diff --git a/ffi/README.md b/ffi/README.md index 3cfaaee62..ee77272e2 100644 --- a/ffi/README.md +++ b/ffi/README.md @@ -438,6 +438,11 @@ Linux's exports, as the merge queue runs on, since a header names its targets. built with the header. A binding checks the two match before any other call, so a header and a library from different builds refuse to mix. - **Panics** abort, as an `extern "C"` function's do. +- **Must-use returns**: a function returning a handle, a buffer, a waker, a value holding + any of those or a `Vec`, such as a record with a `String` field, a poll, or a fallible + call's `bool` is `_MUST_USE`, C23's and C++17's `[[nodiscard]]`, or + GCC's and Clang's `warn_unused_result` before C23, since dropping it leaks or loses an + error. Docs are `/** */`, which Doxygen reads. - **Android**: the build script links the library with 16 KB pages, which Google Play requires of a 64-bit library from 2027-02-01 and an NDK before r28 does not do itself. A panic or a failed check that aborts goes to logcat as `rust2-ffi` and to bionic's abort @@ -547,8 +552,14 @@ packages place it in. from. From C++20, either converts to `std::span`. A `view` or span lives only as long as the bytes it views, and a `view` lent to a callback only for the call; reading one past that is C++'s own undefined behavior, which Clang's `-Wdangling` - refuses for a view or `str()` of a temporary `buf`. A `Vec` is a `std::vector`, passed in place - when of a fixed-width integer other than `u8` (bytes) or `u128` or of a float. One whose + refuses for a view or `str()` of a temporary `buf`, and from Clang 23 `-Wlifetime-safety` + for one kept past its `buf` across statements: `buf` is a `[[gsl::Owner]]`, and `view`, + `slice`, and `items` are `[[gsl::Pointer]]`s. A `Vec` is a `std::vector`. A list + parameter of a fixed-width integer other than `u8` (bytes) or `u128` or of a float, as + `&[f32]` or `Vec`, is a `slice`, which Rust reads in place and copies only if it + keeps it: a pointer and a count, or any contiguous range of `T`, such as a + `std::vector`, a `std::array`, a C array, a braced list, or from C++20 a + `std::span`, which it converts back to. One whose items hold bytes is taken as `items` of `view`s, which points into a `std::vector` of them in place and converts any other range whose items convert and outlive the call, such as a returned `std::vector`, but not a range of temporaries. A `std::vector` moved in @@ -557,7 +568,9 @@ packages place it in. handle is taken as `taken`, a `std::vector` of them moved in as it is, or any other such range moved in, each handle moved out of it. A socket address is a `socket_addr`, an IP address an `ip_addr`, and a `u128` a `u128`, each the C struct. `Option` is `std::optional`, a tuple `std::tuple`, and `Result` a `result`, whose `value()` aborts on an - error. A `[u8; N]` is a `std::array`. + error. A `[u8; N]` is a `std::array`. A `result`, `future`, `task`, or + `buf` is `[[nodiscard]]`, as Rust's `Result` and futures are `#[must_use]`: dropping + one unread loses an error, cancels a call, or reads bytes for nothing. - **Traits** are abstract classes, passed as a `std::unique_ptr` that Rust deletes. - **Closures** are any callable, taken by a template parameter, which Rust calls from any thread, one call at a time. One lent for a call Rust calls only during the call; one Rust @@ -579,8 +592,10 @@ packages place it in. loses nothing. `poll(waker)` polls once; `std::move(f).get()` blocks the thread; `std::move(f).then(exec, callback)` polls on an executor and calls back there, returning a `task` that cancels when destroyed, after which the callback has finished or never - runs and the executor is never called again; and from C++20, `co_await std::move(f).via(exec)` resumes the coroutine on the - executor. An executor is any callable taking a `void()` job to run once, later, on any + runs and the executor is never called again: a `task` dropped before its executor starts + the job never runs, though one dropped at once may lose that race to an executor on + another thread; and from C++20, `co_await std::move(f).via(exec)` resumes the coroutine + on the executor. An executor is any callable taking a `void()` job to run once, later, on any thread: never inline, since a wake may come from inside Rust. Each wake that lands while the future polls polls it again, and a future has one poller at a time, since awaiting it moves it. diff --git a/ffi/moq/moq.c b/ffi/moq/moq.c index ed219f785..cf21fc0c1 100644 --- a/ffi/moq/moq.c +++ b/ffi/moq/moq.c @@ -432,7 +432,7 @@ int main(void) { CHECK(guarded != NULL && moq_hang_catalog_Stats_eq(guarded, want, NULL)); moq_hang_catalog_Stats_free(guarded); moq_status held = 0; - moq_mux_catalog_Producer_Extra_mutate(catalog, lists_stats, &listed_stats, &mux_err, &held); + CHECK(!moq_mux_catalog_Producer_Extra_mutate(catalog, lists_stats, &listed_stats, &mux_err, &held)); CHECK(held == MOQ_STATUS_BORROWED); moq_mux_catalog_Guard_Extra_stats_set(guard, NULL, NULL); CHECK(moq_mux_catalog_Guard_Extra_commit(guard, &mux_err, NULL)); diff --git a/ffi/runtime/rt.hpp b/ffi/runtime/rt.hpp index 029533ad3..67b7c2ca2 100644 --- a/ffi/runtime/rt.hpp +++ b/ffi/runtime/rt.hpp @@ -3,11 +3,14 @@ // namespace, after `detail` names the export's C types. It throws nothing and reads no // type information, so it builds with exceptions and RTTI off. -// Clang's checks of ownership, which a caller enables with `-Wconsumed -Wdangling`: an -// object is used after a move, or a view outlives the bytes it reads. Other compilers see -// nothing. A method callable "unknown" takes a reference parameter's object, whose state -// Clang does not track. +// Clang's checks of ownership, which a caller enables with `-Wconsumed -Wdangling`, and +// from Clang 23 `-Wlifetime-safety`: an object is used after a move, or a view outlives +// the bytes it reads, within a statement or across them. Other compilers see nothing. A +// method callable "unknown" takes a reference parameter's object, whose state Clang does +// not track. An owner holds what a pointer views. #if defined(__clang__) +#define RUST2_FFI_OWNER(T) [[gsl::Owner(T)]] +#define RUST2_FFI_POINTER(T) [[gsl::Pointer(T)]] #define RUST2_FFI_LIFETIMEBOUND [[clang::lifetimebound]] #define RUST2_FFI_CONSUMABLE [[clang::consumable(unconsumed)]] #define RUST2_FFI_CALLABLE [[clang::callable_when("unconsumed", "unknown")]] @@ -15,6 +18,8 @@ #define RUST2_FFI_UNCONSUMED [[clang::return_typestate(unconsumed)]] #define RUST2_FFI_MOVED_FROM [[clang::return_typestate(consumed)]] #else +#define RUST2_FFI_OWNER(T) +#define RUST2_FFI_POINTER(T) #define RUST2_FFI_LIFETIMEBOUND #define RUST2_FFI_CONSUMABLE #define RUST2_FFI_CALLABLE @@ -282,7 +287,7 @@ class borrow { // Bytes lent to a call: text or binary, read during the call and never kept. A contiguous // range, so from C++20 it converts to `std::span`, and back. -class view { +class RUST2_FFI_POINTER(::std::uint8_t) view { const ::std::uint8_t *data_; ::std::size_t size_; @@ -318,10 +323,55 @@ class view { friend struct detail::access; }; +// Numbers lent to a call in place: a pointer and a count, or any contiguous range of `T`, +// such as a `std::vector`, a `std::array`, a C array, a braced list, or from +// C++20 a `std::span`, which it converts back to. +#if defined(__GNUC__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Winit-list-lifetime" +#endif +template +class RUST2_FFI_POINTER(T) slice { + const T *data_; + ::std::size_t size_; + +public: + slice() noexcept : data_(nullptr), size_(0) {} + slice(const T *data, ::std::size_t size) noexcept : data_(data), size_(size) {} + template <::std::size_t N> + slice(const T (&array RUST2_FFI_LIFETIMEBOUND)[N]) noexcept : data_(array), size_(N) {} + // A list's array lives until the call's full-expression ends, which GCC cannot see. + slice(::std::initializer_list list RUST2_FFI_LIFETIMEBOUND) noexcept : data_(list.begin()), size_(list.size()) {} + template ().data())>>, T>>, + class = decltype(::std::declval().size())> + slice(const R &range RUST2_FFI_LIFETIMEBOUND) noexcept : data_(range.data()), size_(range.size()) {} + + const T *data() const noexcept { + return data_; + } + ::std::size_t size() const noexcept { + return size_; + } + bool empty() const noexcept { + return size_ == 0; + } + const T *begin() const noexcept { + return data_; + } + const T *end() const noexcept { + return data_ + size_; + } +}; +#if defined(__GNUC__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif + // Owned bytes: returned by Rust without a copy, or copied from C++. They outlive the object // they came from; a view or span of them lives only as long as they do. A copy of Rust's // shares its bytes, and one moved into a call's `input` goes back to Rust without a copy. -class buf { +class [[nodiscard]] RUST2_FFI_OWNER(::std::uint8_t) buf { // Rust's when `owner` is set, else C++'s, allocated with `new[]` unless empty. detail::c_buf raw_; @@ -443,7 +493,7 @@ inline constexpr bool lasting = ::std::is_reference_v || ::std::is_same_v< // or any other range whose items convert to `T`, such as the `std::vector` a call // returned or a `std::vector`, converted item by item. template -class items { +class RUST2_FFI_POINTER(T) items { ::std::vector converted_; const T *data_; ::std::size_t size_; @@ -533,7 +583,7 @@ class taken { // What a fallible call returns: its value, or the error that stopped it. template -class result { +class [[nodiscard]] result { ::std::variant value_; template <::std::size_t I, class A> @@ -603,7 +653,7 @@ class result { }; template -class result { +class [[nodiscard]] result { ::std::optional error_; public: @@ -752,8 +802,10 @@ void spawn(task &slot, typename Op::raw *raw, Exec exec, F f); // A future running on an executor until it calls back with the output. Destroying it // cancels the future: once that returns, the callback has finished or never runs, and the -// executor is never called again, so it may go too. -class task { +// executor is never called again, so it may go too. A task dropped before its executor +// starts the job never runs; one dropped at once may still lose that race to an executor +// on another thread. +class [[nodiscard]] task { detail::task_node *node_ = nullptr; void reset() noexcept { @@ -784,7 +836,7 @@ class task { // it before it finishes cancels it, which loses nothing, since a value leaves Rust only in // the poll that finishes it. template -class future { +class [[nodiscard]] future { typename Op::raw *raw_; // The waker Rust holds from the last poll, which it reuses when given it again. detail::node *last_ = nullptr; @@ -1000,11 +1052,11 @@ class arena { } }; -// The numbers of `items` as the C array `C`, in place: never null, so an empty one is -// told apart from a missing one. -template -C block(const ::std::vector &items) { - static const T empty{}; +// The numbers of `items`, a `slice` or a `std::vector`, as the C array `C`, in place: never +// null, so an empty one is told apart from a missing one. +template +C block(const R &items) { + static const ::std::remove_cv_t<::std::remove_pointer_t> empty{}; return C{items.empty() ? &empty : items.data(), items.size(), nullptr}; } diff --git a/ffi/src/abi.rs b/ffi/src/abi.rs index aabb51708..02678d464 100644 --- a/ffi/src/abi.rs +++ b/ffi/src/abi.rs @@ -957,6 +957,33 @@ impl<'a> Abi<'a> { } } + /// Whether a value of `ty` holds memory Rust allocated. + pub(crate) fn owns(&self, ty: &Type) -> bool { + self.holds(ty, false) + } + + /// Whether C's copy of a returned `ty` holds memory Rust allocated: a reference + /// returns as an owned copy of what it borrows. + pub(crate) fn returns_owned(&self, ty: &Type) -> bool { + self.holds(ty, true) + } + + fn holds(&self, ty: &Type, refs: bool) -> bool { + match ty { + _ if Abi::is_buf(ty) => true, + Type::Object(_) | Type::List(..) => true, + Type::Ref(_, inner) if refs => self.holds(inner, refs), + Type::Option(inner) | Type::Box(inner) => self.holds(inner, refs), + Type::Tuple(elements) => elements.iter().any(|ty| self.holds(ty, refs)), + Type::Record(i) => self.api.records[*i].fields.iter().any(|f| self.holds(&f.ty, refs)), + Type::Enum(i) => self.api.enums[*i] + .variants + .iter() + .any(|v| v.fields.iter().any(|f| self.holds(&f.ty, refs))), + _ => false, + } + } + /// Whether `ty` crosses as a `_buf`. pub(crate) fn is_buf(ty: &Type) -> bool { matches!( diff --git a/ffi/src/c.rs b/ffi/src/c.rs index 7d5ac6064..075c98d44 100644 --- a/ffi/src/c.rs +++ b/ffi/src/c.rs @@ -34,8 +34,18 @@ pub(crate) fn header(abi: &Abi<'_>, packages: &str) -> (String, u64, BTreeMap\n#include \n#include \n\n\ + /** Marks a function whose result the caller must use, since dropping it leaks or\n * loses something: a handle, bytes, a Vec, a poll, or whether a call failed. */\n\ + #ifndef {upper}_MUST_USE\n\ + #if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || \\\n (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L)\n\ + #define {upper}_MUST_USE [[nodiscard]]\n\ + #elif defined(__GNUC__)\n\ + #define {upper}_MUST_USE __attribute__((warn_unused_result))\n\ + #else\n\ + #define {upper}_MUST_USE\n\ + #endif\n\ + #endif\n\n\ #ifdef __cplusplus\nextern \"C\" {{\n#endif\n\n\ - /* A hash of everything below, which {p}_contract returns from a library built with\n * this header. Check it before any other call: a header and a library that declare\n * different APIs must not mix. */\n\ + /** A hash of everything below, which {p}_contract returns from a library built with\n * this header. Check it before any other call: a header and a library that declare\n * different APIs must not mix. */\n\ #define {upper}_CONTRACT ((uint64_t)0x{contract:016x}ULL)\n\ uint64_t {p}_contract(void);\n\n\ {body}\n\ @@ -113,13 +123,26 @@ impl Header<'_> { decl(self.abi, ty, name) } - fn prototype(&self, sig: &Sig) -> String { + /// `sig`'s declaration, marked must-use if dropping what it returns leaks or loses + /// something: a handle, bytes, a waker, a value that `owns` memory, such as a `Vec`, a + /// poll, or whether a `fallible` call failed. + fn prototype(&self, sig: &Sig, owns: bool, fallible: bool) -> String { let params: Vec = sig.params.iter().map(|(n, ty)| self.decl(ty, n)).collect(); let params = match params.is_empty() { true => "void".to_string(), false => params.join(", "), }; - format!("{};", self.decl(&sig.ret, &format!("{}({params})", sig.name))) + let must_use = match &sig.ret { + Ty::Handle { .. } | Ty::Future(_) | Ty::Buf | Ty::Waker | Ty::Poll => true, + Ty::Struct(_) => owns, + Ty::Bool => fallible, + _ => false, + }; + let attr = match must_use { + true => format!("{}_MUST_USE ", self.abi.prefix.to_uppercase()), + false => String::new(), + }; + format!("{attr}{};", self.decl(&sig.ret, &format!("{}({params})", sig.name))) } /// Everything the header declares but its contract. @@ -132,39 +155,39 @@ impl Header<'_> { .map(|(i, t)| format!("\n * {i}: {t}")) .collect(); self.line(format!( - "/* The index of the library's target among those this header serves:{targets} */\nuint32_t {p}_target(void);\n" + "/** The index of the library's target among those this header serves:{targets} */\nuint32_t {p}_target(void);\n" )); let statuses: String = (crate::abi::STATUSES.iter().enumerate()) .map(|(n, (status, _))| format!("\t{upper}_STATUS_{} = {},\n", status.to_uppercase(), n + 1)) .collect(); self.line(format!( - "/* Why a call failed a check of a handle, before it ran any Rust: a borrow or move\n * Rust's borrow checker would refuse. A function that can fail one takes a status\n * last, through which it writes the failure, returning a zeroed value to ignore;\n * passed null, it aborts with the message instead. */\ntypedef int32_t {p}_status;\nenum {{\n{statuses}}};\n\n/* What a status says broke. */\nconst char *{p}_status_message({p}_status status);\n" + "/** Why a call failed a check of a handle, before it ran any Rust: a borrow or move\n * Rust's borrow checker would refuse. A function that can fail one takes a status\n * last, through which it writes the failure, returning a zeroed value to ignore;\n * passed null, it aborts with the message instead. */\ntypedef int32_t {p}_status;\nenum {{\n{statuses}}};\n\n/** What a status says broke. */\nconst char *{p}_status_message({p}_status status);\n" )); self.line(format!( - "/* Bytes. Returned, an owned buffer to free once with {p}_buf_free, or pass back to\n * Rust by value, ptr and len narrowed to any range of its bytes. Passed by value, one\n * whose owner is set is Rust's from then on, taken without a copy, and one whose owner\n * is NULL is a view Rust reads during the call and never frees; in a value passed by\n * pointer, or an array's item, either is only read. A null ptr is None. */\ntypedef struct {p}_buf {{\n\tconst uint8_t *ptr;\n\tsize_t len;\n\tvoid *owner;\n}} {p}_buf;\n\nvoid {p}_buf_free({p}_buf buf);\n\n/* An owned copy of view's bytes: what a closure or reader C implements returns Rust,\n * which then owns it. */\n{p}_buf {p}_buf_copy({p}_buf view);\n\n/* A second owned buffer of an owned buffer's bytes, sharing them without a copy: what\n * a caller passes Rust while keeping buf. */\n{p}_buf {p}_buf_clone({p}_buf buf);\n" + "/** Bytes. Returned, an owned buffer to free once with {p}_buf_free, or pass back to\n * Rust by value, ptr and len narrowed to any range of its bytes. Passed by value, one\n * whose owner is set is Rust's from then on, taken without a copy, and one whose owner\n * is NULL is a view Rust reads during the call and never frees; in a value passed by\n * pointer, or an array's item, either is only read. A null ptr is None. */\ntypedef struct {p}_buf {{\n\tconst uint8_t *ptr;\n\tsize_t len;\n\tvoid *owner;\n}} {p}_buf;\n\nvoid {p}_buf_free({p}_buf buf);\n\n/** An owned copy of view's bytes: what a closure or reader C implements returns Rust,\n * which then owns it. */\n{upper}_MUST_USE {p}_buf {p}_buf_copy({p}_buf view);\n\n/** A second owned buffer of an owned buffer's bytes, sharing them without a copy: what\n * a caller passes Rust while keeping buf. */\n{upper}_MUST_USE {p}_buf {p}_buf_clone({p}_buf buf);\n" )); self.line(format!( - "/* A u128: lo holds its low 64 bits and hi its high 64. */\ntypedef struct {p}_u128 {{\n\tuint64_t lo;\n\tuint64_t hi;\n}} {p}_u128;\n" + "/** A u128: lo holds its low 64 bits and hi its high 64. */\ntypedef struct {p}_u128 {{\n\tuint64_t lo;\n\tuint64_t hi;\n}} {p}_u128;\n" )); self.line(format!( "typedef struct {p}_duration {{\n\tuint64_t secs;\n\tuint32_t nanos;\n}} {p}_duration;\n" )); self.line(format!( - "/* An IPv4 address, in network order. */\ntypedef struct {p}_ipv4_addr {{\n\tuint8_t octets[4];\n}} {p}_ipv4_addr;\n\n/* An IPv6 address, in network order. */\ntypedef struct {p}_ipv6_addr {{\n\tuint8_t octets[16];\n}} {p}_ipv6_addr;\n\n/* An IP address: ip.v6 if v6, else ip.v4. */\ntypedef struct {p}_ip_addr {{\n\tbool v6;\n\tunion {{\n\t\t{p}_ipv4_addr v4;\n\t\t{p}_ipv6_addr v6;\n\t}} ip;\n}} {p}_ip_addr;\n\n/* An IPv4 socket address, its port in the host's order. */\ntypedef struct {p}_socket_addr_v4 {{\n\t{p}_ipv4_addr ip;\n\tuint16_t port;\n}} {p}_socket_addr_v4;\n\n/* An IPv6 socket address, its port in the host's order. */\ntypedef struct {p}_socket_addr_v6 {{\n\t{p}_ipv6_addr ip;\n\tuint16_t port;\n\tuint32_t flowinfo;\n\tuint32_t scope_id;\n}} {p}_socket_addr_v6;\n\n/* A socket address: addr.v6 if v6, else addr.v4. */\ntypedef struct {p}_socket_addr {{\n\tbool v6;\n\tunion {{\n\t\t{p}_socket_addr_v4 v4;\n\t\t{p}_socket_addr_v6 v6;\n\t}} addr;\n}} {p}_socket_addr;\n" + "/** An IPv4 address, in network order. */\ntypedef struct {p}_ipv4_addr {{\n\tuint8_t octets[4];\n}} {p}_ipv4_addr;\n\n/** An IPv6 address, in network order. */\ntypedef struct {p}_ipv6_addr {{\n\tuint8_t octets[16];\n}} {p}_ipv6_addr;\n\n/** An IP address: ip.v6 if v6, else ip.v4. */\ntypedef struct {p}_ip_addr {{\n\tbool v6;\n\tunion {{\n\t\t{p}_ipv4_addr v4;\n\t\t{p}_ipv6_addr v6;\n\t}} ip;\n}} {p}_ip_addr;\n\n/** An IPv4 socket address, its port in the host's order. */\ntypedef struct {p}_socket_addr_v4 {{\n\t{p}_ipv4_addr ip;\n\tuint16_t port;\n}} {p}_socket_addr_v4;\n\n/** An IPv6 socket address, its port in the host's order. */\ntypedef struct {p}_socket_addr_v6 {{\n\t{p}_ipv6_addr ip;\n\tuint16_t port;\n\tuint32_t flowinfo;\n\tuint32_t scope_id;\n}} {p}_socket_addr_v6;\n\n/** A socket address: addr.v6 if v6, else addr.v4. */\ntypedef struct {p}_socket_addr {{\n\tbool v6;\n\tunion {{\n\t\t{p}_socket_addr_v4 v4;\n\t\t{p}_socket_addr_v6 v6;\n\t}} addr;\n}} {p}_socket_addr;\n" )); self.line(format!( - "/* Wakes a future's poller: wake may be called from any thread, any number of\n * times, until drop releases data. A poll passing the same wake and data again\n * reuses the waker. Either function may be null. One Rust returns is the caller's,\n * to drop once or pass back into Rust. */\ntypedef struct {p}_waker {{\n\tvoid (*wake)(void *data);\n\tvoid (*drop)(void *data);\n\tvoid *data;\n}} {p}_waker;\n" + "/** Wakes a future's poller: wake may be called from any thread, any number of\n * times, until drop releases data. A poll passing the same wake and data again\n * reuses the waker. Either function may be null. One Rust returns is the caller's,\n * to drop once or pass back into Rust. */\ntypedef struct {p}_waker {{\n\tvoid (*wake)(void *data);\n\tvoid (*drop)(void *data);\n\tvoid *data;\n}} {p}_waker;\n" )); if api.unsent() { self.line(format!( - "/* A value that is not Send, freed on another thread than the one that made it,\n * drops on that thread at its next call on such a value, or when it exits. A thread\n * running a loop that may call nothing for a while passes {p}_thread_wake a waker,\n * replacing any earlier one, which a free elsewhere wakes from its own thread as it\n * queues a drop: the waker then schedules {p}_thread_drain on the thread, which drops\n * each value queued for the thread it runs on. */\nvoid {p}_thread_wake({p}_waker wake);\nvoid {p}_thread_drain(void);\n" + "/** A value that is not Send, freed on another thread than the one that made it,\n * drops on that thread at its next call on such a value, or when it exits. A thread\n * running a loop that may call nothing for a while passes {p}_thread_wake a waker,\n * replacing any earlier one, which a free elsewhere wakes from its own thread as it\n * queues a drop: the waker then schedules {p}_thread_drain on the thread, which drops\n * each value queued for the thread it runs on. */\nvoid {p}_thread_wake({p}_waker wake);\nvoid {p}_thread_drain(void);\n" )); } self.line(format!( - "/* A future C implements, of nothing: Rust polls it from any thread with a waker of\n * its own each time, which C wakes once the future can make progress and drops once,\n * until poll returns true, and calls free with data once it drops the future, done or\n * not. free may be null. */\ntypedef struct {p}_foreign_future {{\n\tbool (*poll)(void *data, {p}_waker waker);\n\tvoid (*free)(void *data);\n\tvoid *data;\n}} {p}_foreign_future;\n" + "/** A future C implements, of nothing: Rust polls it from any thread with a waker of\n * its own each time, which C wakes once the future can make progress and drops once,\n * until poll returns true, and calls free with data once it drops the future, done or\n * not. free may be null. */\ntypedef struct {p}_foreign_future {{\n\tbool (*poll)(void *data, {p}_waker waker);\n\tvoid (*free)(void *data);\n\tvoid *data;\n}} {p}_foreign_future;\n" )); self.line(format!( - "/* A reader C implements, which Rust reads and seeks only during the call it is passed\n * to, one call at a time from any thread. read reads up to len bytes into buf,\n * writing how many to *n, none only at the end; seek moves offset from whence, SEEK_SET,\n * SEEK_CUR, or SEEK_END, writing the position from the start to *position; from SEEK_SET,\n * offset's bits are a uint64_t, which may pass INT64_MAX. Each\n * returns whether it succeeded, else writing its error's message to *err as a buffer\n * {p}_buf_copy made. */\ntypedef struct {p}_foreign_reader {{\n\tbool (*read)(void *data, uint8_t *buf, size_t len, size_t *n, {p}_buf *err);\n\tbool (*seek)(void *data, int whence, int64_t offset, uint64_t *position, {p}_buf *err);\n\tvoid *data;\n}} {p}_foreign_reader;\n" + "/** A reader C implements, which Rust reads and seeks only during the call it is passed\n * to, one call at a time from any thread. read reads up to len bytes into buf,\n * writing how many to *n, none only at the end; seek moves offset from whence, SEEK_SET,\n * SEEK_CUR, or SEEK_END, writing the position from the start to *position; from SEEK_SET,\n * offset's bits are a uint64_t, which may pass INT64_MAX. Each\n * returns whether it succeeded, else writing its error's message to *err as a buffer\n * {p}_buf_copy made. */\ntypedef struct {p}_foreign_reader {{\n\tbool (*read)(void *data, uint8_t *buf, size_t len, size_t *n, {p}_buf *err);\n\tbool (*seek)(void *data, int whence, int64_t offset, uint64_t *position, {p}_buf *err);\n\tvoid *data;\n}} {p}_foreign_reader;\n" )); self.line(format!( "typedef enum {p}_poll {{\n\t{upper}_POLL_PENDING = 0,\n\t{upper}_POLL_READY = 1,\n\t{upper}_POLL_ERROR = 2,\n}} {p}_poll;\n" @@ -197,7 +220,7 @@ impl Header<'_> { let bound = abi.rt("bound"); let upper = bound.to_uppercase(); self.line(format!( - "/* What a range's start or end bound does: nothing, include its value, or exclude it. */\ntypedef enum {bound} {{\n\t{upper}_UNBOUNDED = 0,\n\t{upper}_INCLUDED = 1,\n\t{upper}_EXCLUDED = 2,\n}} {bound};\n" + "/** What a range's start or end bound does: nothing, include its value, or exclude it. */\ntypedef enum {bound} {{\n\t{upper}_UNBOUNDED = 0,\n\t{upper}_INCLUDED = 1,\n\t{upper}_EXCLUDED = 2,\n}} {bound};\n" )); } @@ -272,13 +295,7 @@ impl Header<'_> { for (i, record) in api.records.iter().enumerate() { let name = abi.record(i); self.line(format!("/* {} */", abi.api.rust(&record.path, &record.args)).trim_end()); - self.value_functions( - &name, - Ty::Struct(name.clone()), - record.traits, - record.opaque.is_none(), - abi.value_status(&Type::Record(i)), - ); + self.value_functions(&name, &Type::Record(i), record.traits, record.opaque.is_none()); let owner = Ty::Struct(name.clone()); for method in &record.methods { self.function(method, Some(&owner)); @@ -292,13 +309,7 @@ impl Header<'_> { continue; } self.line(format!("/* {} */", abi.api.rust(&e.path, &e.args))); - self.value_functions( - &name, - ty.clone(), - e.traits, - !e.plain(), - abi.value_status(&Type::Enum(i)), - ); + self.value_functions(&name, &Type::Enum(i), e.traits, !e.plain()); for method in &e.methods { self.function(method, Some(&ty)); } @@ -332,7 +343,9 @@ impl Header<'_> { false => String::new(), }; if t.clone { - self.line(format!("{name} *{name}_clone(const {name} *self{status});")); + self.line(format!( + "{upper}_MUST_USE {name} *{name}_clone(const {name} *self{status});" + )); } if t.eq { self.line(format!("bool {name}_eq(const {name} *a, const {name} *b{status});")); @@ -341,15 +354,19 @@ impl Header<'_> { self.line(format!("uint64_t {name}_hash(const {name} *self{status});")); } if t.display { - self.line(format!("{p}_buf {name}_to_string(const {name} *self{status});")); + self.line(format!( + "{upper}_MUST_USE {p}_buf {name}_to_string(const {name} *self{status});" + )); } if t.debug { - self.line(format!("{p}_buf {name}_debug(const {name} *self{status});")); + self.line(format!( + "{upper}_MUST_USE {p}_buf {name}_debug(const {name} *self{status});" + )); } if t.default { - self.line(format!("{name} *{name}_default(void);")); + self.line(format!("{upper}_MUST_USE {name} *{name}_default(void);")); if !object.send { - self.line(format!("{name} *{name}_default_homed(void);")); + self.line(format!("{upper}_MUST_USE {name} *{name}_default_homed(void);")); } } let owner = Ty::Handle { @@ -401,7 +418,7 @@ impl Header<'_> { elem => self.decl(&Ty::In(Box::new(elem)), "ptr"), }; self.line(format!( - "/* A Vec. Passed in, an array Rust reads during the call and never frees. Returned,\n * an array to free once with {name}_free, which frees its first len elements too:\n * set len to 0 first to keep them. A null ptr is None. */\ntypedef struct {name} {{\n\t{ptr};\n\tsize_t len;\n\tvoid *owner;\n}} {name};\n\nvoid {name}_free({name} vec);\n" + "/** A Vec. Passed in, an array Rust reads during the call and never frees. Returned,\n * an array to free once with {name}_free, which frees its first len elements too:\n * set len to 0 first to keep them. A null ptr is None. */\ntypedef struct {name} {{\n\t{ptr};\n\tsize_t len;\n\tvoid *owner;\n}} {name};\n\nvoid {name}_free({name} vec);\n" )); return; } @@ -428,7 +445,7 @@ impl Header<'_> { let record = &abi.api.records[i]; if let Some(opaque) = &record.opaque { self.line(format!( - "{}typedef struct {name} {{\n\t/* Its bytes, which only Rust reads: copy it, but never make or change one. */\n\t{} opaque[{}];\n}} {name};\n", + "{}typedef struct {name} {{\n\t/** Its bytes, which only Rust reads: copy it, but never make or change one. */\n\t{} opaque[{}];\n}} {name};\n", comment(&deprecation(&record.docs, record.deprecated.as_deref()), ""), c_unit(opaque.unit()), opaque.units() @@ -498,10 +515,12 @@ impl Header<'_> { )); } - /// The functions a value type's std traits export, and its `free` if it owns memory. - fn value_functions(&mut self, name: &str, ty: Ty, traits: Traits, free: bool, status: bool) { + /// The functions a value type's std traits export, and its `free` if it has one. + fn value_functions(&mut self, name: &str, value: &Type, traits: Traits, free: bool) { let p = &self.abi.prefix; - let status = match status { + let upper = p.to_uppercase(); + let ty = self.abi.ty(value); + let status = match self.abi.value_status(value) { true => format!(", {p}_status *status"), false => String::new(), }; @@ -518,13 +537,17 @@ impl Header<'_> { self.line(format!("uint64_t {name}_hash({this}{status});")); } if traits.display { - self.line(format!("{p}_buf {name}_to_string({this}{status});")); + self.line(format!("{upper}_MUST_USE {p}_buf {name}_to_string({this}{status});")); } if traits.debug { - self.line(format!("{p}_buf {name}_debug({this}{status});")); + self.line(format!("{upper}_MUST_USE {p}_buf {name}_debug({this}{status});")); } if traits.default { - self.line(format!("{} {name}_default(void);", self.decl(&ty, ""))); + let must_use = match self.abi.returns_owned(value) { + true => format!("{upper}_MUST_USE "), + false => String::new(), + }; + self.line(format!("{must_use}{} {name}_default(void);", self.decl(&ty, ""))); } } @@ -628,13 +651,13 @@ impl Header<'_> { .into_iter() .chain(homed) { - let prototype = self.prototype(&sig); + let prototype = self.prototype(&sig, false, false); self.line(prototype); } return; } for sig in std::iter::once(export.call.clone()).chain(export.homed_call()) { - let prototype = self.prototype(&sig); + let prototype = self.prototype(&sig, self.abi.returns_owned(&function.ok), function.err.is_some()); self.line(prototype); } } @@ -725,7 +748,7 @@ fn link(abi: &Abi<'_>, target: crate::doc::Target<'_>) -> String { } } -/// A C comment holding `docs`, each line indented by `indent`, or nothing for none. +/// A Doxygen comment, `/** */`, holding `docs`, each line indented by `indent`, or nothing for none. fn comment(docs: &str, indent: &str) -> String { if docs.is_empty() { return String::new(); @@ -736,7 +759,7 @@ fn comment(docs: &str, indent: &str) -> String { let mut out = String::new(); for (i, line) in lines.iter().enumerate() { let lead = match i { - 0 => "/* ", + 0 => "/** ", _ => " * ", }; out.push_str(indent); diff --git a/ffi/src/cpp.rs b/ffi/src/cpp.rs index 083357587..892f70a16 100644 --- a/ffi/src/cpp.rs +++ b/ffi/src/cpp.rs @@ -227,6 +227,11 @@ impl<'a> Header<'a> { } match ty { Type::Option(inner) if Abi::is_buf(inner) => format!("::std::optional<::{}::input>", self.ns), + // Numbers lent in place, which Rust copies if it keeps them. + Type::Option(inner) if inner.base().block().is_some() => { + format!("::std::optional<{}>", self.slice(inner.base())) + } + Type::List(..) if ty.block().is_some() => self.slice(ty), // Moved out of, each handle as a handle taken by value is. Type::Option(inner) if matches!(inner.base(), Type::List(_, elem) if moves(abi, elem)) => { format!("::std::optional<{}>", self.items(inner.base())) @@ -284,6 +289,12 @@ impl<'a> Header<'a> { } } + /// The `slice` a parameter of the block `ty` takes. + fn slice(&self, ty: &Type) -> String { + let elem = ty.block().expect("a block"); + format!("::{}::slice<{}>", self.ns, self.owned(elem)) + } + /// The C++ type a parameter's `Vec`, `Option`, or tuple holds a `ty` as: bytes as a view. fn held(&self, ty: &Type) -> String { match ty { @@ -2022,7 +2033,9 @@ fn runtime_names() -> impl Iterator { let rest = ["class ", "struct ", "using "] .iter() .find_map(|kw| line.strip_prefix(kw))?; - rest.split(|c: char| !(c.is_ascii_alphanumeric() || c == '_')).next() + // Past the class's attributes, such as `[[nodiscard]]` and `RUST2_FFI_OWNER(T)`. + let name = (rest.split(' ')).find(|word| !word.starts_with("[[") && !word.starts_with("RUST2_FFI_"))?; + name.split(|c: char| !(c.is_ascii_alphanumeric() || c == '_')).next() }); std::iter::once("detail").chain(names) } diff --git a/ffi/src/glue.rs b/ffi/src/glue.rs index ff0563f7d..09cebdd19 100644 --- a/ffi/src/glue.rs +++ b/ffi/src/glue.rs @@ -1321,28 +1321,12 @@ impl Gen<'_> { "unsafe {{ rt::Object::<{}>::free({e}) }};", self.object_path(*i) )), - Type::Record(i) if self.owns(ty) => Some(format!("free_{}({e});", self.abi.record(*i))), - Type::Enum(i) if self.owns(ty) => Some(format!("free_{}({e});", self.abi.enumeration(*i))), + Type::Record(i) if self.abi.owns(ty) => Some(format!("free_{}({e});", self.abi.record(*i))), + Type::Enum(i) if self.abi.owns(ty) => Some(format!("free_{}({e});", self.abi.enumeration(*i))), _ => None, } } - /// Whether a value of `ty` holds memory Rust allocated. - fn owns(&self, ty: &Type) -> bool { - match ty { - _ if Abi::is_buf(ty) => true, - Type::Object(_) | Type::List(..) => true, - Type::Option(inner) | Type::Box(inner) => self.owns(inner), - Type::Tuple(elements) => elements.iter().any(|ty| self.owns(ty)), - Type::Record(i) => self.abi.api.records[*i].fields.iter().any(|f| self.owns(&f.ty)), - Type::Enum(i) => self.abi.api.enums[*i] - .variants - .iter() - .any(|v| v.fields.iter().any(|f| self.owns(&f.ty))), - _ => false, - } - } - fn lib(&mut self) { let api = self.abi.api; self.line(format!( @@ -1773,7 +1757,7 @@ impl Gen<'_> { "fn lower_{name}(v: {path}) -> {name} {{\n\tlet {pattern} = v;\n\t{name} {{ {} }}\n}}\n", lowered.join(", ") )); - if self.owns(&ty) { + if self.abi.owns(&ty) { let frees: Vec = record .fields .iter() @@ -2042,7 +2026,7 @@ impl Gen<'_> { self.item(format!( "fn lower_{name}(v: {path}) -> {name} {{\n\tmatch v {{{lower}{wildcard}\n\t}}\n}}\n" )); - if self.owns(&ty) { + if self.abi.owns(&ty) { self.item(format!( "fn free_{name}(c: {name}) {{\n\tmatch c.tag {{{free}\n\t\t_ => {{}}\n\t}}\n}}\n" )); diff --git a/ffi/surface/api/c.h b/ffi/surface/api/c.h index f9f324f56..de57d244d 100644 --- a/ffi/surface/api/c.h +++ b/ffi/surface/api/c.h @@ -4,10 +4,20 @@ #include #include #include +#ifndef API_MUST_USE +#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || \ + (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) +#define API_MUST_USE [[nodiscard]] +#elif defined(__GNUC__) +#define API_MUST_USE __attribute__((warn_unused_result)) +#else +#define API_MUST_USE +#endif +#endif #ifdef __cplusplus extern "C" { #endif -#define API_CONTRACT ((uint64_t)0x4ef55d1d8a723c39ULL) +#define API_CONTRACT ((uint64_t)0x90b55a88885e2638ULL) uint64_t api_contract(void); uint32_t api_target(void); typedef int32_t api_status; @@ -27,8 +37,8 @@ typedef struct api_buf { void *owner; } api_buf; void api_buf_free(api_buf buf); -api_buf api_buf_copy(api_buf view); -api_buf api_buf_clone(api_buf buf); +API_MUST_USE api_buf api_buf_copy(api_buf view); +API_MUST_USE api_buf api_buf_clone(api_buf buf); typedef struct api_u128 { uint64_t lo; uint64_t hi; @@ -1128,86 +1138,86 @@ void api_Packet_free(api_Packet *self); void api_Hasher_free(api_Hasher *self); void api_Size_free(api_Size *self); bool api_Size_eq(const api_Size *a, const api_Size *b); -api_buf api_Size_debug(const api_Size *self); +API_MUST_USE api_buf api_Size_debug(const api_Size *self); void api_Point_free(api_Point *self); bool api_Point_eq(const api_Point *a, const api_Point *b); -api_buf api_Point_debug(const api_Point *self); +API_MUST_USE api_buf api_Point_debug(const api_Point *self); api_Point api_Point_default(void); api_Point api_Point_offset(const api_Point *self, int32_t dx, int32_t dy); int32_t api_Point_get_x(void); void api_Label_free(api_Label *self); bool api_Label_eq(const api_Label *a, const api_Label *b); -api_buf api_Label_debug(const api_Label *self); +API_MUST_USE api_buf api_Label_debug(const api_Label *self); void api_Note_free(api_Note *self); bool api_Note_eq(const api_Note *a, const api_Note *b); -api_buf api_Note_debug(const api_Note *self); -api_Note api_Note_default(void); +API_MUST_USE api_buf api_Note_debug(const api_Note *self); +API_MUST_USE api_Note api_Note_default(void); void api_Reading_free(api_Reading *self); bool api_Reading_eq(const api_Reading *a, const api_Reading *b); -api_buf api_Reading_debug(const api_Reading *self); -api_option_Reading api_Reading_next(const api_Reading *self); +API_MUST_USE api_buf api_Reading_debug(const api_Reading *self); +API_MUST_USE api_option_Reading api_Reading_next(const api_Reading *self); void api_Packaged_free(api_Packaged *self); bool api_Packaged_eq(const api_Packaged *a, const api_Packaged *b); -api_buf api_Packaged_debug(const api_Packaged *self); +API_MUST_USE api_buf api_Packaged_debug(const api_Packaged *self); api_Point api_Packaged_point(const api_Packaged *self); api_Shape api_Packaged_shape(const api_Packaged *self); void api_Atlas_free(api_Atlas *self); bool api_Atlas_eq(const api_Atlas *a, const api_Atlas *b); -api_buf api_Atlas_debug(const api_Atlas *self); -api_Atlas api_Atlas_with(const api_Atlas *self, api_buf name, api_Point at); +API_MUST_USE api_buf api_Atlas_debug(const api_Atlas *self); +API_MUST_USE api_Atlas api_Atlas_with(const api_Atlas *self, api_buf name, api_Point at); void api_Span_free(api_Span *self); bool api_Span_eq(const api_Span *a, const api_Span *b); -api_buf api_Span_debug(const api_Span *self); +API_MUST_USE api_buf api_Span_debug(const api_Span *self); void api_Window_free(api_Window *self); bool api_Window_eq(const api_Window *a, const api_Window *b); -api_buf api_Window_debug(const api_Window *self); +API_MUST_USE api_buf api_Window_debug(const api_Window *self); bool api_Window_contains(const api_Window *self, uint64_t n); bool api_Ticket_eq(const api_Ticket *a, const api_Ticket *b); -api_buf api_Ticket_debug(const api_Ticket *self); +API_MUST_USE api_buf api_Ticket_debug(const api_Ticket *self); api_Ticket api_Ticket_new(uint32_t number); uint32_t api_Ticket_number(const api_Ticket *self); uint32_t api_Ticket_clones(void); void api_Seat_free(api_Seat *self); bool api_Seat_eq(const api_Seat *a, const api_Seat *b, api_status *status); -api_buf api_Seat_debug(const api_Seat *self, api_status *status); +API_MUST_USE api_buf api_Seat_debug(const api_Seat *self, api_status *status); uint64_t api_Seat_count(const api_Seat *self, api_status *status); bool api_Stamp_eq(const api_Stamp *a, const api_Stamp *b); -api_buf api_Stamp_debug(const api_Stamp *self); +API_MUST_USE api_buf api_Stamp_debug(const api_Stamp *self); api_Stamp api_Stamp_from_millis(uint64_t millis); uint64_t api_Stamp_secs(const api_Stamp *self); api_Stamp api_Stamp_whole(const api_Stamp *self); bool api_Stamp_later(const api_Stamp *self, api_Stamp other); bool api_Moment_eq(const api_Moment *a, const api_Moment *b); -api_buf api_Moment_debug(const api_Moment *self); +API_MUST_USE api_buf api_Moment_debug(const api_Moment *self); api_option_Moment api_Moment_new(uint64_t ticks, uint64_t rate); uint64_t api_Moment_millis(const api_Moment *self); api_Moment api_Moment_after(const api_Moment *self, uint64_t ticks); bool api_LongArray_eq(const api_LongArray *a, const api_LongArray *b); -api_buf api_LongArray_debug(const api_LongArray *self); +API_MUST_USE api_buf api_LongArray_debug(const api_LongArray *self); api_LongArray api_LongArray_new(uint64_t low, uint64_t high); uint64_t api_LongArray_c_(const api_LongArray *self); void api_LongArray_also(const api_LongArray *self, void (*f)(void *data, uint64_t), void *f_data); void api_JvmField_free(api_JvmField *self); bool api_JvmField_eq(const api_JvmField *a, const api_JvmField *b); -api_buf api_JvmField_debug(const api_JvmField *self); +API_MUST_USE api_buf api_JvmField_debug(const api_JvmField *self); void api_JvmStatic_free(api_JvmStatic *self); bool api_JvmStatic_eq(const api_JvmStatic *a, const api_JvmStatic *b); -api_buf api_JvmStatic_debug(const api_JvmStatic *self); +API_MUST_USE api_buf api_JvmStatic_debug(const api_JvmStatic *self); void api_OptIn_free(api_OptIn *self); bool api_OptIn_eq(const api_OptIn *a, const api_OptIn *b); -api_buf api_OptIn_debug(const api_OptIn *self); +API_MUST_USE api_buf api_OptIn_debug(const api_OptIn *self); bool api_Wide_eq(const api_Wide *a, const api_Wide *b); -api_buf api_Wide_debug(const api_Wide *self); +API_MUST_USE api_buf api_Wide_debug(const api_Wide *self); api_Wide api_Wide_new(uint64_t seed); uint64_t api_Wide_sum(const api_Wide *self); void api_Clocked_free(api_Clocked *self); bool api_Clocked_eq(const api_Clocked *a, const api_Clocked *b); -api_buf api_Clocked_debug(const api_Clocked *self); +API_MUST_USE api_buf api_Clocked_debug(const api_Clocked *self); bool api_Rated_eq(const api_Rated *a, const api_Rated *b); -api_buf api_Rated_debug(const api_Rated *self); +API_MUST_USE api_buf api_Rated_debug(const api_Rated *self); api_Rated api_Rated_new(uint64_t count, uint64_t scale); uint64_t api_Rated_scale(const api_Rated *self); -api_buf api_Score_debug(const api_Score *self); +API_MUST_USE api_buf api_Score_debug(const api_Score *self); api_Score api_Score_of(uint64_t count); uint64_t api_Score_count(const api_Score *self); void api_Score_add(api_Score *self, api_Score other); @@ -1216,7 +1226,7 @@ uint64_t api_Score_take(api_Score *self); uint64_t api_Score_note(api_Score *self, const api_Mark *mark, api_status *status); void api_Score_absorb(api_Score *self, api_Score other, api_Score *other_out, uint64_t *out0, uint64_t *out1); bool api_Hits_eq(const api_Hits *a, const api_Hits *b); -api_buf api_Hits_debug(const api_Hits *self); +API_MUST_USE api_buf api_Hits_debug(const api_Hits *self); api_Hits api_Hits_default(void); uint64_t api_Hits_hits_get(const api_Hits *self); void api_Hits_hits_set(api_Hits *self, uint64_t value); @@ -1226,7 +1236,7 @@ api_Hits api_Hits_of(uint64_t hits, uint64_t misses); void api_Hits_add(api_Hits *self, api_Hits other); bool api_Hits_eq_(api_Hits *self, api_Hits other); bool api_Extent_eq(const api_Extent *a, const api_Extent *b); -api_buf api_Extent_debug(const api_Extent *self); +API_MUST_USE api_buf api_Extent_debug(const api_Extent *self); uint64_t api_Extent_start_get(const api_Extent *self); void api_Extent_start_set(api_Extent *self, uint64_t value); api_Extent api_Extent_new(uint64_t start, uint64_t len); @@ -1234,260 +1244,260 @@ uint64_t api_Extent_end(const api_Extent *self); uint64_t api_Extent_slide(api_Extent *self, uint64_t by); void api_Pair_Size_u8_free(api_Pair_Size_u8 *self); bool api_Pair_Size_u8_eq(const api_Pair_Size_u8 *a, const api_Pair_Size_u8 *b); -api_buf api_Pair_Size_u8_debug(const api_Pair_Size_u8 *self); +API_MUST_USE api_buf api_Pair_Size_u8_debug(const api_Pair_Size_u8 *self); api_Pair_u8_Size api_Pair_Size_u8_swap(const api_Pair_Size_u8 *self); void api_Pair_non_zero_u16_free(api_Pair_non_zero_u16 *self); bool api_Pair_non_zero_u16_eq(const api_Pair_non_zero_u16 *a, const api_Pair_non_zero_u16 *b); -api_buf api_Pair_non_zero_u16_debug(const api_Pair_non_zero_u16 *self); +API_MUST_USE api_buf api_Pair_non_zero_u16_debug(const api_Pair_non_zero_u16 *self); api_Pair_non_zero_u16 api_Pair_non_zero_u16_swap(const api_Pair_non_zero_u16 *self); bool api_Pair_non_zero_u16_even(const api_Pair_non_zero_u16 *self); void api_Pair_u32_free(api_Pair_u32 *self); bool api_Pair_u32_eq(const api_Pair_u32 *a, const api_Pair_u32 *b); -api_buf api_Pair_u32_debug(const api_Pair_u32 *self); +API_MUST_USE api_buf api_Pair_u32_debug(const api_Pair_u32 *self); api_Pair_u32 api_Pair_u32_swap(const api_Pair_u32 *self); bool api_Pair_u32_even(const api_Pair_u32 *self); uint32_t api_Pair_u32_sum(const api_Pair_u32 *self); api_Pair_u8_Size api_Pair_u32_beside_Size(const api_Pair_u32 *self, api_Size right); void api_Pair_u8_Size_free(api_Pair_u8_Size *self); bool api_Pair_u8_Size_eq(const api_Pair_u8_Size *a, const api_Pair_u8_Size *b); -api_buf api_Pair_u8_Size_debug(const api_Pair_u8_Size *self); +API_MUST_USE api_buf api_Pair_u8_Size_debug(const api_Pair_u8_Size *self); api_Pair_Size_u8 api_Pair_u8_Size_swap(const api_Pair_u8_Size *self); void api_Left_Right_u8_free(api_Left_Right_u8 *self); bool api_Left_Right_u8_eq(const api_Left_Right_u8 *a, const api_Left_Right_u8 *b); -api_buf api_Left_Right_u8_debug(const api_Left_Right_u8 *self); +API_MUST_USE api_buf api_Left_Right_u8_debug(const api_Left_Right_u8 *self); void api_Left_u8_free(api_Left_u8 *self); bool api_Left_u8_eq(const api_Left_u8 *a, const api_Left_u8 *b); -api_buf api_Left_u8_debug(const api_Left_u8 *self); +API_MUST_USE api_buf api_Left_u8_debug(const api_Left_u8 *self); void api_Right_Left_u8_free(api_Right_Left_u8 *self); bool api_Right_Left_u8_eq(const api_Right_Left_u8 *a, const api_Right_Left_u8 *b); -api_buf api_Right_Left_u8_debug(const api_Right_Left_u8 *self); +API_MUST_USE api_buf api_Right_Left_u8_debug(const api_Right_Left_u8 *self); void api_Right_u8_free(api_Right_u8 *self); bool api_Right_u8_eq(const api_Right_u8 *a, const api_Right_u8 *b); -api_buf api_Right_u8_debug(const api_Right_u8 *self); +API_MUST_USE api_buf api_Right_u8_debug(const api_Right_u8 *self); void api_Inner_u8_free(api_Inner_u8 *self); bool api_Inner_u8_eq(const api_Inner_u8 *a, const api_Inner_u8 *b); -api_buf api_Inner_u8_debug(const api_Inner_u8 *self); +API_MUST_USE api_buf api_Inner_u8_debug(const api_Inner_u8 *self); void api_Boxed_u16_free(api_Boxed_u16 *self); bool api_Boxed_u16_eq(const api_Boxed_u16 *a, const api_Boxed_u16 *b); -api_buf api_Boxed_u16_debug(const api_Boxed_u16 *self); +API_MUST_USE api_buf api_Boxed_u16_debug(const api_Boxed_u16 *self); void api_Boxed_u8_free(api_Boxed_u8 *self); bool api_Boxed_u8_eq(const api_Boxed_u8 *a, const api_Boxed_u8 *b); -api_buf api_Boxed_u8_debug(const api_Boxed_u8 *self); +API_MUST_USE api_buf api_Boxed_u8_debug(const api_Boxed_u8 *self); void api_LogCount_free(api_LogCount *self); bool api_LogCount_eq(const api_LogCount *a, const api_LogCount *b); -api_buf api_LogCount_debug(const api_LogCount *self); +API_MUST_USE api_buf api_LogCount_debug(const api_LogCount *self); void api_Wrap_u32_free(api_Wrap_u32 *self); bool api_Wrap_u32_eq(const api_Wrap_u32 *a, const api_Wrap_u32 *b); -api_buf api_Wrap_u32_debug(const api_Wrap_u32 *self); +API_MUST_USE api_buf api_Wrap_u32_debug(const api_Wrap_u32 *self); void api_PolarTurn_free(api_PolarTurn *self); bool api_PolarTurn_eq(const api_PolarTurn *a, const api_PolarTurn *b); -api_buf api_PolarTurn_debug(const api_PolarTurn *self); +API_MUST_USE api_buf api_PolarTurn_debug(const api_PolarTurn *self); void api_Peer_free(api_Peer *self); bool api_Peer_eq(const api_Peer *a, const api_Peer *b); -api_buf api_Peer_debug(const api_Peer *self); -api_vec_string api_Peer_aliases(const api_Peer *self); -api_Peer api_Peer_next(const api_Peer *self, api_buf name); +API_MUST_USE api_buf api_Peer_debug(const api_Peer *self); +API_MUST_USE api_vec_string api_Peer_aliases(const api_Peer *self); +API_MUST_USE api_Peer api_Peer_next(const api_Peer *self, api_buf name); void api_Shadowed_free(api_Shadowed *self); bool api_Shadowed_eq(const api_Shadowed *a, const api_Shadowed *b); -api_buf api_Shadowed_debug(const api_Shadowed *self); +API_MUST_USE api_buf api_Shadowed_debug(const api_Shadowed *self); void api_Numbers_free(api_Numbers *self); bool api_Numbers_eq(const api_Numbers *a, const api_Numbers *b); -api_buf api_Numbers_debug(const api_Numbers *self); -api_Numbers api_Numbers_edges(void); -api_Numbers api_Numbers_zero(bool negative); -api_Numbers api_Numbers_reversed(const api_Numbers *self); +API_MUST_USE api_buf api_Numbers_debug(const api_Numbers *self); +API_MUST_USE api_Numbers api_Numbers_edges(void); +API_MUST_USE api_Numbers api_Numbers_zero(bool negative); +API_MUST_USE api_Numbers api_Numbers_reversed(const api_Numbers *self); void api_Measure_free(api_Measure *self); bool api_Measure_eq(const api_Measure *a, const api_Measure *b); -api_buf api_Measure_debug(const api_Measure *self); -api_Measure api_Measure_new(double value, bool negative); +API_MUST_USE api_buf api_Measure_debug(const api_Measure *self); +API_MUST_USE api_Measure api_Measure_new(double value, bool negative); void api_Limits_bytes_free(api_Limits_bytes *self); bool api_Limits_bytes_eq(const api_Limits_bytes *a, const api_Limits_bytes *b); -api_buf api_Limits_bytes_debug(const api_Limits_bytes *self); +API_MUST_USE api_buf api_Limits_bytes_debug(const api_Limits_bytes *self); void api_Limits_duration_free(api_Limits_duration *self); bool api_Limits_duration_eq(const api_Limits_duration *a, const api_Limits_duration *b); -api_buf api_Limits_duration_debug(const api_Limits_duration *self); +API_MUST_USE api_buf api_Limits_duration_debug(const api_Limits_duration *self); void api_Page_free(api_Page *self); bool api_Page_eq(const api_Page *a, const api_Page *b); -api_buf api_Page_debug(const api_Page *self); +API_MUST_USE api_buf api_Page_debug(const api_Page *self); api_Page api_Page_default(void); void api_Booth_free(api_Booth *self); bool api_Booth_eq(const api_Booth *a, const api_Booth *b, api_status *status); -api_buf api_Booth_debug(const api_Booth *self, api_status *status); +API_MUST_USE api_buf api_Booth_debug(const api_Booth *self, api_status *status); void api_Cancelled_free(api_Cancelled *self); bool api_Cancelled_eq(const api_Cancelled *a, const api_Cancelled *b); -api_buf api_Cancelled_debug(const api_Cancelled *self); +API_MUST_USE api_buf api_Cancelled_debug(const api_Cancelled *self); void api_StartSeekable_free(api_StartSeekable *self); bool api_StartSeekable_eq(const api_StartSeekable *a, const api_StartSeekable *b); -api_buf api_StartSeekable_debug(const api_StartSeekable *self); +API_MUST_USE api_buf api_StartSeekable_debug(const api_StartSeekable *self); void api_DoubleArray_free(api_DoubleArray *self); bool api_DoubleArray_eq(const api_DoubleArray *a, const api_DoubleArray *b); -api_buf api_DoubleArray_debug(const api_DoubleArray *self); +API_MUST_USE api_buf api_DoubleArray_debug(const api_DoubleArray *self); void api_NonZeros_free(api_NonZeros *self); -api_buf api_NonZeros_debug(const api_NonZeros *self); +API_MUST_USE api_buf api_NonZeros_debug(const api_NonZeros *self); void api_a_free(api_a *self); bool api_a_eq(const api_a *a, const api_a *b); -api_buf api_a_debug(const api_a *self); +API_MUST_USE api_buf api_a_debug(const api_a *self); void api_Qualifiers_free(api_Qualifiers *self); bool api_Qualifiers_eq(const api_Qualifiers *a, const api_Qualifiers *b); void api_Spot_free(api_Spot *self); bool api_Spot_eq(const api_Spot *a, const api_Spot *b); -api_buf api_Spot_debug(const api_Spot *self); -bool api_Spot_deserialize(api_Json *deserializer, api_Spot *out, api_buf *err, api_status *status); +API_MUST_USE api_buf api_Spot_debug(const api_Spot *self); +API_MUST_USE bool api_Spot_deserialize(api_Json *deserializer, api_Spot *out, api_buf *err, api_status *status); void api_Deprecated_free(api_Deprecated *self); bool api_Deprecated_eq(const api_Deprecated *a, const api_Deprecated *b); -api_buf api_Deprecated_debug(const api_Deprecated *self); +API_MUST_USE api_buf api_Deprecated_debug(const api_Deprecated *self); api_Deprecated api_Deprecated_default(void); void api_Dial_free(api_Dial *self); bool api_Dial_eq(const api_Dial *a, const api_Dial *b); -api_buf api_Dial_debug(const api_Dial *self); +API_MUST_USE api_buf api_Dial_debug(const api_Dial *self); api_Dial api_Dial_default(void); -bool api_Dial_turn(const api_Dial *self, uint64_t by, api_Dial *out, api_Error *err); +API_MUST_USE bool api_Dial_turn(const api_Dial *self, uint64_t by, api_Dial *out, api_Error *err); api_Dial api_Dial_max(const api_Dial *self); void api_Knob_free(api_Knob *self); bool api_Knob_eq(const api_Knob *a, const api_Knob *b); -api_buf api_Knob_debug(const api_Knob *self); +API_MUST_USE api_buf api_Knob_debug(const api_Knob *self); api_Knob api_Knob_default(void); uint64_t api_Knob_doubled(const api_Knob *self); void api_polar_Point_free(api_polar_Point *self); bool api_polar_Point_eq(const api_polar_Point *a, const api_polar_Point *b); -api_buf api_polar_Point_debug(const api_polar_Point *self); +API_MUST_USE api_buf api_polar_Point_debug(const api_polar_Point *self); void api_polar_Turn_free(api_polar_Turn *self); bool api_polar_Turn_eq(const api_polar_Turn *a, const api_polar_Turn *b); -api_buf api_polar_Turn_debug(const api_polar_Turn *self); +API_MUST_USE api_buf api_polar_Turn_debug(const api_polar_Turn *self); void api_clash_Tone_free(api_clash_Tone *self); bool api_clash_Tone_eq(const api_clash_Tone *a, const api_clash_Tone *b); -api_buf api_clash_Tone_debug(const api_clash_Tone *self); +API_MUST_USE api_buf api_clash_Tone_debug(const api_clash_Tone *self); void api_clash_TONE_free(api_clash_TONE *self); bool api_clash_TONE_eq(const api_clash_TONE *a, const api_clash_TONE *b); -api_buf api_clash_TONE_debug(const api_clash_TONE *self); +API_MUST_USE api_buf api_clash_TONE_debug(const api_clash_TONE *self); void api_clash_Span_free(api_clash_Span *self); bool api_clash_Span_eq(const api_clash_Span *a, const api_clash_Span *b); -api_buf api_clash_Span_to_string(const api_clash_Span *self); -api_buf api_clash_Span_debug(const api_clash_Span *self); +API_MUST_USE api_buf api_clash_Span_to_string(const api_clash_Span *self); +API_MUST_USE api_buf api_clash_Span_debug(const api_clash_Span *self); uint32_t api_clash_Span_width(const api_clash_Span *self); -api_buf api_clash_Span_to_string_(const api_clash_Span *self); +API_MUST_USE api_buf api_clash_Span_to_string_(const api_clash_Span *self); void api_clash_Any_free(api_clash_Any *self); bool api_clash_Any_eq(const api_clash_Any *a, const api_clash_Any *b); uint64_t api_clash_Any_hash(const api_clash_Any *self); -api_buf api_clash_Any_debug(const api_clash_Any *self); +API_MUST_USE api_buf api_clash_Any_debug(const api_clash_Any *self); void api_clash_Break_free(api_clash_Break *self); bool api_clash_Break_eq(const api_clash_Break *a, const api_clash_Break *b); -api_buf api_clash_Break_debug(const api_clash_Break *self); +API_MUST_USE api_buf api_clash_Break_debug(const api_clash_Break *self); api_clash_Break api_clash_Break_Sp(void); api_clash_Break api_clash_Break_SP(void); void api_tls_policy_Lifetime_free(api_tls_policy_Lifetime *self); bool api_tls_policy_Lifetime_eq(const api_tls_policy_Lifetime *a, const api_tls_policy_Lifetime *b); -api_buf api_tls_policy_Lifetime_debug(const api_tls_policy_Lifetime *self); +API_MUST_USE api_buf api_tls_policy_Lifetime_debug(const api_tls_policy_Lifetime *self); void api_Core_free(api_Core *self); void api_Choice_free(api_Choice *self); void api_Array_free(api_Array *self); void api_Platform_free(api_Platform *self); void api_Placement_free(api_Placement *self); bool api_Shape_eq(const api_Shape *a, const api_Shape *b); -api_buf api_Shape_debug(const api_Shape *self); +API_MUST_USE api_buf api_Shape_debug(const api_Shape *self); api_option_Shape api_Shape_value_of(api_buf name); -api_vec_Shape api_Shape_ALL(void); -api_vec_Shape api_Shape_BOTH(void); +API_MUST_USE api_vec_Shape api_Shape_ALL(void); +API_MUST_USE api_vec_Shape api_Shape_BOTH(void); void api_Event_free(api_Event *self); bool api_Event_eq(const api_Event *a, const api_Event *b); -api_buf api_Event_debug(const api_Event *self); +API_MUST_USE api_buf api_Event_debug(const api_Event *self); void api_Clash_free(api_Clash *self); bool api_Clash_eq(const api_Clash *a, const api_Clash *b); -api_buf api_Clash_debug(const api_Clash *self); +API_MUST_USE api_buf api_Clash_debug(const api_Clash *self); api_option_Point api_Clash_point(const api_Clash *self); -api_Clash api_Clash_of(double value); -api_buf api_Clash_bytes(const api_Clash *self); -api_Reading api_Clash_reading(const api_Clash *self, uint32_t kotlin); -api_vec_vec_u32 api_Clash_listed(api_vec_u32 java, uint32_t kotlin, uint32_t *kotlin_out); +API_MUST_USE api_Clash api_Clash_of(double value); +API_MUST_USE api_buf api_Clash_bytes(const api_Clash *self); +API_MUST_USE api_Reading api_Clash_reading(const api_Clash *self, uint32_t kotlin); +API_MUST_USE api_vec_vec_u32 api_Clash_listed(api_vec_u32 java, uint32_t kotlin, uint32_t *kotlin_out); typedef struct api_Clash_after_future api_Clash_after_future; -api_Clash_after_future *api_Clash_after(api_foreign_future first, double kotlin); -api_poll api_Clash_after_start(api_foreign_future first, double kotlin, api_Clash *out, api_Clash_after_future **future); -api_poll api_Clash_after_poll(api_Clash_after_future *future, api_waker waker, api_Clash *out); +API_MUST_USE api_Clash_after_future *api_Clash_after(api_foreign_future first, double kotlin); +API_MUST_USE api_poll api_Clash_after_start(api_foreign_future first, double kotlin, api_Clash *out, api_Clash_after_future **future); +API_MUST_USE api_poll api_Clash_after_poll(api_Clash_after_future *future, api_waker waker, api_Clash *out); void api_Clash_after_future_free(api_Clash_after_future *future); -api_buf api_Clash_joined(const api_Clash *self, api_buf lent, api_buf owned, api_buf maybe); +API_MUST_USE api_buf api_Clash_joined(const api_Clash *self, api_buf lent, api_buf owned, api_buf maybe); typedef struct api_Clash_tagged_future api_Clash_tagged_future; -api_Clash_tagged_future *api_Clash_tagged(const api_Clash *self, api_buf tag); -api_poll api_Clash_tagged_start(const api_Clash *self, api_buf tag, api_buf *out, api_Clash_tagged_future **future); -api_poll api_Clash_tagged_poll(api_Clash_tagged_future *future, api_waker waker, api_buf *out); +API_MUST_USE api_Clash_tagged_future *api_Clash_tagged(const api_Clash *self, api_buf tag); +API_MUST_USE api_poll api_Clash_tagged_start(const api_Clash *self, api_buf tag, api_buf *out, api_Clash_tagged_future **future); +API_MUST_USE api_poll api_Clash_tagged_poll(api_Clash_tagged_future *future, api_waker waker, api_buf *out); void api_Clash_tagged_future_free(api_Clash_tagged_future *future); api_Stamp api_Clash_stamp(const api_Clash *self, uint64_t kotlin); api_Moment api_Clash_moment(const api_Clash *self, uint64_t kotlin); -api_Clash api_Clash_at(api_Point api); -api_buf api_Clash_describe(const api_Clash *self, api_buf text, uint32_t n, api_Shape shape, uint32_t out_, uint32_t *out__out); +API_MUST_USE api_Clash api_Clash_at(api_Point api); +API_MUST_USE api_buf api_Clash_describe(const api_Clash *self, api_buf text, uint32_t n, api_Shape shape, uint32_t out_, uint32_t *out__out); void api_Stage_free(api_Stage *self); bool api_Stage_eq(const api_Stage *a, const api_Stage *b); -api_buf api_Stage_debug(const api_Stage *self); +API_MUST_USE api_buf api_Stage_debug(const api_Stage *self); void api_Error_free(api_Error *self); bool api_Error_eq(const api_Error *a, const api_Error *b); -api_buf api_Error_to_string(const api_Error *self); -api_buf api_Error_debug(const api_Error *self); +API_MUST_USE api_buf api_Error_to_string(const api_Error *self); +API_MUST_USE api_buf api_Error_debug(const api_Error *self); bool api_Status__eq(const api_Status_ *a, const api_Status_ *b); -api_buf api_Status__debug(const api_Status_ *self); +API_MUST_USE api_buf api_Status__debug(const api_Status_ *self); void api_Labelled_free(api_Labelled *self); bool api_Labelled_eq(const api_Labelled *a, const api_Labelled *b); -api_buf api_Labelled_debug(const api_Labelled *self); +API_MUST_USE api_buf api_Labelled_debug(const api_Labelled *self); bool api_Family_eq(const api_Family *a, const api_Family *b); -api_buf api_Family_debug(const api_Family *self); +API_MUST_USE api_buf api_Family_debug(const api_Family *self); bool api_VecClashTone_eq(const api_VecClashTone *a, const api_VecClashTone *b); -api_buf api_VecClashTone_debug(const api_VecClashTone *self); +API_MUST_USE api_buf api_VecClashTone_debug(const api_VecClashTone *self); void api_b_free(api_b *self); bool api_b_eq(const api_b *a, const api_b *b); -api_buf api_b_debug(const api_b *self); +API_MUST_USE api_buf api_b_debug(const api_b *self); void api_Builtin_free(api_Builtin *self); bool api_Builtin_eq(const api_Builtin *a, const api_Builtin *b); void api_clash_Candidate_free(api_clash_Candidate *self); bool api_clash_Candidate_eq(const api_clash_Candidate *a, const api_clash_Candidate *b); -api_buf api_clash_Candidate_debug(const api_clash_Candidate *self); +API_MUST_USE api_buf api_clash_Candidate_debug(const api_clash_Candidate *self); bool api_Level_eq(const api_Level *a, const api_Level *b); uint64_t api_Level_hash(const api_Level *self); -api_buf api_Level_to_string(const api_Level *self); +API_MUST_USE api_buf api_Level_to_string(const api_Level *self); void api_Board_free(api_Board *self); void api_Board_drop(api_Board *self, api_status *status); -api_Board *api_Board_new(api_vec_tuple_string_Counter counters, api_status *status); -api_vec_tuple_string_Counter api_Board_into_counters(api_Board *self, api_status *status); -api_vec_tuple_string_Counter api_Board_ranked(const api_Board *self, api_status *status); -api_Counter *api_Board_best(const api_Board *self, api_status *status); +API_MUST_USE api_Board *api_Board_new(api_vec_tuple_string_Counter counters, api_status *status); +API_MUST_USE api_vec_tuple_string_Counter api_Board_into_counters(api_Board *self, api_status *status); +API_MUST_USE api_vec_tuple_string_Counter api_Board_ranked(const api_Board *self, api_status *status); +API_MUST_USE api_Counter *api_Board_best(const api_Board *self, api_status *status); void api_Tab_free(api_Tab *self); void api_Tab_drop(api_Tab *self, api_status *status); -api_Ledger *api_Tab_ledger_get(const api_Tab *self, api_status *status); -api_buf api_Tab_label_get(const api_Tab *self, api_status *status); +API_MUST_USE api_Ledger *api_Tab_ledger_get(const api_Tab *self, api_status *status); +API_MUST_USE api_buf api_Tab_label_get(const api_Tab *self, api_status *status); void api_Receipt_free(api_Receipt *self); void api_Receipt_drop(api_Receipt *self, api_status *status); -api_Receipt *api_Receipt_clone(const api_Receipt *self, api_status *status); +API_MUST_USE api_Receipt *api_Receipt_clone(const api_Receipt *self, api_status *status); uint32_t api_Receipt_count(const api_Receipt *self, api_status *status); void api_Draft_free(api_Draft *self); void api_Draft_drop(api_Draft *self, api_status *status); bool api_Draft_edited(const api_Draft *self, api_status *status); -api_buf api_Draft_describe(const api_Draft *self, api_status *status); +API_MUST_USE api_buf api_Draft_describe(const api_Draft *self, api_status *status); uint32_t api_Draft_commit(api_Draft *self, api_status *status); -api_buf api_Draft_title_get(const api_Draft *self, api_status *status); +API_MUST_USE api_buf api_Draft_title_get(const api_Draft *self, api_status *status); void api_Draft_title_set(api_Draft *self, api_buf value, api_status *status); uint32_t api_Draft_lines(const api_Draft *self, api_status *status); void api_Draft_write(api_Draft *self, api_buf line, api_status *status); void api_Filed_Receipt_free(api_Filed_Receipt *self); void api_Filed_Receipt_drop(api_Filed_Receipt *self, api_status *status); -api_Filed_Receipt *api_Filed_Receipt_clone(const api_Filed_Receipt *self, api_status *status); +API_MUST_USE api_Filed_Receipt *api_Filed_Receipt_clone(const api_Filed_Receipt *self, api_status *status); uint32_t api_Filed_Receipt_count(const api_Filed_Receipt *self, api_status *status); void api_Pad_u16_free(api_Pad_u16 *self); -api_Pad_u16 *api_Pad_u16_wide(void); +API_MUST_USE api_Pad_u16 *api_Pad_u16_wide(void); uint16_t api_Pad_u16_tag(const api_Pad_u16 *self); uint16_t api_Pad_u16_title(const api_Pad_u16 *self); -api_buf api_Pad_u16_title_get(const api_Pad_u16 *self); +API_MUST_USE api_buf api_Pad_u16_title_get(const api_Pad_u16 *self); uint32_t api_Pad_u16_lines(const api_Pad_u16 *self); -api_buf api_Pad_u16_describe(const api_Pad_u16 *self); +API_MUST_USE api_buf api_Pad_u16_describe(const api_Pad_u16 *self); void api_Pad_u8_free(api_Pad_u8 *self); -api_Pad_u8 *api_Pad_u8_small(void); -api_buf api_Pad_u8_describe(const api_Pad_u8 *self); -api_buf api_Pad_u8_title_get(const api_Pad_u8 *self); +API_MUST_USE api_Pad_u8 *api_Pad_u8_small(void); +API_MUST_USE api_buf api_Pad_u8_describe(const api_Pad_u8 *self); +API_MUST_USE api_buf api_Pad_u8_title_get(const api_Pad_u8 *self); uint32_t api_Pad_u8_lines(const api_Pad_u8 *self); void api_Layered_free(api_Layered *self); -api_Layered *api_Layered_new(void); -api_buf api_Layered_title_get(const api_Layered *self); +API_MUST_USE api_Layered *api_Layered_new(void); +API_MUST_USE api_buf api_Layered_title_get(const api_Layered *self); uint32_t api_Layered_lines(const api_Layered *self); void api_Marker_free(api_Marker *self); void api_Marker_drop(api_Marker *self, api_status *status); -api_Marker *api_Marker_new(api_buf label, int32_t x, int32_t y); -api_buf api_Marker_label(const api_Marker *self, api_status *status); +API_MUST_USE api_Marker *api_Marker_new(api_buf label, int32_t x, int32_t y); +API_MUST_USE api_buf api_Marker_label(const api_Marker *self, api_status *status); int32_t api_Marker_x(const api_Marker *self, api_status *status); int32_t api_Marker_y(void); int32_t api_Marker_x_get(const api_Marker *self, api_status *status); @@ -1497,74 +1507,74 @@ void api_Marker_y_set(api_Marker *self, int32_t value, api_status *status); api_Point api_Marker_offset(const api_Marker *self, int32_t dx, int32_t dy, api_status *status); void api_Batch_free(api_Batch *self); void api_Batch_drop(api_Batch *self, api_status *status); -api_Batch *api_Batch_new(void); +API_MUST_USE api_Batch *api_Batch_new(void); bool api_Batch_push(api_Batch *self, uint32_t v, api_status *status); size_t api_Batch_capacity(const api_Batch *self, api_status *status); void api_Batch_2_free(api_Batch_2 *self); void api_Batch_2_drop(api_Batch_2 *self, api_status *status); -api_Batch_2 *api_Batch_2_new(void); +API_MUST_USE api_Batch_2 *api_Batch_2_new(void); bool api_Batch_2_push(api_Batch_2 *self, uint32_t v, api_status *status); size_t api_Batch_2_capacity(const api_Batch_2 *self, api_status *status); void api_Waiter_free(api_Waiter *self); void api_Waiter_drop(api_Waiter *self, api_status *status); -api_Waiter *api_Waiter_new(api_waker waker_); -api_waker api_Waiter_waker(const api_Waiter *self, api_status *status); -api_waker api_Waiter_context(const api_Waiter *self, api_status *status); +API_MUST_USE api_Waiter *api_Waiter_new(api_waker waker_); +API_MUST_USE api_waker api_Waiter_waker(const api_Waiter *self, api_status *status); +API_MUST_USE api_waker api_Waiter_context(const api_Waiter *self, api_status *status); typedef struct api_Waiter_poll_future_future api_Waiter_poll_future_future; -api_Waiter_poll_future_future *api_Waiter_poll_future(api_foreign_future future_); -api_poll api_Waiter_poll_future_start(api_foreign_future future_, api_Waiter_poll_future_future **future); -api_poll api_Waiter_poll_future_poll(api_Waiter_poll_future_future *future, api_waker waker); +API_MUST_USE api_Waiter_poll_future_future *api_Waiter_poll_future(api_foreign_future future_); +API_MUST_USE api_poll api_Waiter_poll_future_start(api_foreign_future future_, api_Waiter_poll_future_future **future); +API_MUST_USE api_poll api_Waiter_poll_future_poll(api_Waiter_poll_future_future *future, api_waker waker); void api_Waiter_poll_future_future_free(api_Waiter_poll_future_future *future); void api_Logger_free(api_Logger *self); -api_Logger *api_Logger_new(api_Log sink); +API_MUST_USE api_Logger *api_Logger_new(api_Log sink); bool api_Logger_write(const api_Logger *self, api_buf line); bool api_Logger_write_from_thread(const api_Logger *self, api_buf line); void api_Journal_free(api_Journal *self); void api_Journal_drop(api_Journal *self, api_status *status); -api_Journal *api_Journal_new(api_Log sink); +API_MUST_USE api_Journal *api_Journal_new(api_Log sink); void api_Journal_redirect(api_Journal *self, api_Log sink, api_status *status); bool api_Journal_write(const api_Journal *self, api_buf line, api_status *status); void api_Local_free(api_Local *self); void api_Local_drop(api_Local *self, api_status *status); bool api_Local_eq(const api_Local *a, const api_Local *b, api_status *status); uint64_t api_Local_hash(const api_Local *self, api_status *status); -api_Local *api_Local_default(void); -api_Local *api_Local_default_homed(void); -api_Local *api_Local_new(void); -api_Local *api_Local_new_homed(void); +API_MUST_USE api_Local *api_Local_default(void); +API_MUST_USE api_Local *api_Local_default_homed(void); +API_MUST_USE api_Local *api_Local_new(void); +API_MUST_USE api_Local *api_Local_new_homed(void); uint32_t api_Local_bump(const api_Local *self, api_status *status); -api_Local *api_Local_share(const api_Local *self, api_status *status); +API_MUST_USE api_Local *api_Local_share(const api_Local *self, api_status *status); typedef struct api_Local_later_future api_Local_later_future; -api_Local_later_future *api_Local_later(const api_Local *self, api_status *status); -api_poll api_Local_later_start(const api_Local *self, uint32_t *out, api_Local_later_future **future, api_status *status); -api_poll api_Local_later_poll(api_Local_later_future *future, api_waker waker, uint32_t *out, api_status *status); +API_MUST_USE api_Local_later_future *api_Local_later(const api_Local *self, api_status *status); +API_MUST_USE api_poll api_Local_later_start(const api_Local *self, uint32_t *out, api_Local_later_future **future, api_status *status); +API_MUST_USE api_poll api_Local_later_poll(api_Local_later_future *future, api_waker waker, uint32_t *out, api_status *status); void api_Local_later_future_free(api_Local_later_future *future); uint32_t api_Local_visit(const api_Local *self, uint32_t (*f)(void *data), void *f_data, api_status *status); typedef struct api_Local_poll_count_future api_Local_poll_count_future; -api_Local_poll_count_future *api_Local_poll_count(const api_Local *self, api_status *status); -api_poll api_Local_poll_count_start(const api_Local *self, uint32_t *out, api_Local_poll_count_future **future, api_status *status); -api_poll api_Local_poll_count_poll(api_Local_poll_count_future *future, api_waker waker, uint32_t *out, api_status *status); +API_MUST_USE api_Local_poll_count_future *api_Local_poll_count(const api_Local *self, api_status *status); +API_MUST_USE api_poll api_Local_poll_count_start(const api_Local *self, uint32_t *out, api_Local_poll_count_future **future, api_status *status); +API_MUST_USE api_poll api_Local_poll_count_poll(api_Local_poll_count_future *future, api_waker waker, uint32_t *out, api_status *status); void api_Local_poll_count_future_free(api_Local_poll_count_future *future); uint64_t api_Local_thread_number(const api_Local *self, api_status *status); bool api_Local_on_own_thread(const api_Local *self, api_status *status); void api_LocalWaiter_free(api_LocalWaiter *self); void api_LocalWaiter_drop(api_LocalWaiter *self, api_status *status); -api_LocalWaiter *api_LocalWaiter_new(api_waker waker_); -api_LocalWaiter *api_LocalWaiter_new_homed(api_waker waker_); +API_MUST_USE api_LocalWaiter *api_LocalWaiter_new(api_waker waker_); +API_MUST_USE api_LocalWaiter *api_LocalWaiter_new_homed(api_waker waker_); typedef struct api_LocalWaiter_poll_ready_future api_LocalWaiter_poll_ready_future; -api_LocalWaiter_poll_ready_future *api_LocalWaiter_poll_ready(uint32_t n); -api_poll api_LocalWaiter_poll_ready_start(uint32_t n, uint32_t *out, api_LocalWaiter_poll_ready_future **future); -api_poll api_LocalWaiter_poll_ready_poll(api_LocalWaiter_poll_ready_future *future, api_waker waker, uint32_t *out, api_status *status); +API_MUST_USE api_LocalWaiter_poll_ready_future *api_LocalWaiter_poll_ready(uint32_t n); +API_MUST_USE api_poll api_LocalWaiter_poll_ready_start(uint32_t n, uint32_t *out, api_LocalWaiter_poll_ready_future **future); +API_MUST_USE api_poll api_LocalWaiter_poll_ready_poll(api_LocalWaiter_poll_ready_future *future, api_waker waker, uint32_t *out, api_status *status); void api_LocalWaiter_poll_ready_future_free(api_LocalWaiter_poll_ready_future *future); -api_LocalWaiter_poll_ready_future *api_LocalWaiter_poll_ready_homed(uint32_t n); -api_poll api_LocalWaiter_poll_ready_start_homed(uint32_t n, uint32_t *out, api_LocalWaiter_poll_ready_future **future); +API_MUST_USE api_LocalWaiter_poll_ready_future *api_LocalWaiter_poll_ready_homed(uint32_t n); +API_MUST_USE api_poll api_LocalWaiter_poll_ready_start_homed(uint32_t n, uint32_t *out, api_LocalWaiter_poll_ready_future **future); void api_Retry_free(api_Retry *self); void api_Retry_drop(api_Retry *self, api_status *status); api_option_u32 api_Retry_limit_get(const api_Retry *self, api_status *status); void api_Retry_limit_set(api_Retry *self, api_option_u32 value, api_status *status); api_option_u32 api_Retry_delay_get(const api_Retry *self, api_status *status); void api_Retry_delay_set(api_Retry *self, api_option_u32 value, api_status *status); -api_Retry *api_Retry_new(api_option_u32 limit); +API_MUST_USE api_Retry *api_Retry_new(api_option_u32 limit); uint32_t api_Retry_limit(const api_Retry *self, api_status *status); uint32_t api_Retry_delay(const api_Retry *self, api_status *status); void api_Retry_set_limit(api_Retry *self, uint32_t limit, api_status *status); @@ -1572,346 +1582,346 @@ void api_Digest_free(api_Digest *self); void api_Digest_drop(api_Digest *self, api_status *status); api_array_u8_4 api_Digest_sum_get(const api_Digest *self, api_status *status); void api_Digest_sum_set(api_Digest *self, api_array_u8_4 value, api_status *status); -api_Digest *api_Digest_new(void); +API_MUST_USE api_Digest *api_Digest_new(void); api_array_u8_4 api_Digest_flipped(const api_Digest *self, api_array_u8_4 mask, api_status *status); void api_Cursor_free(api_Cursor *self); void api_Cursor_drop(api_Cursor *self, api_status *status); uint64_t api_Cursor_at(const api_Cursor *self, api_status *status); void api_Outer_Inner_u8_free(api_Outer_Inner_u8 *self); -api_Outer_Inner_u8 *api_Outer_Inner_u8_new(uint8_t value); +API_MUST_USE api_Outer_Inner_u8 *api_Outer_Inner_u8_new(uint8_t value); uint8_t api_Outer_Inner_u8_get(const api_Outer_Inner_u8 *self); void api_Slot_u32_free(api_Slot_u32 *self); void api_Slot_u32_drop(api_Slot_u32 *self, api_status *status); uint32_t api_Slot_u32_value_get(const api_Slot_u32 *self, api_status *status); void api_Slot_u32_value_set(api_Slot_u32 *self, uint32_t value, api_status *status); -api_Slot_u32 *api_Slot_u32_new(uint32_t value); +API_MUST_USE api_Slot_u32 *api_Slot_u32_new(uint32_t value); void api_Slot_u8_free(api_Slot_u8 *self); void api_Slot_u8_drop(api_Slot_u8 *self, api_status *status); uint8_t api_Slot_u8_value_get(const api_Slot_u8 *self, api_status *status); void api_Slot_u8_value_set(api_Slot_u8 *self, uint8_t value, api_status *status); -api_Slot_u8 *api_Slot_u8_new(uint8_t value); +API_MUST_USE api_Slot_u8 *api_Slot_u8_new(uint8_t value); uint16_t api_Slot_u8_value(const api_Slot_u8 *self, api_status *status); void api_Resolving_free(api_Resolving *self); void api_Resolving_drop(api_Resolving *self, api_status *status); -api_tls_Resolver *api_Resolving_0_get(const api_Resolving *self, api_status *status); +API_MUST_USE api_tls_Resolver *api_Resolving_0_get(const api_Resolving *self, api_status *status); void api_Resolving_0_set(api_Resolving *self, api_tls_Resolver *value, api_status *status); -api_Resolving *api_Resolving_new(api_buf name); +API_MUST_USE api_Resolving *api_Resolving_new(api_buf name); void api_Codecs_free(api_Codecs *self); void api_Codecs_drop(api_Codecs *self, api_status *status); -api_Codecs *api_Codecs_default(void); -api_vec_tls_Codec api_Codecs_list_get(const api_Codecs *self, api_status *status); +API_MUST_USE api_Codecs *api_Codecs_default(void); +API_MUST_USE api_vec_tls_Codec api_Codecs_list_get(const api_Codecs *self, api_status *status); void api_Codecs_list_set(api_Codecs *self, api_vec_tls_Codec value, api_status *status); -api_Codecs *api_Codecs_new(void); +API_MUST_USE api_Codecs *api_Codecs_new(void); uint32_t api_Codecs_ids(api_Codecs *self, api_status *status); void api_Der_free(api_Der *self); -api_Der *api_Der_from_slice(api_buf bytes); -api_buf api_Der_bytes(const api_Der *self); +API_MUST_USE api_Der *api_Der_from_slice(api_buf bytes); +API_MUST_USE api_buf api_Der_bytes(const api_Der *self); void api_Verbosity_free(api_Verbosity *self); void api_Verbosity_drop(api_Verbosity *self, api_status *status); api_Level api_Verbosity_level_get(const api_Verbosity *self, api_status *status); void api_Verbosity_level_set(api_Verbosity *self, api_Level value, api_status *status); -api_Verbosity *api_Verbosity_new(api_Level level); +API_MUST_USE api_Verbosity *api_Verbosity_new(api_Level level); api_option_Level api_Verbosity_filter(const api_Verbosity *self, api_status *status); void api_Site_free(api_Site *self); void api_Site_drop(api_Site *self, api_status *status); -api_Url *api_Site_home_get(const api_Site *self, api_status *status); +API_MUST_USE api_Url *api_Site_home_get(const api_Site *self, api_status *status); void api_Site_home_set(api_Site *self, api_Url *value, api_status *status); -api_Site *api_Site_new(api_Url *home, api_status *status); +API_MUST_USE api_Site *api_Site_new(api_Url *home, api_status *status); void api_Trail_free(api_Trail *self); void api_Trail_drop(api_Trail *self, api_status *status); -api_Trail *api_Trail_new(api_vec_Point points, api_vec_string names); -api_vec_Point api_Trail_points(const api_Trail *self, api_status *status); -api_vec_Label api_Trail_labels(const api_Trail *self, api_status *status); -api_vec_Point api_Trail_iter(const api_Trail *self, api_status *status); -api_vec_string api_Trail_names(const api_Trail *self, api_status *status); -api_vec_Point api_Trail_beyond(const api_Trail *self, int32_t x, api_status *status); -api_buf api_Trail_bytes(const api_Trail *self, api_status *status); -api_vec_Label api_Trail_drain(api_Trail *self, api_status *status); +API_MUST_USE api_Trail *api_Trail_new(api_vec_Point points, api_vec_string names); +API_MUST_USE api_vec_Point api_Trail_points(const api_Trail *self, api_status *status); +API_MUST_USE api_vec_Label api_Trail_labels(const api_Trail *self, api_status *status); +API_MUST_USE api_vec_Point api_Trail_iter(const api_Trail *self, api_status *status); +API_MUST_USE api_vec_string api_Trail_names(const api_Trail *self, api_status *status); +API_MUST_USE api_vec_Point api_Trail_beyond(const api_Trail *self, int32_t x, api_status *status); +API_MUST_USE api_buf api_Trail_bytes(const api_Trail *self, api_status *status); +API_MUST_USE api_vec_Label api_Trail_drain(api_Trail *self, api_status *status); void api_Worker_free(api_Worker *self); -api_Worker *api_Worker_new(uint32_t id); +API_MUST_USE api_Worker *api_Worker_new(uint32_t id); uint32_t api_Worker_id(const api_Worker *self); void api_Handle_free(api_Handle *self); -api_Handle *api_Handle_new(uint32_t count); +API_MUST_USE api_Handle *api_Handle_new(uint32_t count); uint32_t api_Handle_count(const api_Handle *self); typedef struct api_Handle_later_future api_Handle_later_future; -api_Handle_later_future *api_Handle_later(uint32_t count); -api_poll api_Handle_later_start(uint32_t count, api_Handle **out, api_Handle_later_future **future); -api_poll api_Handle_later_poll(api_Handle_later_future *future, api_waker waker, api_Handle **out); +API_MUST_USE api_Handle_later_future *api_Handle_later(uint32_t count); +API_MUST_USE api_poll api_Handle_later_start(uint32_t count, api_Handle **out, api_Handle_later_future **future); +API_MUST_USE api_poll api_Handle_later_poll(api_Handle_later_future *future, api_waker waker, api_Handle **out); void api_Handle_later_future_free(api_Handle_later_future *future); void api_Holder_free(api_Holder *self); -api_Holder *api_Holder_new(uint64_t level); +API_MUST_USE api_Holder *api_Holder_new(uint64_t level); uint64_t api_Holder_level_get(const api_Holder *self); uint64_t api_Holder_doubled(const api_Holder *self); void api_Area_free(api_Area *self); bool api_Area_borrowed(const api_Area *self); -api_Area *api_Area_clone(const api_Area *self); -api_buf api_Area_debug(const api_Area *self); -api_Area *api_Area_new(api_Size size); +API_MUST_USE api_Area *api_Area_clone(const api_Area *self); +API_MUST_USE api_buf api_Area_debug(const api_Area *self); +API_MUST_USE api_Area *api_Area_new(api_Size size); api_Size api_Area_size(const api_Area *self); uint64_t api_Area_pixels(const api_Area *self); uint64_t api_Area_scaled_Point(const api_Area *self, api_Point by); void api_Counter_free(api_Counter *self); void api_Counter_drop(api_Counter *self, api_status *status); -api_Counter *api_Counter_clone(const api_Counter *self, api_status *status); -api_buf api_Counter_debug(const api_Counter *self, api_status *status); -api_Counter *api_Counter_default(void); -api_Counter *api_Counter_new(api_buf name, uint64_t start); +API_MUST_USE api_Counter *api_Counter_clone(const api_Counter *self, api_status *status); +API_MUST_USE api_buf api_Counter_debug(const api_Counter *self, api_status *status); +API_MUST_USE api_Counter *api_Counter_default(void); +API_MUST_USE api_Counter *api_Counter_new(api_buf name, uint64_t start); uint64_t api_Counter_get(const api_Counter *self, api_status *status); uint64_t api_Counter_offset(const api_Counter *self, uint64_t handle, uint64_t h, api_status *status); uint64_t api_Counter_into_sum(api_Counter *self, uint64_t close, api_status *status); -api_buf api_Counter_name(const api_Counter *self, api_status *status); -bool api_Counter_add(api_Counter *self, uint64_t n, uint64_t *out, api_Error *err, api_status *status); -bool api_Counter_sub(api_Counter *self, uint64_t n, uint64_t *out, api_Error *err, api_status *status); +API_MUST_USE api_buf api_Counter_name(const api_Counter *self, api_status *status); +API_MUST_USE bool api_Counter_add(api_Counter *self, uint64_t n, uint64_t *out, api_Error *err, api_status *status); +API_MUST_USE bool api_Counter_sub(api_Counter *self, uint64_t n, uint64_t *out, api_Error *err, api_status *status); bool api_Counter_edited(const api_Counter *self, api_status *status); uint64_t api_Counter_plus(const api_Counter *self, const api_Counter *other, api_status *status); uint64_t api_Counter_clamped(const api_Counter *self, const api_Counter *low, const api_Counter *high, api_status *status); typedef struct api_Counter_plus_later_future api_Counter_plus_later_future; -api_Counter_plus_later_future *api_Counter_plus_later(const api_Counter *self, const api_Counter *other, api_status *status); -api_poll api_Counter_plus_later_start(const api_Counter *self, const api_Counter *other, uint64_t *out, api_Counter_plus_later_future **future, api_status *status); -api_poll api_Counter_plus_later_poll(api_Counter_plus_later_future *future, api_waker waker, uint64_t *out); +API_MUST_USE api_Counter_plus_later_future *api_Counter_plus_later(const api_Counter *self, const api_Counter *other, api_status *status); +API_MUST_USE api_poll api_Counter_plus_later_start(const api_Counter *self, const api_Counter *other, uint64_t *out, api_Counter_plus_later_future **future, api_status *status); +API_MUST_USE api_poll api_Counter_plus_later_poll(api_Counter_plus_later_future *future, api_waker waker, uint64_t *out); void api_Counter_plus_later_future_free(api_Counter_plus_later_future *future); bool api_Counter_add_to(const api_Counter *self, api_Counter *other, api_status *status); -api_Label api_Counter_into_label(api_Counter *self, api_option_Point at, api_status *status); +API_MUST_USE api_Label api_Counter_into_label(api_Counter *self, api_option_Point at, api_status *status); void api_Counter_rename(api_Counter *self, api_buf name, api_status *status); void api_Counter_split(api_Counter *self, uint64_t at, api_Counter **out0, api_Counter **out1, api_status *status); bool api_Counter_is(const api_Counter *self, api_buf name, api_status *status); -api_Counter *api_Counter_seeded_Point(api_buf name, api_Point from); -api_Counter *api_Counter_seeded_Counter(api_buf name, const api_Counter *from, api_status *status); -api_Counter *api_Counter_seeded_Size(api_buf name, api_Size from); -api_Counter *api_Counter_seeded_Wrap_u32(api_buf name, api_Wrap_u32 from); -api_Counter *api_Counter_seeded_polar_Point(api_buf name, api_polar_Point from); +API_MUST_USE api_Counter *api_Counter_seeded_Point(api_buf name, api_Point from); +API_MUST_USE api_Counter *api_Counter_seeded_Counter(api_buf name, const api_Counter *from, api_status *status); +API_MUST_USE api_Counter *api_Counter_seeded_Size(api_buf name, api_Size from); +API_MUST_USE api_Counter *api_Counter_seeded_Wrap_u32(api_buf name, api_Wrap_u32 from); +API_MUST_USE api_Counter *api_Counter_seeded_polar_Point(api_buf name, api_polar_Point from); void api_Meter_free(api_Meter *self); void api_Meter_drop(api_Meter *self, api_status *status); -api_Meter *api_Meter_default(void); +API_MUST_USE api_Meter *api_Meter_default(void); uint64_t api_Meter_add(const api_Meter *self, uint64_t n, api_status *status); uint64_t api_Meter_count(const api_Meter *self, api_status *status); void api_Meter_reset(api_Meter *self, api_status *status); void api_Meters_free(api_Meters *self); void api_Meters_drop(api_Meters *self, api_status *status); -api_Meters *api_Meters_default(void); -api_Meter *api_Meters_last_get(const api_Meters *self, api_status *status); +API_MUST_USE api_Meters *api_Meters_default(void); +API_MUST_USE api_Meter *api_Meters_last_get(const api_Meters *self, api_status *status); void api_Meters_last_set(api_Meters *self, api_Meter *value, api_status *status); -api_Meter *api_Meters_spare_get(const api_Meters *self, api_status *status); +API_MUST_USE api_Meter *api_Meters_spare_get(const api_Meters *self, api_status *status); void api_Meters_spare_set(api_Meters *self, api_Meter *value, api_status *status); -api_Meters *api_Meters_new(void); -api_Meter *api_Meters_first(const api_Meters *self, api_status *status); +API_MUST_USE api_Meters *api_Meters_new(void); +API_MUST_USE api_Meter *api_Meters_first(const api_Meters *self, api_status *status); void api_Meters_clear(api_Meters *self, api_status *status); void api_Registry_free(api_Registry *self); void api_Registry_drop(api_Registry *self, api_status *status); -api_Registry *api_Registry_default(void); -api_Counter *api_Registry_first_get(const api_Registry *self, api_status *status); +API_MUST_USE api_Registry *api_Registry_default(void); +API_MUST_USE api_Counter *api_Registry_first_get(const api_Registry *self, api_status *status); void api_Registry_first_set(api_Registry *self, api_Counter *value, api_status *status); -api_Registry *api_Registry_new(api_Counter *first, api_status *status); -api_Counter *api_Registry_last(const api_Registry *self, api_status *status); +API_MUST_USE api_Registry *api_Registry_new(api_Counter *first, api_status *status); +API_MUST_USE api_Counter *api_Registry_last(const api_Registry *self, api_status *status); void api_Registry_push(api_Registry *self, api_Counter *counter, api_status *status); bool api_Registry_edit(api_Registry *self, bool (*edit)(void *data, api_Counter *), void *edit_data, api_status *status); void api_Ledger_free(api_Ledger *self); void api_Ledger_drop(api_Ledger *self, api_status *status); -api_Ledger *api_Ledger_default(void); -api_Ledger *api_Ledger_new(void); -bool api_Ledger_edit(api_Ledger *self, api_Draft **out, api_Error *err, api_status *status); -bool api_Ledger_edit_homed(api_Ledger *self, api_Draft **out, api_Error *err, api_status *status); +API_MUST_USE api_Ledger *api_Ledger_default(void); +API_MUST_USE api_Ledger *api_Ledger_new(void); +API_MUST_USE bool api_Ledger_edit(api_Ledger *self, api_Draft **out, api_Error *err, api_status *status); +API_MUST_USE bool api_Ledger_edit_homed(api_Ledger *self, api_Draft **out, api_Error *err, api_status *status); uint32_t api_Ledger_published(const api_Ledger *self, api_status *status); -api_buf api_Ledger_title(const api_Ledger *self, api_status *status); +API_MUST_USE api_buf api_Ledger_title(const api_Ledger *self, api_status *status); void api_Ledger_seal(api_Ledger *self, api_status *status); -api_Receipt *api_Ledger_receipt(api_Ledger *self, api_status *status); -api_Receipt *api_Ledger_noted(api_Ledger *self, api_status *status); -api_Filed_Receipt *api_Ledger_file_Receipt(api_Ledger *self, api_Receipt *item, api_status *status); -api_Tab *api_Ledger_tab(api_Ledger *self, api_status *status); -api_Slip *api_Ledger_slip(api_Ledger *self, api_status *status); -api_Slip *api_Ledger_slip_homed(api_Ledger *self, api_status *status); +API_MUST_USE api_Receipt *api_Ledger_receipt(api_Ledger *self, api_status *status); +API_MUST_USE api_Receipt *api_Ledger_noted(api_Ledger *self, api_status *status); +API_MUST_USE api_Filed_Receipt *api_Ledger_file_Receipt(api_Ledger *self, api_Receipt *item, api_status *status); +API_MUST_USE api_Tab *api_Ledger_tab(api_Ledger *self, api_status *status); +API_MUST_USE api_Slip *api_Ledger_slip(api_Ledger *self, api_status *status); +API_MUST_USE api_Slip *api_Ledger_slip_homed(api_Ledger *self, api_status *status); void api_Slip_free(api_Slip *self); void api_Slip_drop(api_Slip *self, api_status *status); -api_Slip *api_Slip_clone(const api_Slip *self, api_status *status); -api_Receipt *api_Slip_receipt_get(const api_Slip *self, api_status *status); +API_MUST_USE api_Slip *api_Slip_clone(const api_Slip *self, api_status *status); +API_MUST_USE api_Receipt *api_Slip_receipt_get(const api_Slip *self, api_status *status); void api_Slip_receipt_set(api_Slip *self, api_Receipt *value, api_status *status); -api_Receipt *api_Slip_global_get(const api_Slip *self, api_status *status); +API_MUST_USE api_Receipt *api_Slip_global_get(const api_Slip *self, api_status *status); void api_Slip_global_set(api_Slip *self, api_Receipt *value, api_status *status); uint32_t api_Slip_count(const api_Slip *self, api_status *status); void api_Sheet_free(api_Sheet *self); void api_Sheet_drop(api_Sheet *self, api_status *status); -api_Sheet *api_Sheet_clone(const api_Sheet *self, api_status *status); -api_buf api_Sheet_debug(const api_Sheet *self, api_status *status); -api_Sheet *api_Sheet_default(void); -api_buf api_Sheet_title_get(const api_Sheet *self, api_status *status); +API_MUST_USE api_Sheet *api_Sheet_clone(const api_Sheet *self, api_status *status); +API_MUST_USE api_buf api_Sheet_debug(const api_Sheet *self, api_status *status); +API_MUST_USE api_Sheet *api_Sheet_default(void); +API_MUST_USE api_buf api_Sheet_title_get(const api_Sheet *self, api_status *status); void api_Sheet_title_set(api_Sheet *self, api_buf value, api_status *status); -api_Sheet *api_Sheet_new(void); +API_MUST_USE api_Sheet *api_Sheet_new(void); uint32_t api_Sheet_lines(const api_Sheet *self, api_status *status); void api_Sheet_write(api_Sheet *self, api_buf line, api_status *status); -api_buf api_Sheet_describe(const api_Sheet *self, api_status *status); +API_MUST_USE api_buf api_Sheet_describe(const api_Sheet *self, api_status *status); void api_Name_free(api_Name *self); void api_Name_drop(api_Name *self, api_status *status); -api_Name *api_Name_clone(const api_Name *self, api_status *status); +API_MUST_USE api_Name *api_Name_clone(const api_Name *self, api_status *status); bool api_Name_eq(const api_Name *a, const api_Name *b, api_status *status); -api_buf api_Name_debug(const api_Name *self, api_status *status); -api_Name *api_Name_owned(api_buf text); -api_buf api_Name_as_str(const api_Name *self, api_status *status); -api_Name *api_Name_join(const api_Name *self, const api_Name *other, api_status *status); -api_Name *api_Name_borrowed(api_buf text); +API_MUST_USE api_buf api_Name_debug(const api_Name *self, api_status *status); +API_MUST_USE api_Name *api_Name_owned(api_buf text); +API_MUST_USE api_buf api_Name_as_str(const api_Name *self, api_status *status); +API_MUST_USE api_Name *api_Name_join(const api_Name *self, const api_Name *other, api_status *status); +API_MUST_USE api_Name *api_Name_borrowed(api_buf text); bool api_Name_shares(const api_Name *self, const api_Name *other, api_status *status); void api_Name_rename(api_Name *self, api_buf text, api_status *status); void api_Channel_free(api_Channel *self); void api_Channel_drop(api_Channel *self, api_status *status); -api_Channel *api_Channel_clone(const api_Channel *self, api_status *status); -api_Channel *api_Channel_default(void); -api_Channel *api_Channel_new(void); +API_MUST_USE api_Channel *api_Channel_clone(const api_Channel *self, api_status *status); +API_MUST_USE api_Channel *api_Channel_default(void); +API_MUST_USE api_Channel *api_Channel_new(void); void api_Channel_clear(api_Channel *self, api_status *status); void api_Channel_send(const api_Channel *self, api_buf payload, api_status *status); typedef struct api_Channel_recv_future api_Channel_recv_future; -api_Channel_recv_future *api_Channel_recv(const api_Channel *self, api_status *status); -api_poll api_Channel_recv_start(const api_Channel *self, api_buf *out, api_Channel_recv_future **future, api_status *status); -api_poll api_Channel_recv_poll(api_Channel_recv_future *future, api_waker waker, api_buf *out); +API_MUST_USE api_Channel_recv_future *api_Channel_recv(const api_Channel *self, api_status *status); +API_MUST_USE api_poll api_Channel_recv_start(const api_Channel *self, api_buf *out, api_Channel_recv_future **future, api_status *status); +API_MUST_USE api_poll api_Channel_recv_poll(api_Channel_recv_future *future, api_waker waker, api_buf *out); void api_Channel_recv_future_free(api_Channel_recv_future *future); void api_Channel_notify(const api_Channel *self, api_waker waker_, api_status *status); typedef struct api_Channel_send_later_future api_Channel_send_later_future; -api_Channel_send_later_future *api_Channel_send_later(const api_Channel *self, api_buf payload, api_status *status); -api_poll api_Channel_send_later_start(const api_Channel *self, api_buf payload, api_Channel_send_later_future **future, api_status *status); -api_poll api_Channel_send_later_poll(api_Channel_send_later_future *future, api_waker waker); +API_MUST_USE api_Channel_send_later_future *api_Channel_send_later(const api_Channel *self, api_buf payload, api_status *status); +API_MUST_USE api_poll api_Channel_send_later_start(const api_Channel *self, api_buf payload, api_Channel_send_later_future **future, api_status *status); +API_MUST_USE api_poll api_Channel_send_later_poll(api_Channel_send_later_future *future, api_waker waker); void api_Channel_send_later_future_free(api_Channel_send_later_future *future); typedef struct api_Channel_tagged_future api_Channel_tagged_future; -api_Channel_tagged_future *api_Channel_tagged(const api_Channel *self, api_buf tag, api_status *status); -api_poll api_Channel_tagged_start(const api_Channel *self, api_buf tag, api_buf *out, api_Channel_tagged_future **future, api_status *status); -api_poll api_Channel_tagged_poll(api_Channel_tagged_future *future, api_waker waker, api_buf *out); +API_MUST_USE api_Channel_tagged_future *api_Channel_tagged(const api_Channel *self, api_buf tag, api_status *status); +API_MUST_USE api_poll api_Channel_tagged_start(const api_Channel *self, api_buf tag, api_buf *out, api_Channel_tagged_future **future, api_status *status); +API_MUST_USE api_poll api_Channel_tagged_poll(api_Channel_tagged_future *future, api_waker waker, api_buf *out); void api_Channel_tagged_future_free(api_Channel_tagged_future *future); typedef struct api_Channel_itemized_future api_Channel_itemized_future; -api_Channel_itemized_future *api_Channel_itemized(const api_Channel *self, api_vec_u32 items, api_status *status); -api_poll api_Channel_itemized_start(const api_Channel *self, api_vec_u32 items, size_t *out, api_Channel_itemized_future **future, api_status *status); -api_poll api_Channel_itemized_poll(api_Channel_itemized_future *future, api_waker waker, size_t *out); +API_MUST_USE api_Channel_itemized_future *api_Channel_itemized(const api_Channel *self, api_vec_u32 items, api_status *status); +API_MUST_USE api_poll api_Channel_itemized_start(const api_Channel *self, api_vec_u32 items, size_t *out, api_Channel_itemized_future **future, api_status *status); +API_MUST_USE api_poll api_Channel_itemized_poll(api_Channel_itemized_future *future, api_waker waker, size_t *out); void api_Channel_itemized_future_free(api_Channel_itemized_future *future); typedef struct api_Channel_poll_take_future api_Channel_poll_take_future; -api_Channel_poll_take_future *api_Channel_poll_take(const api_Channel *self, api_status *status); -api_poll api_Channel_poll_take_start(const api_Channel *self, api_buf *out, api_Channel_poll_take_future **future, api_status *status); -api_poll api_Channel_poll_take_poll(api_Channel_poll_take_future *future, api_waker waker, api_buf *out); +API_MUST_USE api_Channel_poll_take_future *api_Channel_poll_take(const api_Channel *self, api_status *status); +API_MUST_USE api_poll api_Channel_poll_take_start(const api_Channel *self, api_buf *out, api_Channel_poll_take_future **future, api_status *status); +API_MUST_USE api_poll api_Channel_poll_take_poll(api_Channel_poll_take_future *future, api_waker waker, api_buf *out); void api_Channel_poll_take_future_free(api_Channel_poll_take_future *future); typedef struct api_Channel_poll_measure_future api_Channel_poll_measure_future; -api_Channel_poll_measure_future *api_Channel_poll_measure(api_Channel *self, size_t extra, api_status *status); -api_poll api_Channel_poll_measure_start(api_Channel *self, size_t extra, size_t *out, api_Error *err, api_Channel_poll_measure_future **future, api_status *status); -api_poll api_Channel_poll_measure_poll(api_Channel_poll_measure_future *future, api_waker waker, size_t *out, api_Error *err); +API_MUST_USE api_Channel_poll_measure_future *api_Channel_poll_measure(api_Channel *self, size_t extra, api_status *status); +API_MUST_USE api_poll api_Channel_poll_measure_start(api_Channel *self, size_t extra, size_t *out, api_Error *err, api_Channel_poll_measure_future **future, api_status *status); +API_MUST_USE api_poll api_Channel_poll_measure_poll(api_Channel_poll_measure_future *future, api_waker waker, size_t *out, api_Error *err); void api_Channel_poll_measure_future_free(api_Channel_poll_measure_future *future); void api_Channel_listen(const api_Channel *self, api_waker cx, api_status *status); typedef struct api_Channel_recv_sized_future api_Channel_recv_sized_future; -api_Channel_recv_sized_future *api_Channel_recv_sized(const api_Channel *self, api_status *status); -api_poll api_Channel_recv_sized_start(const api_Channel *self, api_buf *out0, size_t *out1, api_Channel_recv_sized_future **future, api_status *status); -api_poll api_Channel_recv_sized_poll(api_Channel_recv_sized_future *future, api_waker waker, api_buf *out0, size_t *out1); +API_MUST_USE api_Channel_recv_sized_future *api_Channel_recv_sized(const api_Channel *self, api_status *status); +API_MUST_USE api_poll api_Channel_recv_sized_start(const api_Channel *self, api_buf *out0, size_t *out1, api_Channel_recv_sized_future **future, api_status *status); +API_MUST_USE api_poll api_Channel_recv_sized_poll(api_Channel_recv_sized_future *future, api_waker waker, api_buf *out0, size_t *out1); void api_Channel_recv_sized_future_free(api_Channel_recv_sized_future *future); typedef struct api_Channel_recv_nonempty_future api_Channel_recv_nonempty_future; -api_Channel_recv_nonempty_future *api_Channel_recv_nonempty(const api_Channel *self, api_status *status); -api_poll api_Channel_recv_nonempty_start(const api_Channel *self, api_buf *out, api_Error *err, api_Channel_recv_nonempty_future **future, api_status *status); -api_poll api_Channel_recv_nonempty_poll(api_Channel_recv_nonempty_future *future, api_waker waker, api_buf *out, api_Error *err); +API_MUST_USE api_Channel_recv_nonempty_future *api_Channel_recv_nonempty(const api_Channel *self, api_status *status); +API_MUST_USE api_poll api_Channel_recv_nonempty_start(const api_Channel *self, api_buf *out, api_Error *err, api_Channel_recv_nonempty_future **future, api_status *status); +API_MUST_USE api_poll api_Channel_recv_nonempty_poll(api_Channel_recv_nonempty_future *future, api_waker waker, api_buf *out, api_Error *err); void api_Channel_recv_nonempty_future_free(api_Channel_recv_nonempty_future *future); void api_Channel_send_from_thread(const api_Channel *self, api_buf payload, api_status *status); void api_Gap_free(api_Gap *self); bool api_Gap_borrowed(const api_Gap *self); -api_Gap *api_Gap_clone(const api_Gap *self); +API_MUST_USE api_Gap *api_Gap_clone(const api_Gap *self); bool api_Gap_eq(const api_Gap *a, const api_Gap *b); -api_buf api_Gap_debug(const api_Gap *self); -api_Gap *api_Gap_new(uint64_t wide, uint8_t narrow); +API_MUST_USE api_buf api_Gap_debug(const api_Gap *self); +API_MUST_USE api_Gap *api_Gap_new(uint64_t wide, uint8_t narrow); uint64_t api_Gap_sum(const api_Gap *self); void api_Berth_free(api_Berth *self); bool api_Berth_borrowed(const api_Berth *self); -api_Berth *api_Berth_clone(const api_Berth *self); -api_buf api_Berth_debug(const api_Berth *self); -api_Berth *api_Berth_new(api_option_u32 at); +API_MUST_USE api_Berth *api_Berth_clone(const api_Berth *self); +API_MUST_USE api_buf api_Berth_debug(const api_Berth *self); +API_MUST_USE api_Berth *api_Berth_new(api_option_u32 at); api_option_u32 api_Berth_at(const api_Berth *self); void api_Mark_free(api_Mark *self); void api_Mark_drop(api_Mark *self, api_status *status); -api_Mark *api_Mark_clone(const api_Mark *self, api_status *status); +API_MUST_USE api_Mark *api_Mark_clone(const api_Mark *self, api_status *status); bool api_Mark_eq(const api_Mark *a, const api_Mark *b, api_status *status); -api_buf api_Mark_debug(const api_Mark *self, api_status *status); -api_Mark *api_Mark_of(uint64_t count); +API_MUST_USE api_buf api_Mark_debug(const api_Mark *self, api_status *status); +API_MUST_USE api_Mark *api_Mark_of(uint64_t count); uint64_t api_Mark_count(const api_Mark *self, api_status *status); void api_Mark_add(api_Mark *self, uint64_t by, api_status *status); void api_Message_free(api_Message *self); void api_Message_drop(api_Message *self, api_status *status); -api_Message *api_Message_clone(const api_Message *self, api_status *status); -api_buf api_Message_debug(const api_Message *self, api_status *status); +API_MUST_USE api_Message *api_Message_clone(const api_Message *self, api_status *status); +API_MUST_USE api_buf api_Message_debug(const api_Message *self, api_status *status); api_option_Stamp api_Message_stamp_get(const api_Message *self, api_status *status); void api_Message_stamp_set(api_Message *self, api_option_Stamp value, api_status *status); -api_buf api_Message_payload_get(const api_Message *self, api_status *status); +API_MUST_USE api_buf api_Message_payload_get(const api_Message *self, api_status *status); void api_Message_payload_set(api_Message *self, api_buf value, api_status *status); -api_Message *api_Message_new(api_option_Stamp stamp, api_buf payload); +API_MUST_USE api_Message *api_Message_new(api_option_Stamp stamp, api_buf payload); bool api_Message_sent(const api_Message *self, api_status *status); void api_Node_free(api_Node *self); void api_Node_drop(api_Node *self, api_status *status); -api_buf api_Node_debug(const api_Node *self, api_status *status); +API_MUST_USE api_buf api_Node_debug(const api_Node *self, api_status *status); uint64_t api_Node_value_get(const api_Node *self, api_status *status); void api_Node_value_set(api_Node *self, uint64_t value, api_status *status); -api_Node *api_Node_next_get(const api_Node *self, api_status *status); +API_MUST_USE api_Node *api_Node_next_get(const api_Node *self, api_status *status); void api_Node_next_set(api_Node *self, api_Node *value, api_status *status); -api_Node *api_Node_new(uint64_t value, api_Node *next, api_status *status); +API_MUST_USE api_Node *api_Node_new(uint64_t value, api_Node *next, api_status *status); void api_Node_push(api_Node *self, uint64_t value, api_status *status); uint64_t api_Node_sum(const api_Node *self, api_status *status); void api_Tally_free(api_Tally *self); void api_Tally_drop(api_Tally *self, api_status *status); bool api_Tally_eq(const api_Tally *a, const api_Tally *b, api_status *status); -api_buf api_Tally_debug(const api_Tally *self, api_status *status); -api_Tally *api_Tally_default(void); -api_Tally *api_Tally_new(void); +API_MUST_USE api_buf api_Tally_debug(const api_Tally *self, api_status *status); +API_MUST_USE api_Tally *api_Tally_default(void); +API_MUST_USE api_Tally *api_Tally_new(void); uint32_t api_Tally_bump(const api_Tally *self, api_status *status); typedef struct api_Tally_bump_later_future api_Tally_bump_later_future; -api_Tally_bump_later_future *api_Tally_bump_later(const api_Tally *self, api_status *status); -api_poll api_Tally_bump_later_start(const api_Tally *self, uint32_t *out, api_Tally_bump_later_future **future, api_status *status); -api_poll api_Tally_bump_later_poll(api_Tally_bump_later_future *future, api_waker waker, uint32_t *out, api_status *status); +API_MUST_USE api_Tally_bump_later_future *api_Tally_bump_later(const api_Tally *self, api_status *status); +API_MUST_USE api_poll api_Tally_bump_later_start(const api_Tally *self, uint32_t *out, api_Tally_bump_later_future **future, api_status *status); +API_MUST_USE api_poll api_Tally_bump_later_poll(api_Tally_bump_later_future *future, api_waker waker, uint32_t *out, api_status *status); void api_Tally_bump_later_future_free(api_Tally_bump_later_future *future); -api_Tally_bump_later_future *api_Tally_bump_later_homed(const api_Tally *self, api_status *status); -api_poll api_Tally_bump_later_start_homed(const api_Tally *self, uint32_t *out, api_Tally_bump_later_future **future, api_status *status); +API_MUST_USE api_Tally_bump_later_future *api_Tally_bump_later_homed(const api_Tally *self, api_status *status); +API_MUST_USE api_poll api_Tally_bump_later_start_homed(const api_Tally *self, uint32_t *out, api_Tally_bump_later_future **future, api_status *status); void api_Tallies_free(api_Tallies *self); void api_Tallies_drop(api_Tallies *self, api_status *status); -api_Tallies *api_Tallies_default(void); -api_Tallies *api_Tallies_new(void); -api_Tally *api_Tallies_first(const api_Tallies *self, api_status *status); +API_MUST_USE api_Tallies *api_Tallies_default(void); +API_MUST_USE api_Tallies *api_Tallies_new(void); +API_MUST_USE api_Tally *api_Tallies_first(const api_Tallies *self, api_status *status); void api_Plain_free(api_Plain *self); void api_Plain_drop(api_Plain *self, api_status *status); bool api_Plain_eq(const api_Plain *a, const api_Plain *b, api_status *status); uint64_t api_Plain_hash(const api_Plain *self, api_status *status); -api_buf api_Plain_debug(const api_Plain *self, api_status *status); +API_MUST_USE api_buf api_Plain_debug(const api_Plain *self, api_status *status); uint64_t api_Plain_n_get(const api_Plain *self, api_status *status); void api_Plain_n_set(api_Plain *self, uint64_t value, api_status *status); bool api_Plain_on_get(const api_Plain *self, api_status *status); void api_Plain_on_set(api_Plain *self, bool value, api_status *status); -api_Plain *api_Plain_new(uint64_t n, bool on); +API_MUST_USE api_Plain *api_Plain_new(uint64_t n, bool on); void api_Labeled_free(api_Labeled *self); bool api_Labeled_eq(const api_Labeled *a, const api_Labeled *b); uint64_t api_Labeled_hash(const api_Labeled *self); -api_buf api_Labeled_debug(const api_Labeled *self); -api_Labeled *api_Labeled_new(api_buf label); +API_MUST_USE api_buf api_Labeled_debug(const api_Labeled *self); +API_MUST_USE api_Labeled *api_Labeled_new(api_buf label); void api_Gauge_free(api_Gauge *self); void api_Gauge_drop(api_Gauge *self, api_status *status); bool api_Gauge_borrowed(const api_Gauge *self); -api_Gauge *api_Gauge_clone(const api_Gauge *self, api_status *status); -api_Gauge *api_Gauge_new(uint64_t level); +API_MUST_USE api_Gauge *api_Gauge_clone(const api_Gauge *self, api_status *status); +API_MUST_USE api_Gauge *api_Gauge_new(uint64_t level); void api_Gauge_set(const api_Gauge *self, uint64_t level, api_status *status); uint64_t api_Gauge_level(const api_Gauge *self, api_status *status); uint64_t api_Gauge_into_level(api_Gauge *self, api_status *status); typedef struct api_Gauge_later_future api_Gauge_later_future; -api_Gauge_later_future *api_Gauge_later(const api_Gauge *self, api_status *status); -api_poll api_Gauge_later_start(const api_Gauge *self, uint64_t *out, api_Gauge_later_future **future, api_status *status); -api_poll api_Gauge_later_poll(api_Gauge_later_future *future, api_waker waker, uint64_t *out); +API_MUST_USE api_Gauge_later_future *api_Gauge_later(const api_Gauge *self, api_status *status); +API_MUST_USE api_poll api_Gauge_later_start(const api_Gauge *self, uint64_t *out, api_Gauge_later_future **future, api_status *status); +API_MUST_USE api_poll api_Gauge_later_poll(api_Gauge_later_future *future, api_waker waker, uint64_t *out); void api_Gauge_later_future_free(api_Gauge_later_future *future); typedef struct api_Gauge_reaches_future api_Gauge_reaches_future; -api_Gauge_reaches_future *api_Gauge_reaches(const api_Gauge *self, uint64_t this_, api_status *status); -api_poll api_Gauge_reaches_start(const api_Gauge *self, uint64_t this_, bool *out, api_Gauge_reaches_future **future, api_status *status); -api_poll api_Gauge_reaches_poll(api_Gauge_reaches_future *future, api_waker waker, bool *out); +API_MUST_USE api_Gauge_reaches_future *api_Gauge_reaches(const api_Gauge *self, uint64_t this_, api_status *status); +API_MUST_USE api_poll api_Gauge_reaches_start(const api_Gauge *self, uint64_t this_, bool *out, api_Gauge_reaches_future **future, api_status *status); +API_MUST_USE api_poll api_Gauge_reaches_poll(api_Gauge_reaches_future *future, api_waker waker, bool *out); void api_Gauge_reaches_future_free(api_Gauge_reaches_future *future); void api_Latch_free(api_Latch *self); -api_Latch *api_Latch_clone(const api_Latch *self); -api_Latch *api_Latch_default(void); +API_MUST_USE api_Latch *api_Latch_clone(const api_Latch *self); +API_MUST_USE api_Latch *api_Latch_default(void); bool api_Latch_set(const api_Latch *self, uint32_t value); api_option_u32 api_Latch_get(const api_Latch *self); void api_Token_free(api_Token *self); void api_Token_drop(api_Token *self, api_status *status); -api_Token *api_Token_clone(const api_Token *self, api_status *status); +API_MUST_USE api_Token *api_Token_clone(const api_Token *self, api_status *status); uint32_t api_Token_id_get(const api_Token *self, api_status *status); void api_Token_id_set(api_Token *self, uint32_t value, api_status *status); -api_Token *api_Token_new(uint32_t id); -api_vec_Token api_Token_twice(const api_Token *self, api_status *status); +API_MUST_USE api_Token *api_Token_new(uint32_t id); +API_MUST_USE api_vec_Token api_Token_twice(const api_Token *self, api_status *status); void api_Stack_free(api_Stack *self); void api_Stack_drop(api_Stack *self, api_status *status); -api_buf api_Stack_debug(const api_Stack *self, api_status *status); -api_Stack *api_Stack_default(void); -api_Stack *api_Stack_new(void); +API_MUST_USE api_buf api_Stack_debug(const api_Stack *self, api_status *status); +API_MUST_USE api_Stack *api_Stack_default(void); +API_MUST_USE api_Stack *api_Stack_new(void); void api_Stack_push(api_Stack *self, api_Counter *item, api_status *status); -api_Counter *api_Stack_pop(api_Stack *self, api_status *status); +API_MUST_USE api_Counter *api_Stack_pop(api_Stack *self, api_status *status); size_t api_Stack_depth(const api_Stack *self, api_status *status); uint64_t api_Stack_depth_past_Point(const api_Stack *self, api_Point from, api_status *status); uint64_t api_Stack_depth_past_Counter(const api_Stack *self, const api_Counter *from, api_status *status); @@ -1920,145 +1930,145 @@ uint64_t api_Stack_depth_past_Wrap_u32(const api_Stack *self, api_Wrap_u32 from, uint64_t api_Stack_depth_past_polar_Point(const api_Stack *self, api_polar_Point from, api_status *status); void api_Refusal_free(api_Refusal *self); void api_Refusal_drop(api_Refusal *self, api_status *status); -api_buf api_Refusal_to_string(const api_Refusal *self, api_status *status); -api_buf api_Refusal_debug(const api_Refusal *self, api_status *status); +API_MUST_USE api_buf api_Refusal_to_string(const api_Refusal *self, api_status *status); +API_MUST_USE api_buf api_Refusal_debug(const api_Refusal *self, api_status *status); void api_Fault_free(api_Fault *self); -api_buf api_Fault_to_string(const api_Fault *self); -api_buf api_Fault_debug(const api_Fault *self); +API_MUST_USE api_buf api_Fault_to_string(const api_Fault *self); +API_MUST_USE api_buf api_Fault_debug(const api_Fault *self); void api_c_free(api_c *self); bool api_c_eq(const api_c *a, const api_c *b); -api_buf api_c_debug(const api_c *self); -api_c *api_c_new(uint8_t value); +API_MUST_USE api_buf api_c_debug(const api_c *self); +API_MUST_USE api_c *api_c_new(uint8_t value); void api_Key_free(api_Key *self); bool api_Key_borrowed(const api_Key *self); -api_Key *api_Key_clone(const api_Key *self); +API_MUST_USE api_Key *api_Key_clone(const api_Key *self); bool api_Key_eq(const api_Key *a, const api_Key *b); uint64_t api_Key_hash(const api_Key *self); -api_buf api_Key_debug(const api_Key *self); -api_Key *api_Key_new(api_buf name); +API_MUST_USE api_buf api_Key_debug(const api_Key *self); +API_MUST_USE api_Key *api_Key_new(api_buf name); uint64_t api_Key_hash_of(const api_Key *self); void api_clash_Seed_free(api_clash_Seed *self); -api_clash_Seed *api_clash_Seed_default(void); -api_clash_Seed *api_clash_Seed_default_(void); +API_MUST_USE api_clash_Seed *api_clash_Seed_default(void); +API_MUST_USE api_clash_Seed *api_clash_Seed_default_(void); uint32_t api_clash_Seed_value(const api_clash_Seed *self); bool api_clash_Seed_bool(const api_clash_Seed *self); void api_clash_Empty_string_free(api_clash_Empty_string *self); bool api_clash_Empty_string_is_empty(const api_clash_Empty_string *self); void api_clash_Store_free(api_clash_Store *self); -api_clash_Store *api_clash_Store_new(uint32_t count); +API_MUST_USE api_clash_Store *api_clash_Store_new(uint32_t count); uint32_t api_clash_Store_free_(const api_clash_Store *self); uint32_t api_clash_Store_close(const api_clash_Store *self); void api_tls_Session_free(api_tls_Session *self); -api_buf api_tls_Session_alpn(const api_tls_Session *self); +API_MUST_USE api_buf api_tls_Session_alpn(const api_tls_Session *self); api_tls_policy_Lifetime api_tls_Session_lifetime(const api_tls_Session *self); void api_Url_free(api_Url *self); void api_Url_drop(api_Url *self, api_status *status); bool api_Url_borrowed(const api_Url *self); -api_Url *api_Url_clone(const api_Url *self, api_status *status); +API_MUST_USE api_Url *api_Url_clone(const api_Url *self, api_status *status); bool api_Url_eq(const api_Url *a, const api_Url *b, api_status *status); uint64_t api_Url_hash(const api_Url *self, api_status *status); -api_buf api_Url_to_string(const api_Url *self, api_status *status); -api_buf api_Url_debug(const api_Url *self, api_status *status); -bool api_Url_parse(api_buf input, api_Url **out, api_buf *err); +API_MUST_USE api_buf api_Url_to_string(const api_Url *self, api_status *status); +API_MUST_USE api_buf api_Url_debug(const api_Url *self, api_status *status); +API_MUST_USE bool api_Url_parse(api_buf input, api_Url **out, api_buf *err); void api_Json_free(api_Json *self); void api_Json_drop(api_Json *self, api_status *status); -bool api_Json_parse(api_buf input, api_Json **out, api_buf *err); -api_buf api_Json_to_text(const api_Json *self, api_status *status); +API_MUST_USE bool api_Json_parse(api_buf input, api_Json **out, api_buf *err); +API_MUST_USE api_buf api_Json_to_text(const api_Json *self, api_status *status); void api_Instant_free(api_Instant *self); bool api_Instant_borrowed(const api_Instant *self); -api_Instant *api_Instant_clone(const api_Instant *self); +API_MUST_USE api_Instant *api_Instant_clone(const api_Instant *self); bool api_Instant_eq(const api_Instant *a, const api_Instant *b); uint64_t api_Instant_hash(const api_Instant *self); -api_buf api_Instant_debug(const api_Instant *self); +API_MUST_USE api_buf api_Instant_debug(const api_Instant *self); void api_std_io_Error_free(api_std_io_Error *self); void api_std_io_Error_drop(api_std_io_Error *self, api_status *status); void api_tls_Config_free(api_tls_Config *self); void api_tls_Config_drop(api_tls_Config *self, api_status *status); bool api_tls_Config_borrowed(const api_tls_Config *self); -api_tls_Config *api_tls_Config_clone(const api_tls_Config *self, api_status *status); +API_MUST_USE api_tls_Config *api_tls_Config_clone(const api_tls_Config *self, api_status *status); void api_tls_Cert_free(api_tls_Cert *self); void api_tls_Cert_drop(api_tls_Cert *self, api_status *status); void api_tls_Resolver_free(api_tls_Resolver *self); void api_tls_Resolver_drop(api_tls_Resolver *self, api_status *status); bool api_tls_Resolver_borrowed(const api_tls_Resolver *self); -api_tls_Resolver *api_tls_Resolver_clone(const api_tls_Resolver *self, api_status *status); +API_MUST_USE api_tls_Resolver *api_tls_Resolver_clone(const api_tls_Resolver *self, api_status *status); void api_tls_Codec_free(api_tls_Codec *self); void api_tls_Codec_drop(api_tls_Codec *self, api_status *status); void api_Spawned_free(api_Spawned *self); void api_Spawned_drop(api_Spawned *self, api_status *status); -api_Spawned *api_Spawned_new(uint32_t (*task)(void *data), void *task_data, void (*task_free)(void *data)); +API_MUST_USE api_Spawned *api_Spawned_new(uint32_t (*task)(void *data), void *task_data, void (*task_free)(void *data)); uint32_t api_Spawned_join(api_Spawned *self, api_status *status); void api_LogThread_free(api_LogThread *self); void api_LogThread_drop(api_LogThread *self, api_status *status); -api_LogThread *api_LogThread_new(api_Log log, api_buf line); +API_MUST_USE api_LogThread *api_LogThread_new(api_Log log, api_buf line); bool api_LogThread_join(api_LogThread *self, api_status *status); void api_Pinned_free(api_Pinned *self); void api_Pinned_drop(api_Pinned *self, api_status *status); uint64_t api_Pinned_value_get(const api_Pinned *self, api_status *status); void api_Pinned_value_set(api_Pinned *self, uint64_t value, api_status *status); -api_Pinned *api_Pinned_new(uint64_t value); -api_Pinned *api_Pinned_new_homed(uint64_t value); -api_Part *api_Pinned_part(const api_Pinned *self, api_status *status); +API_MUST_USE api_Pinned *api_Pinned_new(uint64_t value); +API_MUST_USE api_Pinned *api_Pinned_new_homed(uint64_t value); +API_MUST_USE api_Part *api_Pinned_part(const api_Pinned *self, api_status *status); void api_Hooked_free(api_Hooked *self); void api_Hooked_drop(api_Hooked *self, api_status *status); bool api_Hooked_eq(const api_Hooked *a, const api_Hooked *b, api_status *status); -api_buf api_Hooked_debug(const api_Hooked *self, api_status *status); +API_MUST_USE api_buf api_Hooked_debug(const api_Hooked *self, api_status *status); uint64_t api_Hooked_n_get(const api_Hooked *self, api_status *status); void api_Hooked_n_set(api_Hooked *self, uint64_t value, api_status *status); -api_Hooked *api_Hooked_new(uint64_t n); +API_MUST_USE api_Hooked *api_Hooked_new(uint64_t n); void api_Forged_free(api_Forged *self); void api_Forged_drop(api_Forged *self, api_status *status); bool api_Forged_eq(const api_Forged *a, const api_Forged *b, api_status *status); -api_buf api_Forged_debug(const api_Forged *self, api_status *status); +API_MUST_USE api_buf api_Forged_debug(const api_Forged *self, api_status *status); uint64_t api_Forged_n_get(const api_Forged *self, api_status *status); void api_Forged_n_set(api_Forged *self, uint64_t value, api_status *status); -api_Forged *api_Forged_new(uint64_t n); +API_MUST_USE api_Forged *api_Forged_new(uint64_t n); void api_Part_free(api_Part *self); void api_Part_drop(api_Part *self, api_status *status); bool api_Part_eq(const api_Part *a, const api_Part *b, api_status *status); uint64_t api_Part_hash(const api_Part *self, api_status *status); -api_buf api_Part_debug(const api_Part *self, api_status *status); +API_MUST_USE api_buf api_Part_debug(const api_Part *self, api_status *status); uint64_t api_Part_value_get(const api_Part *self, api_status *status); void api_Part_value_set(api_Part *self, uint64_t value, api_status *status); bool api_has_text(api_Note note); uint64_t api_marked(const api_Mark *api_marked, api_status *status); -api_option_Reading api_reading(uint32_t n); -api_buf api_reading_debug(uint32_t n); -api_option_Reading api_reading_echo(api_option_Reading reading); +API_MUST_USE api_option_Reading api_reading(uint32_t n); +API_MUST_USE api_buf api_reading_debug(uint32_t n); +API_MUST_USE api_option_Reading api_reading_echo(api_option_Reading reading); void api_reading_bump(api_option_Reading reading, api_option_Reading *reading_out); api_Stage api_advance(api_Stage stage); void api_only(api_Counter *counter, api_Counter **out0, api_status *status); void api_widths(uint64_t n, uint8_t *out0, int16_t *out1, uint32_t *out2, uint64_t *out3); -bool api_divide(uint64_t a, uint64_t b, uint64_t *out0, uint64_t *out1, api_Error *err); -bool api_corner(bool unit, api_tuple_u32_u32 *out, api_Error *err); +API_MUST_USE bool api_divide(uint64_t a, uint64_t b, uint64_t *out0, uint64_t *out1, api_Error *err); +API_MUST_USE bool api_corner(bool unit, api_tuple_u32_u32 *out, api_Error *err); typedef struct api_corner_later_future api_corner_later_future; -api_corner_later_future *api_corner_later(void); -api_poll api_corner_later_start(api_tuple_u32_u32 *out, api_corner_later_future **future); -api_poll api_corner_later_poll(api_corner_later_future *future, api_waker waker, api_tuple_u32_u32 *out); +API_MUST_USE api_corner_later_future *api_corner_later(void); +API_MUST_USE api_poll api_corner_later_start(api_tuple_u32_u32 *out, api_corner_later_future **future); +API_MUST_USE api_poll api_corner_later_poll(api_corner_later_future *future, api_waker waker, api_tuple_u32_u32 *out); void api_corner_later_future_free(api_corner_later_future *future); api_option_tuple_u8_i16_u32_u64 api_spread(uint64_t n); api_option_tuple_usize_usize api_find(api_buf haystack, api_buf needle); -api_vec_tuple_string_Shape_Point api_rows(api_vec_Point points); -bool api_port(api_buf text, uint16_t *out, api_buf *err); +API_MUST_USE api_vec_tuple_string_Shape_Point api_rows(api_vec_Point points); +API_MUST_USE bool api_port(api_buf text, uint16_t *out, api_buf *err); uint32_t api_span(uint32_t start, uint32_t end); void api_halves(api_Span span, api_tuple_u32_u32 *out0, api_tuple_u32_u32 *out1); api_option_tuple_option_u32 api_doubled(api_option_tuple_option_u32 value); -api_option_tuple_string api_title(bool formal); -api_option_tuple_string api_named(api_buf name); -api_tuple_bytes api_lent_back(api_tuple_bytes value); -api_tuple_bytes api_boxed_tuple(api_buf bytes); +API_MUST_USE api_option_tuple_string api_title(bool formal); +API_MUST_USE api_option_tuple_string api_named(api_buf name); +API_MUST_USE api_tuple_bytes api_lent_back(api_tuple_bytes value); +API_MUST_USE api_tuple_bytes api_boxed_tuple(api_buf bytes); void api_swapped(api_tuple_string_u32 pair, uint32_t *out0, api_buf *out1); bool api_lasting(const api_Draft *draft, api_status *status); uint32_t api_stored(api_Receipt *receipt, api_status *status); uint32_t api_tallied(api_Receipt *receipt, api_status *status); uint32_t api_summed_up_Receipt(api_Receipt *totaled, api_status *status); uint32_t api_erased(api_Receipt *receipt, api_status *status); -api_Name *api_longer(api_Name *a, const api_Name *b, api_status *status); -api_Name *api_unnamed(void); +API_MUST_USE api_Name *api_longer(api_Name *a, const api_Name *b, api_status *status); +API_MUST_USE api_Name *api_unnamed(void); uint64_t api_total(api_range_u64 range); uint32_t api_reach(uint32_t start, uint32_t end); api_option_u128 api_scaled(api_u128 v, uint64_t by); -api_Batch_2 *api_pair(void); +API_MUST_USE api_Batch_2 *api_pair(void); uint64_t api_drain_4(api_Batch *batch, api_status *status); uint64_t api_drain_2(api_Batch_2 *batch, api_status *status); size_t api_capacities_4_4(const api_Batch *a, const api_Batch *b, api_status *status); @@ -2066,114 +2076,114 @@ size_t api_capacities_4_2(const api_Batch *a, const api_Batch_2 *b, api_status * size_t api_capacities_2_4(const api_Batch_2 *a, const api_Batch *b, api_status *status); size_t api_capacities_2_2(const api_Batch_2 *a, const api_Batch_2 *b, api_status *status); typedef struct api_fill_4_future api_fill_4_future; -api_fill_4_future *api_fill_4(api_Batch *batch, uint32_t v, api_status *status); -api_poll api_fill_4_start(api_Batch *batch, uint32_t v, api_vec_u32 *out, api_fill_4_future **future, api_status *status); -api_poll api_fill_4_poll(api_fill_4_future *future, api_waker waker, api_vec_u32 *out); +API_MUST_USE api_fill_4_future *api_fill_4(api_Batch *batch, uint32_t v, api_status *status); +API_MUST_USE api_poll api_fill_4_start(api_Batch *batch, uint32_t v, api_vec_u32 *out, api_fill_4_future **future, api_status *status); +API_MUST_USE api_poll api_fill_4_poll(api_fill_4_future *future, api_waker waker, api_vec_u32 *out); void api_fill_4_future_free(api_fill_4_future *future); typedef struct api_fill_2_future api_fill_2_future; -api_fill_2_future *api_fill_2(api_Batch_2 *batch, uint32_t v, api_status *status); -api_poll api_fill_2_start(api_Batch_2 *batch, uint32_t v, api_vec_u32 *out, api_fill_2_future **future, api_status *status); -api_poll api_fill_2_poll(api_fill_2_future *future, api_waker waker, api_vec_u32 *out); +API_MUST_USE api_fill_2_future *api_fill_2(api_Batch_2 *batch, uint32_t v, api_status *status); +API_MUST_USE api_poll api_fill_2_start(api_Batch_2 *batch, uint32_t v, api_vec_u32 *out, api_fill_2_future **future, api_status *status); +API_MUST_USE api_poll api_fill_2_poll(api_fill_2_future *future, api_waker waker, api_vec_u32 *out); void api_fill_2_future_free(api_fill_2_future *future); api_range_u64 api_widen(api_range_u64 range, uint64_t by); size_t api_count(api_bounds_u64 range); api_bound_u64 api_end(uint64_t limit); void api_ends(uint64_t limit, api_bound_u64 *out0, api_bound_u64 *out1); -bool api_below(uint64_t n, uint64_t limit, uint64_t *out, api_bounds_u64 *err); +API_MUST_USE bool api_below(uint64_t n, uint64_t limit, uint64_t *out, api_bounds_u64 *err); typedef struct api_drive_future api_drive_future; -api_drive_future *api_drive(api_Moment start, bool (*poll)(void *data, api_Moment, const api_Waiter *, api_option_Moment *, api_buf *), void *poll_data, void (*poll_free)(void *data)); -api_poll api_drive_start(api_Moment start, bool (*poll)(void *data, api_Moment, const api_Waiter *, api_option_Moment *, api_buf *), void *poll_data, void (*poll_free)(void *data), api_buf *out, api_drive_future **future); -api_poll api_drive_poll(api_drive_future *future, api_waker waker, api_buf *out); +API_MUST_USE api_drive_future *api_drive(api_Moment start, bool (*poll)(void *data, api_Moment, const api_Waiter *, api_option_Moment *, api_buf *), void *poll_data, void (*poll_free)(void *data)); +API_MUST_USE api_poll api_drive_start(api_Moment start, bool (*poll)(void *data, api_Moment, const api_Waiter *, api_option_Moment *, api_buf *), void *poll_data, void (*poll_free)(void *data), api_buf *out, api_drive_future **future); +API_MUST_USE api_poll api_drive_poll(api_drive_future *future, api_waker waker, api_buf *out); void api_drive_future_free(api_drive_future *future); -api_buf api_made(uint32_t n, api_buf (*make)(void *data, uint32_t), void *make_data); -api_vec_tuple_string_Ticket api_tickets(api_vec_tuple_string_Ticket entries); +API_MUST_USE api_buf api_made(uint32_t n, api_buf (*make)(void *data, uint32_t), void *make_data); +API_MUST_USE api_vec_tuple_string_Ticket api_tickets(api_vec_tuple_string_Ticket entries); api_Ticket api_reissue(api_Ticket ticket, api_Ticket (*swap)(void *data, api_Ticket), void *swap_data); api_Ticket api_reissue_lent(api_Ticket ticket, api_Ticket (*swap)(void *data, api_Ticket), void *swap_data); -api_Seat api_seat(const api_Mark *mark, uint32_t row, api_status *status); +API_MUST_USE api_Seat api_seat(const api_Mark *mark, uint32_t row, api_status *status); uint64_t api_admit(api_tuple_Counter_Mark_Seat_Choice entry, api_status *status); uint64_t api_choose(api_Choice choice, api_status *status); uint64_t api_heft(api_tuple_Mark_bytes marked, api_Parcel lent, api_tuple_Counter_bytes moved, api_status *status); -bool api_spend(api_Counter *e, api_Counter *it, uint64_t *out, api_buf *err, api_status *status); +API_MUST_USE bool api_spend(api_Counter *e, api_Counter *it, uint64_t *out, api_buf *err, api_status *status); bool api_is_kept(api_Status_ status); -bool api_attempt(bool (*check)(void *data, api_buf *), void *check_data, api_buf *err); -bool api_tail(api_foreign_reader file, uint64_t len, api_buf *out0, uint64_t *out1, api_buf *err); -bool api_seek_to(api_foreign_reader file, uint64_t at, uint64_t *out, api_buf *err); +API_MUST_USE bool api_attempt(bool (*check)(void *data, api_buf *), void *check_data, api_buf *err); +API_MUST_USE bool api_tail(api_foreign_reader file, uint64_t len, api_buf *out0, uint64_t *out1, api_buf *err); +API_MUST_USE bool api_seek_to(api_foreign_reader file, uint64_t at, uint64_t *out, api_buf *err); typedef struct api_halved_future api_halved_future; -api_halved_future *api_halved(uint32_t n); -api_poll api_halved_start(uint32_t n, api_option_u32 *out, api_halved_future **future); -api_poll api_halved_poll(api_halved_future *future, api_waker waker, api_option_u32 *out); +API_MUST_USE api_halved_future *api_halved(uint32_t n); +API_MUST_USE api_poll api_halved_start(uint32_t n, api_option_u32 *out, api_halved_future **future); +API_MUST_USE api_poll api_halved_poll(api_halved_future *future, api_waker waker, api_option_u32 *out); void api_halved_future_free(api_halved_future *future); typedef struct api_yielded_future api_yielded_future; -api_yielded_future *api_yielded(uint32_t value); -api_poll api_yielded_start(uint32_t value, uint32_t *out, api_yielded_future **future); -api_poll api_yielded_poll(api_yielded_future *future, api_waker waker, uint32_t *out); +API_MUST_USE api_yielded_future *api_yielded(uint32_t value); +API_MUST_USE api_poll api_yielded_start(uint32_t value, uint32_t *out, api_yielded_future **future); +API_MUST_USE api_poll api_yielded_poll(api_yielded_future *future, api_waker waker, uint32_t *out); void api_yielded_future_free(api_yielded_future *future); typedef struct api_after_future api_after_future; -api_after_future *api_after(api_foreign_future first, uint32_t value); -api_poll api_after_start(api_foreign_future first, uint32_t value, uint32_t *out, api_after_future **future); -api_poll api_after_poll(api_after_future *future, api_waker waker, uint32_t *out); +API_MUST_USE api_after_future *api_after(api_foreign_future first, uint32_t value); +API_MUST_USE api_poll api_after_start(api_foreign_future first, uint32_t value, uint32_t *out, api_after_future **future); +API_MUST_USE api_poll api_after_poll(api_after_future *future, api_waker waker, uint32_t *out); void api_after_future_free(api_after_future *future); typedef struct api_within_future api_within_future; -api_within_future *api_within(uint32_t polls, api_foreign_future future_); -api_poll api_within_start(uint32_t polls, api_foreign_future future_, api_Error *err, api_within_future **future); -api_poll api_within_poll(api_within_future *future, api_waker waker, api_Error *err); +API_MUST_USE api_within_future *api_within(uint32_t polls, api_foreign_future future_); +API_MUST_USE api_poll api_within_start(uint32_t polls, api_foreign_future future_, api_Error *err, api_within_future **future); +API_MUST_USE api_poll api_within_poll(api_within_future *future, api_waker waker, api_Error *err); void api_within_future_free(api_within_future *future); -bool api_moment_at(uint64_t ticks, uint64_t rate, api_Moment *out, api_buf *err); -bool api_stamp_at(uint64_t millis, api_Stamp *out, api_buf *err); +API_MUST_USE bool api_moment_at(uint64_t ticks, uint64_t rate, api_Moment *out, api_buf *err); +API_MUST_USE bool api_stamp_at(uint64_t millis, api_Stamp *out, api_buf *err); api_Moment api_shifted(api_Moment moment, api_Moment (*shift)(void *data, api_Moment), void *shift_data); uint32_t api_jvm_sum(api_JvmField field, api_JvmStatic method, api_OptIn opt); api_Clocked api_clocked_after(api_Clocked clocked, uint64_t ticks); uint32_t api_emit(api_Log log, api_buf lines); typedef struct api_counted_future api_counted_future; -api_counted_future *api_counted(uint32_t n, void (*count)(void *data, uint32_t), void *count_data); -api_poll api_counted_start(uint32_t n, void (*count)(void *data, uint32_t), void *count_data, uint32_t *out, api_Error *err, api_counted_future **future); -api_poll api_counted_poll(api_counted_future *future, api_waker waker, uint32_t *out, api_Error *err); +API_MUST_USE api_counted_future *api_counted(uint32_t n, void (*count)(void *data, uint32_t), void *count_data); +API_MUST_USE api_poll api_counted_start(uint32_t n, void (*count)(void *data, uint32_t), void *count_data, uint32_t *out, api_Error *err, api_counted_future **future); +API_MUST_USE api_poll api_counted_poll(api_counted_future *future, api_waker waker, uint32_t *out, api_Error *err); void api_counted_future_free(api_counted_future *future); uint32_t api_filter(api_buf lines, bool (*keep)(void *data, uint8_t, api_buf), void *keep_data); typedef struct api_log_later_future api_log_later_future; -api_log_later_future *api_log_later(api_Log log); -api_poll api_log_later_start(api_Log log, bool *out, api_log_later_future **future); -api_poll api_log_later_poll(api_log_later_future *future, api_waker waker, bool *out); +API_MUST_USE api_log_later_future *api_log_later(api_Log log); +API_MUST_USE api_poll api_log_later_start(api_Log log, bool *out, api_log_later_future **future); +API_MUST_USE api_poll api_log_later_poll(api_log_later_future *future, api_waker waker, bool *out); void api_log_later_future_free(api_log_later_future *future); uint32_t api_log_counts(api_Log log, uint8_t level, const api_Counter *counter, api_vec_Counter more, api_status *status); bool api_on_first_thread(void); uint32_t api_locals_dropped(void); -api_Local *api_local_or_new(const api_Local *local, api_status *status); -api_Local *api_local_or_new_homed(const api_Local *local, api_status *status); +API_MUST_USE api_Local *api_local_or_new(const api_Local *local, api_status *status); +API_MUST_USE api_Local *api_local_or_new_homed(const api_Local *local, api_status *status); typedef struct api_local_or_new_later_future api_local_or_new_later_future; -api_local_or_new_later_future *api_local_or_new_later(const api_Local *local, api_status *status); -api_poll api_local_or_new_later_start(const api_Local *local, api_Local **out, api_local_or_new_later_future **future, api_status *status); -api_poll api_local_or_new_later_poll(api_local_or_new_later_future *future, api_waker waker, api_Local **out, api_status *status); +API_MUST_USE api_local_or_new_later_future *api_local_or_new_later(const api_Local *local, api_status *status); +API_MUST_USE api_poll api_local_or_new_later_start(const api_Local *local, api_Local **out, api_local_or_new_later_future **future, api_status *status); +API_MUST_USE api_poll api_local_or_new_later_poll(api_local_or_new_later_future *future, api_waker waker, api_Local **out, api_status *status); void api_local_or_new_later_future_free(api_local_or_new_later_future *future); -api_local_or_new_later_future *api_local_or_new_later_homed(const api_Local *local, api_status *status); -api_poll api_local_or_new_later_start_homed(const api_Local *local, api_Local **out, api_local_or_new_later_future **future, api_status *status); +API_MUST_USE api_local_or_new_later_future *api_local_or_new_later_homed(const api_Local *local, api_status *status); +API_MUST_USE api_poll api_local_or_new_later_start_homed(const api_Local *local, api_Local **out, api_local_or_new_later_future **future, api_status *status); uint32_t api_bump_either(const api_Local *first, const api_Local *second, api_status *status); typedef struct api_local_after_future api_local_after_future; -api_local_after_future *api_local_after(void); -api_poll api_local_after_start(api_Local **out, api_local_after_future **future); -api_poll api_local_after_poll(api_local_after_future *future, api_waker waker, api_Local **out, api_status *status); +API_MUST_USE api_local_after_future *api_local_after(void); +API_MUST_USE api_poll api_local_after_start(api_Local **out, api_local_after_future **future); +API_MUST_USE api_poll api_local_after_poll(api_local_after_future *future, api_waker waker, api_Local **out, api_status *status); void api_local_after_future_free(api_local_after_future *future); -api_local_after_future *api_local_after_homed(void); -api_poll api_local_after_start_homed(api_Local **out, api_local_after_future **future); +API_MUST_USE api_local_after_future *api_local_after_homed(void); +API_MUST_USE api_poll api_local_after_start_homed(api_Local **out, api_local_after_future **future); typedef struct api_local_later_future api_local_later_future; -api_local_later_future *api_local_later(uint32_t n); -api_poll api_local_later_start(uint32_t n, uint32_t *out, api_local_later_future **future); -api_poll api_local_later_poll(api_local_later_future *future, api_waker waker, uint32_t *out, api_status *status); +API_MUST_USE api_local_later_future *api_local_later(uint32_t n); +API_MUST_USE api_poll api_local_later_start(uint32_t n, uint32_t *out, api_local_later_future **future); +API_MUST_USE api_poll api_local_later_poll(api_local_later_future *future, api_waker waker, uint32_t *out, api_status *status); void api_local_later_future_free(api_local_later_future *future); -api_local_later_future *api_local_later_homed(uint32_t n); -api_poll api_local_later_start_homed(uint32_t n, uint32_t *out, api_local_later_future **future); +API_MUST_USE api_local_later_future *api_local_later_homed(uint32_t n); +API_MUST_USE api_poll api_local_later_start_homed(uint32_t n, uint32_t *out, api_local_later_future **future); typedef struct api_poll_tripled_future api_poll_tripled_future; -api_poll_tripled_future *api_poll_tripled(uint32_t n); -api_poll api_poll_tripled_start(uint32_t n, uint32_t *out, api_poll_tripled_future **future); -api_poll api_poll_tripled_poll(api_poll_tripled_future *future, api_waker waker, uint32_t *out, api_status *status); +API_MUST_USE api_poll_tripled_future *api_poll_tripled(uint32_t n); +API_MUST_USE api_poll api_poll_tripled_start(uint32_t n, uint32_t *out, api_poll_tripled_future **future); +API_MUST_USE api_poll api_poll_tripled_poll(api_poll_tripled_future *future, api_waker waker, uint32_t *out, api_status *status); void api_poll_tripled_future_free(api_poll_tripled_future *future); -api_poll_tripled_future *api_poll_tripled_homed(uint32_t n); -api_poll api_poll_tripled_start_homed(uint32_t n, uint32_t *out, api_poll_tripled_future **future); +API_MUST_USE api_poll_tripled_future *api_poll_tripled_homed(uint32_t n); +API_MUST_USE api_poll api_poll_tripled_start_homed(uint32_t n, uint32_t *out, api_poll_tripled_future **future); uint64_t api_watch(const api_Gauge *gauge, uint64_t (*watch)(void *data, const api_Gauge *), void *watch_data, api_status *status); -api_buf api_token_bytes(uint32_t id, uint32_t len); -api_buf api_token_slice(uint32_t id, uint32_t len, uint32_t of); -api_Packet api_next_packet(api_Packet packet); -bool api_fingerprint(api_buf hex, api_array_u8_4 *out, api_buf *err); +API_MUST_USE api_buf api_token_bytes(uint32_t id, uint32_t len); +API_MUST_USE api_buf api_token_slice(uint32_t id, uint32_t len, uint32_t of); +API_MUST_USE api_Packet api_next_packet(api_Packet packet); +API_MUST_USE bool api_fingerprint(api_buf hex, api_array_u8_4 *out, api_buf *err); uint32_t api_dropped(void); uint32_t api_bump_both(const api_Tally *a, const api_Tally *b, api_status *status); uint32_t api_offset(uint32_t (*by)(void *data), void *by_data_, uint32_t by_data); @@ -2182,16 +2192,16 @@ uint64_t api_walk(uint64_t steps, uint64_t (*visit)(void *data, const api_Cursor uint32_t api_each(uint32_t steps, void (*visit)(void *data, uint32_t), void *visit_data); uint32_t api_peek(const api_Tally *tally, uint32_t (*peek)(void *data, const api_Tally *), void *peek_data, api_status *status); size_t api_len(api_buf payload); -api_buf api_hex(api_buf payload); -api_buf api_timed_hex(api_buf payload); -api_buf api_sample_hex(api_buf sample); -api_buf api_queued_hex(api_buf queued); -api_buf api_tick_name(api_Label tick); -api_buf api_rooted_name(api_Label rooted); -api_buf api_stored_text(api_buf stored); -api_buf api_layer_name(api_Label layer); -api_buf api_greet(api_buf name, api_Shape shape); -api_buf api_describe(api_Event event); +API_MUST_USE api_buf api_hex(api_buf payload); +API_MUST_USE api_buf api_timed_hex(api_buf payload); +API_MUST_USE api_buf api_sample_hex(api_buf sample); +API_MUST_USE api_buf api_queued_hex(api_buf queued); +API_MUST_USE api_buf api_tick_name(api_Label tick); +API_MUST_USE api_buf api_rooted_name(api_Label rooted); +API_MUST_USE api_buf api_stored_text(api_buf stored); +API_MUST_USE api_buf api_layer_name(api_Label layer); +API_MUST_USE api_buf api_greet(api_buf name, api_Shape shape); +API_MUST_USE api_buf api_describe(api_Event event); api_Pair_Size_u8 api_tag(api_Size size, uint8_t tag); uint8_t api_cross(api_Left_Right_u8 left, api_Right_Left_u8 right); uint64_t api_kept_Point(api_Point from); @@ -2222,123 +2232,123 @@ uint64_t api_seeds_Counter_Counter(const api_Counter *from, api_status *status); uint64_t api_seeds_Counter_Size(api_Size from); uint64_t api_seeds_Counter_Wrap_u32(api_Wrap_u32 from); uint64_t api_seeds_Counter_polar_Point(api_polar_Point from); -api_Area *api_grow(const api_Area *area, uint32_t by); -api_Slot_u32 *api_wide(uint32_t value); -api_buf api_host(const api_Url *url, api_status *status); -bool api_resolve(api_Url *base, api_buf path, api_Url **out, api_buf *err, api_status *status); -api_vec_u16 api_ports(api_vec_socket_addr addrs); +API_MUST_USE api_Area *api_grow(const api_Area *area, uint32_t by); +API_MUST_USE api_Slot_u32 *api_wide(uint32_t value); +API_MUST_USE api_buf api_host(const api_Url *url, api_status *status); +API_MUST_USE bool api_resolve(api_Url *base, api_buf path, api_Url **out, api_buf *err, api_status *status); +API_MUST_USE api_vec_u16 api_ports(api_vec_socket_addr addrs); api_duration api_doubled_ttl(api_duration ttl); -api_buf api_file(api_buf dir, api_buf name); -api_buf api_stray(void); +API_MUST_USE api_buf api_file(api_buf dir, api_buf name); +API_MUST_USE api_buf api_stray(void); void api_visit_stray(void (*visit)(void *data, api_buf), void *visit_data); api_option_char api_next_char(uint32_t c); api_option_duration api_extended(api_duration duration, api_duration by); -api_vec_option_path api_parents(api_vec_path paths); -api_vec_string api_words(api_buf text); -api_buf api_sentence(api_vec_string words); +API_MUST_USE api_vec_option_path api_parents(api_vec_path paths); +API_MUST_USE api_vec_string api_words(api_buf text); +API_MUST_USE api_buf api_sentence(api_vec_string words); void api_put_number(uint32_t value, api_buf buf, api_buf *buf_out); api_duration api_second_later(api_duration w235); -bool api_digit(api_buf r, api_buf *r_out, uint8_t *out, api_Error *err); +API_MUST_USE bool api_digit(api_buf r, api_buf *r_out, uint8_t *out, api_Error *err); uint32_t api_push_counted(api_tuple_bytes_u32 entry, uint8_t byte, api_tuple_bytes_u32 *entry_out); void api_nudge(api_Point point, int32_t by, api_Point *point_out); void api_nudge_by(api_Point point, const api_Refusal *refusal, api_Point *point_out, api_status *status); -api_tls_Config *api_secure(api_buf alpn); -api_buf api_alpn(api_tls_Config *config, api_status *status); -api_buf api_alpn_lent(const api_tls_Config *config, api_status *status); -api_tls_Cert *api_certify(api_buf der); +API_MUST_USE api_tls_Config *api_secure(api_buf alpn); +API_MUST_USE api_buf api_alpn(api_tls_Config *config, api_status *status); +API_MUST_USE api_buf api_alpn_lent(const api_tls_Config *config, api_status *status); +API_MUST_USE api_tls_Cert *api_certify(api_buf der); typedef struct api_byte_len_future api_byte_len_future; -api_byte_len_future *api_byte_len(api_buf bytes); -api_poll api_byte_len_start(api_buf bytes, size_t *out, api_byte_len_future **future); -api_poll api_byte_len_poll(api_byte_len_future *future, api_waker waker, size_t *out); +API_MUST_USE api_byte_len_future *api_byte_len(api_buf bytes); +API_MUST_USE api_poll api_byte_len_start(api_buf bytes, size_t *out, api_byte_len_future **future); +API_MUST_USE api_poll api_byte_len_poll(api_byte_len_future *future, api_waker waker, size_t *out); void api_byte_len_future_free(api_byte_len_future *future); size_t api_cert_len(const api_tls_Cert *cert, api_status *status); -api_buf api_cert_der(api_tls_Cert *cert, api_status *status); +API_MUST_USE api_buf api_cert_der(api_tls_Cert *cert, api_status *status); size_t api_chain_len(api_vec_tls_Cert chain, api_status *status); -bool api_verify(const api_tls_Cert *cert, uint32_t *out, api_buf *err, api_status *status); -bool api_parse_cert(api_buf text, uint32_t *out, api_buf *err); +API_MUST_USE bool api_verify(const api_tls_Cert *cert, uint32_t *out, api_buf *err, api_status *status); +API_MUST_USE bool api_parse_cert(api_buf text, uint32_t *out, api_buf *err); typedef struct api_parse_later_future api_parse_later_future; -api_parse_later_future *api_parse_later(api_buf text); -api_poll api_parse_later_start(api_buf text, uint32_t *out, api_buf *err, api_parse_later_future **future); -api_poll api_parse_later_poll(api_parse_later_future *future, api_waker waker, uint32_t *out, api_buf *err); +API_MUST_USE api_parse_later_future *api_parse_later(api_buf text); +API_MUST_USE api_poll api_parse_later_start(api_buf text, uint32_t *out, api_buf *err, api_parse_later_future **future); +API_MUST_USE api_poll api_parse_later_poll(api_parse_later_future *future, api_waker waker, uint32_t *out, api_buf *err); void api_parse_later_future_free(api_parse_later_future *future); -api_tls_Resolver *api_resolver(api_buf name); -api_buf api_resolved(api_tls_Resolver *resolver, api_status *status); -api_std_io_Error *api_failure(api_buf message); -api_buf api_failure_message(const api_std_io_Error *error, api_status *status); -api_buf api_failure_kind(api_std_io_Error *error, api_status *status); +API_MUST_USE api_tls_Resolver *api_resolver(api_buf name); +API_MUST_USE api_buf api_resolved(api_tls_Resolver *resolver, api_status *status); +API_MUST_USE api_std_io_Error *api_failure(api_buf message); +API_MUST_USE api_buf api_failure_message(const api_std_io_Error *error, api_status *status); +API_MUST_USE api_buf api_failure_kind(api_std_io_Error *error, api_status *status); uint32_t api_sum_all(api_vec_u32 items); uint64_t api_weigh_all_Counter(api_vec_Counter items, api_status *status); size_t api_offered_len(api_vec_bytes alpns); -api_buf api_join_words(api_vec_string words); -bool api_resume(api_buf alpn, uint32_t seconds, api_tls_Session **out, api_buf *err); +API_MUST_USE api_buf api_join_words(api_vec_string words); +API_MUST_USE bool api_resume(api_buf alpn, uint32_t seconds, api_tls_Session **out, api_buf *err); size_t api_either(api_buf text); typedef struct api_either_later_future api_either_later_future; -api_either_later_future *api_either_later(api_buf text); -api_poll api_either_later_start(api_buf text, size_t *out, api_either_later_future **future); -api_poll api_either_later_poll(api_either_later_future *future, api_waker waker, size_t *out); +API_MUST_USE api_either_later_future *api_either_later(api_buf text); +API_MUST_USE api_poll api_either_later_start(api_buf text, size_t *out, api_either_later_future **future); +API_MUST_USE api_poll api_either_later_poll(api_either_later_future *future, api_waker waker, size_t *out); void api_either_later_future_free(api_either_later_future *future); -api_buf api_prefixed(api_buf payload, api_buf prefix); +API_MUST_USE api_buf api_prefixed(api_buf payload, api_buf prefix); int32_t api_sum_lists(api_vec_i32 a, api_vec_i32 b, api_vec_i32 c); int32_t api_coordinates(api_option_Point point); -api_vec_bytes api_chunks(api_buf bytes, size_t size); -api_vec_Counter api_counters(api_vec_string names); +API_MUST_USE api_vec_bytes api_chunks(api_buf bytes, size_t size); +API_MUST_USE api_vec_Counter api_counters(api_vec_string names); uint64_t api_worth(api_vec_Counter some, api_vec_Counter boxed, api_status *status); api_option_u64 api_held_count(api_option_tuple_Counter held, api_status *status); -api_Counter *api_boxed_counter(api_buf name); -api_buf api_boxed_name(api_Counter *boxed, api_status *status); +API_MUST_USE api_Counter *api_boxed_counter(api_buf name); +API_MUST_USE api_buf api_boxed_name(api_Counter *boxed, api_status *status); uint32_t api_less(uint32_t value, uint32_t _value); -api_vec_u32 api_sums(api_vec_vec_u32 rows); -api_vec_vec_u32 api_least(api_vec_vec_u32 sets); +API_MUST_USE api_vec_u32 api_sums(api_vec_vec_u32 rows); +API_MUST_USE api_vec_vec_u32 api_least(api_vec_vec_u32 sets); void api_split_last(api_vec_i32 items, api_vec_i32 *out0, uint32_t *out1); uint64_t api_sum_u32(api_vec_u32 items); -api_vec_i64 api_doubled_i64(api_vec_i64 items); -api_vec_u64 api_visit_chunks(api_buf payload, size_t size, uint64_t (*visit)(void *data, api_buf), void *visit_data); +API_MUST_USE api_vec_i64 api_doubled_i64(api_vec_i64 items); +API_MUST_USE api_vec_u64 api_visit_chunks(api_buf payload, size_t size, uint64_t (*visit)(void *data, api_buf), void *visit_data); uint64_t api_scanned(api_Scan scan, api_buf payload); -api_vec_f64 api_boxed_floats(api_vec_f64 items); +API_MUST_USE api_vec_f64 api_boxed_floats(api_vec_f64 items); api_Point api_summed(api_vec_Point points); api_duration api_breadth(api_Limits_duration limits); -api_Limits_bytes api_byte_limits(api_buf low, api_buf high); -api_buf api_joined(api_vec_bytes parts); -api_buf api_first_of(api_vec_string items); +API_MUST_USE api_Limits_bytes api_byte_limits(api_buf low, api_buf high); +API_MUST_USE api_buf api_joined(api_vec_bytes parts); +API_MUST_USE api_buf api_first_of(api_vec_string items); uint64_t api_read_len(api_buf reader); size_t api_longest(api_vec_string words); -api_buf api_encode(const api_Json *value, api_status *status); -api_Json *api_tagged(api_Json *doc, api_buf tag, api_status *status); -api_vec_tuple_string_Json api_entries(api_vec_tuple_string_Json entries, api_buf tag, api_status *status); -api_vec_tuple_string_Json api_sections(api_vec_tuple_string_Json entries, api_status *status); -api_Instant *api_now(void); -api_Instant *api_later(const api_Instant *at, api_duration by); +API_MUST_USE api_buf api_encode(const api_Json *value, api_status *status); +API_MUST_USE api_Json *api_tagged(api_Json *doc, api_buf tag, api_status *status); +API_MUST_USE api_vec_tuple_string_Json api_entries(api_vec_tuple_string_Json entries, api_buf tag, api_status *status); +API_MUST_USE api_vec_tuple_string_Json api_sections(api_vec_tuple_string_Json entries, api_status *status); +API_MUST_USE api_Instant *api_now(void); +API_MUST_USE api_Instant *api_later(const api_Instant *at, api_duration by); api_duration api_since(const api_Instant *later, const api_Instant *earlier); bool api_has_instant(api_Instant *at); api_option_Level api_louder(api_option_Level filter); -api_buf api_spell(api_option_Level filter); -api_vec_string api_GREETINGS(void); -api_vec_u32 api_PRIMES(void); -api_vec_Counter api_numbered(api_vec_string names); +API_MUST_USE api_buf api_spell(api_option_Level filter); +API_MUST_USE api_vec_string api_GREETINGS(void); +API_MUST_USE api_vec_u32 api_PRIMES(void); +API_MUST_USE api_vec_Counter api_numbered(api_vec_string names); void api_nexts(api_socket_addr_v4 v4, api_socket_addr_v6 v6, api_socket_addr_v4 *out0, api_socket_addr_v6 *out1); void api_next_ips(api_ipv4_addr v4, api_ipv6_addr v6, api_ipv4_addr *out0, api_ipv6_addr *out1); api_ip_addr api_flip(api_ip_addr ip); -api_buf api_reasons(api_vec_tuple_Counter_Refusal pairs, api_option_tuple_Counter_Refusal last, api_status *status); +API_MUST_USE api_buf api_reasons(api_vec_tuple_Counter_Refusal pairs, api_option_tuple_Counter_Refusal last, api_status *status); size_t api_excuse(api_buf note, api_tuple_bytes_Refusal entry, api_status *status); uint32_t api_relay(api_Log log, api_vec_Refusal refusals, api_status *status); -bool api_refuse(api_buf reason, uint32_t *out, api_Refusal **err); -bool api_jam(uint32_t n, uint32_t *out, api_Fault **err); +API_MUST_USE bool api_refuse(api_buf reason, uint32_t *out, api_Refusal **err); +API_MUST_USE bool api_jam(uint32_t n, uint32_t *out, api_Fault **err); api_Platform api_platform(void); uint32_t api_pointer_bits(api_Platform platform); api_Labelled api_same_labelled(api_Labelled labelled); api_Placement api_placement(void); bool api_is_family(api_Family family); uint32_t api_wasm_only(void); -bool api_wasm_take(api_Counter *counter, uint64_t *out, api_Error *err, api_status *status); +API_MUST_USE bool api_wasm_take(api_Counter *counter, uint64_t *out, api_Error *err, api_status *status); void api_wasm_log(api_Log log); uint64_t api_booth_count(api_Booth booth, api_status *status); api_Page api_page(void); uint32_t api_beats(api_Beat beat); int32_t api_same(double a, double b); -bool api_return_values(api_Point point, bool fail, api_Point *point_out, api_buf *out0, api_option_tuple_u8_i16_u32_u64 *out1, api_vec_bytes *out2, api_Error *err); -bool api_return_moved(api_Counter *counter, bool fail, api_Counter **out, api_Error *err, api_status *status); +API_MUST_USE bool api_return_values(api_Point point, bool fail, api_Point *point_out, api_buf *out0, api_option_tuple_u8_i16_u32_u64 *out1, api_vec_bytes *out2, api_Error *err); +API_MUST_USE bool api_return_moved(api_Counter *counter, bool fail, api_Counter **out, api_Error *err, api_status *status); api_NonZeros api_non_zeros(void); -api_buf api_describe_non_zeros(api_NonZeros non_zeros); +API_MUST_USE api_buf api_describe_non_zeros(api_NonZeros non_zeros); api_option_non_zero_u64 api_next_hop(api_option_non_zero_u64 hop); uint16_t api_farther_hop(api_Pair_non_zero_u16 hops); api_duration api_same_duration(api_duration v); @@ -2347,56 +2357,56 @@ size_t api_same_usize(size_t v); ptrdiff_t api_same_isize(ptrdiff_t v); api_u128 api_same_u128(api_u128 v); uint32_t api_same_char(uint32_t v); -api_buf api_same_string(api_buf v); -api_buf api_same_path(api_buf v); +API_MUST_USE api_buf api_same_string(api_buf v); +API_MUST_USE api_buf api_same_path(api_buf v); api_socket_addr api_same_socket_addr(api_socket_addr v); api_socket_addr_v4 api_same_socket_addr_v4(api_socket_addr_v4 v); api_socket_addr_v6 api_same_socket_addr_v6(api_socket_addr_v6 v); api_ip_addr api_same_ip_addr(api_ip_addr v); -api_buf api_unescaped(api_buf text); +API_MUST_USE api_buf api_unescaped(api_buf text); typedef struct api_unescaped_later_future api_unescaped_later_future; -api_unescaped_later_future *api_unescaped_later(api_buf text); -api_poll api_unescaped_later_start(api_buf text, api_buf *out, api_unescaped_later_future **future); -api_poll api_unescaped_later_poll(api_unescaped_later_future *future, api_waker waker, api_buf *out); +API_MUST_USE api_unescaped_later_future *api_unescaped_later(api_buf text); +API_MUST_USE api_poll api_unescaped_later_start(api_buf text, api_buf *out, api_unescaped_later_future **future); +API_MUST_USE api_poll api_unescaped_later_poll(api_unescaped_later_future *future, api_waker waker, api_buf *out); void api_unescaped_later_future_free(api_unescaped_later_future *future); typedef struct api_unescaped_maybe_future api_unescaped_maybe_future; -api_unescaped_maybe_future *api_unescaped_maybe(api_buf text); -api_poll api_unescaped_maybe_start(api_buf text, api_buf *out, api_unescaped_maybe_future **future); -api_poll api_unescaped_maybe_poll(api_unescaped_maybe_future *future, api_waker waker, api_buf *out); +API_MUST_USE api_unescaped_maybe_future *api_unescaped_maybe(api_buf text); +API_MUST_USE api_poll api_unescaped_maybe_start(api_buf text, api_buf *out, api_unescaped_maybe_future **future); +API_MUST_USE api_poll api_unescaped_maybe_poll(api_unescaped_maybe_future *future, api_waker waker, api_buf *out); void api_unescaped_maybe_future_free(api_unescaped_maybe_future *future); -api_buf api_unzeroed(api_buf bytes); +API_MUST_USE api_buf api_unzeroed(api_buf bytes); uint8_t api_deprecated(uint8_t note); api_Knob api_knob(api_Dial dial); typedef struct api_level_later_future api_level_later_future; -api_level_later_future *api_level_later(api_Dial dial); -api_poll api_level_later_start(api_Dial dial, uint64_t *out, api_level_later_future **future); -api_poll api_level_later_poll(api_level_later_future *future, api_waker waker, uint64_t *out); +API_MUST_USE api_level_later_future *api_level_later(api_Dial dial); +API_MUST_USE api_poll api_level_later_start(api_Dial dial, uint64_t *out, api_level_later_future **future); +API_MUST_USE api_poll api_level_later_poll(api_level_later_future *future, api_waker waker, uint64_t *out); void api_level_later_future_free(api_level_later_future *future); -bool api_turned(api_Dial dial, api_Turner turner, api_Dial *out, api_Error *err); +API_MUST_USE bool api_turned(api_Dial dial, api_Turner turner, api_Dial *out, api_Error *err); uint64_t api_crowded(api_Reading reading, api_Stamp a, api_Stamp b, uint64_t n0, uint64_t n1, uint64_t n2, uint64_t n3, uint64_t n4, uint64_t n5, uint64_t n6, uint64_t n7, uint64_t n8, uint64_t n9, uint64_t n10, uint64_t n11, uint64_t n12, uint64_t n13, uint64_t n14, uint64_t n15, uint64_t n16, uint64_t n17, uint64_t n18, uint64_t n19, uint64_t n20, uint64_t n21, uint64_t n22, uint64_t n23, uint64_t n24, uint64_t n25, uint64_t n26, uint64_t n27, uint64_t n28, uint64_t n29, uint64_t n30, uint64_t n31, uint64_t n32, uint64_t n33, uint64_t n34, uint64_t n35, uint64_t n36, uint64_t n37, uint64_t n38, uint64_t n39, uint64_t n40, uint64_t n41, uint64_t n42, uint64_t n43, uint64_t n44, uint64_t n45, uint64_t n46, uint64_t n47, uint64_t n48, uint64_t n49, uint64_t n50, uint64_t n51, uint64_t n52, uint64_t n53, uint64_t n54, uint64_t n55, uint64_t n56, uint64_t n57, uint64_t n58, uint64_t n59, uint64_t n60, uint64_t n61, uint64_t n62, uint64_t n63, uint64_t n64, uint64_t n65, uint64_t n66, uint64_t n67, uint64_t n68, uint64_t n69, uint64_t n70, uint64_t n71, uint64_t n72, uint64_t n73, uint64_t n74, uint64_t n75, uint64_t n76, uint64_t n77, uint64_t n78, uint64_t n79, uint64_t n80, uint64_t n81, uint64_t n82, uint64_t n83, uint64_t n84, uint64_t n85, uint64_t n86, uint64_t n87, uint64_t n88, uint64_t n89, uint64_t n90, uint64_t n91, uint64_t n92, uint64_t n93, uint64_t n94, uint64_t n95, uint64_t n96, uint64_t n97, uint64_t n98, uint64_t n99, uint64_t n100, uint64_t n101, uint64_t n102, uint64_t n103, uint64_t n104, uint64_t n105, uint64_t n106, uint64_t n107, uint64_t n108, uint64_t n109, uint64_t n110, uint64_t n111, uint64_t n112, uint64_t n113, uint64_t n114, uint64_t n115, uint64_t n116, uint64_t n117, uint64_t n118); uint64_t api_crammed(api_Moment a, api_Moment b, uint64_t n0, uint64_t n1, uint64_t n2, uint64_t n3, uint64_t n4, uint64_t n5, uint64_t n6, uint64_t n7, uint64_t n8, uint64_t n9, uint64_t n10, uint64_t n11, uint64_t n12, uint64_t n13, uint64_t n14, uint64_t n15, uint64_t n16, uint64_t n17, uint64_t n18, uint64_t n19, uint64_t n20, uint64_t n21, uint64_t n22, uint64_t n23, uint64_t n24, uint64_t n25, uint64_t n26, uint64_t n27, uint64_t n28, uint64_t n29, uint64_t n30, uint64_t n31, uint64_t n32, uint64_t n33, uint64_t n34, uint64_t n35, uint64_t n36, uint64_t n37, uint64_t n38, uint64_t n39, uint64_t n40, uint64_t n41, uint64_t n42, uint64_t n43, uint64_t n44, uint64_t n45, uint64_t n46, uint64_t n47, uint64_t n48, uint64_t n49, uint64_t n50, uint64_t n51, uint64_t n52, uint64_t n53, uint64_t n54, uint64_t n55, uint64_t n56, uint64_t n57, uint64_t n58, uint64_t n59, uint64_t n60, uint64_t n61, uint64_t n62, uint64_t n63, uint64_t n64, uint64_t n65, uint64_t n66, uint64_t n67, uint64_t n68, uint64_t n69, uint64_t n70, uint64_t n71, uint64_t n72, uint64_t n73, uint64_t n74, uint64_t n75, uint64_t n76, uint64_t n77, uint64_t n78, uint64_t n79, uint64_t n80, uint64_t n81, uint64_t n82, uint64_t n83, uint64_t n84, uint64_t n85, uint64_t n86, uint64_t n87, uint64_t n88, uint64_t n89, uint64_t n90, uint64_t n91, uint64_t n92, uint64_t n93, uint64_t n94, uint64_t n95, uint64_t n96, uint64_t n97, uint64_t n98, uint64_t n99, uint64_t n100, uint64_t n101, uint64_t n102, uint64_t n103, uint64_t n104, uint64_t n105, uint64_t n106, uint64_t n107, uint64_t n108, uint64_t n109, uint64_t n110, uint64_t n111, uint64_t n112, uint64_t n113, uint64_t n114, uint64_t n115, uint64_t n116, uint64_t n117, uint64_t n118, uint64_t n119, uint64_t n120, uint64_t n121, uint64_t n122, uint64_t n123); uint32_t api_jni_one(void); api_option_polar_Point api_polar_point(uint32_t distance); -api_clash_Any api_clash_any(api_buf type_url); +API_MUST_USE api_clash_Any api_clash_any(api_buf type_url); api_clash_Candidate api_clash_candidate(uint8_t at); uint8_t api_clash_ignore(uint8_t arg0, uint8_t arg1, uint8_t arg2); -api_clash_Empty_string *api_clash_empty(void); -bool api_clash_audible(api_clash_Tone tone, api_clash_Tone *out, api_vec_clash_Tone *err); +API_MUST_USE api_clash_Empty_string *api_clash_empty(void); +API_MUST_USE bool api_clash_audible(api_clash_Tone tone, api_clash_Tone *out, api_vec_clash_Tone *err); uint32_t api_clash_nested(api_option_tuple_tuple_u8_u16_u32 a, api_option_tuple_tuple_u8_u16_u32_ b); uint8_t api_clash_audio_encoder_finish(void); uint8_t api_clash_audio_encoder_finish_(void); uint32_t api_emit_from_thread(api_Log log, api_buf lines); typedef struct api_emit_later_future api_emit_later_future; -api_emit_later_future *api_emit_later(api_Log log, api_buf lines); -api_poll api_emit_later_start(api_Log log, api_buf lines, uint32_t *out, api_emit_later_future **future); -api_poll api_emit_later_poll(api_emit_later_future *future, api_waker waker, uint32_t *out); +API_MUST_USE api_emit_later_future *api_emit_later(api_Log log, api_buf lines); +API_MUST_USE api_poll api_emit_later_start(api_Log log, api_buf lines, uint32_t *out, api_emit_later_future **future); +API_MUST_USE api_poll api_emit_later_poll(api_emit_later_future *future, api_waker waker, uint32_t *out); void api_emit_later_future_free(api_emit_later_future *future); typedef struct api_log_on_drop_future api_log_on_drop_future; -api_log_on_drop_future *api_log_on_drop(api_Log log); -api_poll api_log_on_drop_start(api_Log log, api_log_on_drop_future **future); -api_poll api_log_on_drop_poll(api_log_on_drop_future *future, api_waker waker); +API_MUST_USE api_log_on_drop_future *api_log_on_drop(api_Log log); +API_MUST_USE api_poll api_log_on_drop_start(api_Log log, api_log_on_drop_future **future); +API_MUST_USE api_poll api_log_on_drop_poll(api_log_on_drop_future *future, api_waker waker); void api_log_on_drop_future_free(api_log_on_drop_future *future); -api_waker api_log_waker(api_Log log); +API_MUST_USE api_waker api_log_waker(api_Log log); void api_hook(void (*f)(void *data), void *f_data, void (*f_free)(void *data)); void api_unhook(void); #ifdef __cplusplus diff --git a/ffi/surface/api/cpp.hpp b/ffi/surface/api/cpp.hpp index 9d7c0140b..3bee3eadf 100644 --- a/ffi/surface/api/cpp.hpp +++ b/ffi/surface/api/cpp.hpp @@ -407,7 +407,7 @@ namespace api { RUST2_FFI_CALLABLE void notify(const ::api::waker &waker_) const; RUST2_FFI_CALLABLE ::api::Channel_send_later_future send_later(::api::input payload) const; RUST2_FFI_CALLABLE ::api::Channel_tagged_future tagged(::api::input tag) const; - RUST2_FFI_CALLABLE ::api::Channel_itemized_future itemized(const ::std::optional<::std::vector<::std::uint32_t>> &items_) const; + RUST2_FFI_CALLABLE ::api::Channel_itemized_future itemized(::std::optional<::api::slice<::std::uint32_t>> items_) const; RUST2_FFI_CALLABLE ::api::Channel_poll_take_future poll_take() const; RUST2_FFI_CALLABLE ::api::Channel_poll_measure_future poll_measure(::std::size_t extra); RUST2_FFI_CALLABLE void listen(const ::api::waker &cx) const; @@ -1365,7 +1365,7 @@ namespace api { inline ::api::Clash Clash_of(double value); inline ::api::buf Clash_bytes(const ::api::Clash &self); inline ::api::Reading Clash_reading(const ::api::Clash &self, ::std::uint32_t kotlin); - inline ::std::vector<::std::vector<::std::uint32_t>> Clash_listed(const ::std::vector<::std::uint32_t> &java, ::std::uint32_t &kotlin); + inline ::std::vector<::std::vector<::std::uint32_t>> Clash_listed(::api::slice<::std::uint32_t> java, ::std::uint32_t &kotlin); template inline ::api::Clash_after_future Clash_after(F0 first, double kotlin); inline ::api::buf Clash_joined(const ::api::Clash &self, ::api::input lent, ::api::input owned, ::std::optional<::api::input> maybe); inline ::api::Clash_tagged_future Clash_tagged(const ::api::Clash &self, ::api::input tag); @@ -1581,7 +1581,7 @@ namespace api { inline ::std::size_t either(::std::optional<::api::input> text); inline ::api::either_later_future either_later(::std::optional<::api::input> text); inline ::api::buf prefixed(::api::input payload, ::std::optional<::api::input> prefix); - inline ::std::int32_t sum_lists(const ::std::vector<::std::int32_t> &a__, const ::std::optional<::std::vector<::std::int32_t>> &b_, const ::std::optional<::std::vector<::std::int32_t>> &c_); + inline ::std::int32_t sum_lists(::api::slice<::std::int32_t> a__, ::std::optional<::api::slice<::std::int32_t>> b_, ::std::optional<::api::slice<::std::int32_t>> c_); inline ::std::int32_t coordinates(const ::std::optional<::api::Point> &point); inline ::std::vector<::api::buf> chunks(::api::input bytes, ::std::size_t size); inline ::std::vector<::api::Counter> counters(const ::api::items<::api::view> &names); @@ -1592,12 +1592,12 @@ namespace api { inline ::std::uint32_t less(::std::uint32_t value, ::std::uint32_t _value); inline ::std::vector<::std::uint32_t> sums(const ::std::vector<::std::vector<::std::uint32_t>> &rows); inline ::std::vector<::std::vector<::std::uint32_t>> least(const ::std::vector<::std::vector<::std::uint32_t>> &sets); - inline ::std::tuple<::std::vector<::std::int32_t>, ::std::uint32_t> split_last(const ::std::vector<::std::int32_t> &items_); - inline ::std::uint64_t sum_u32(const ::std::vector<::std::uint32_t> &items_); - inline ::std::vector<::std::int64_t> doubled_i64(const ::std::vector<::std::int64_t> &items_); + inline ::std::tuple<::std::vector<::std::int32_t>, ::std::uint32_t> split_last(::api::slice<::std::int32_t> items_); + inline ::std::uint64_t sum_u32(::api::slice<::std::uint32_t> items_); + inline ::std::vector<::std::int64_t> doubled_i64(::api::slice<::std::int64_t> items_); template inline ::std::vector<::std::uint64_t> visit_chunks(::api::input payload, ::std::size_t size, F0 &&visit); inline ::std::uint64_t scanned(::std::unique_ptr<::api::Scan> scan, ::api::input payload); - inline ::std::vector boxed_floats(const ::std::vector &items_); + inline ::std::vector boxed_floats(::api::slice items_); inline ::api::Point summed(const ::std::vector<::api::Point> &points); inline ::api::duration breadth(const ::api::Limits_duration &limits); inline ::api::Limits_bytes byte_limits(::api::input low, ::api::input high); @@ -1815,6 +1815,8 @@ namespace api { #endif namespace api { #if defined(__clang__) + #define RUST2_FFI_OWNER(T) [[gsl::Owner(T)]] + #define RUST2_FFI_POINTER(T) [[gsl::Pointer(T)]] #define RUST2_FFI_LIFETIMEBOUND [[clang::lifetimebound]] #define RUST2_FFI_CONSUMABLE [[clang::consumable(unconsumed)]] #define RUST2_FFI_CALLABLE [[clang::callable_when("unconsumed", "unknown")]] @@ -1822,6 +1824,8 @@ namespace api { #define RUST2_FFI_UNCONSUMED [[clang::return_typestate(unconsumed)]] #define RUST2_FFI_MOVED_FROM [[clang::return_typestate(consumed)]] #else + #define RUST2_FFI_OWNER(T) + #define RUST2_FFI_POINTER(T) #define RUST2_FFI_LIFETIMEBOUND #define RUST2_FFI_CONSUMABLE #define RUST2_FFI_CALLABLE @@ -1837,7 +1841,7 @@ namespace api { borrow &operator=(const borrow &) = delete; T *operator->() const noexcept; }; - class view { + class RUST2_FFI_POINTER(::std::uint8_t) view { view() noexcept : data_(detail::bytes(nullptr, 0)), size_(0); view(const void *data, ::std::size_t size) noexcept : data_(detail::bytes(data, size)), size_(size); view(const char *text) noexcept : view(text, ::std::strlen(text)); @@ -1849,7 +1853,26 @@ namespace api { const ::std::uint8_t *end() const noexcept; ::std::string_view str() const noexcept; }; - class buf { + #if defined(__GNUC__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Winit-list-lifetime" + #endif + template class RUST2_FFI_POINTER(T) slice { + slice() noexcept : data_(nullptr), size_(0); + slice(const T *data, ::std::size_t size) noexcept : data_(data), size_(size); + template <::std::size_t N> slice(const T (&array RUST2_FFI_LIFETIMEBOUND)[N]) noexcept : data_(array), size_(N); + slice(::std::initializer_list list RUST2_FFI_LIFETIMEBOUND) noexcept : data_(list.begin()), size_(list.size()); + template ().data())>>, T>>, class = decltype(::std::declval().size())> slice(const R &range RUST2_FFI_LIFETIMEBOUND) noexcept : data_(range.data()), size_(range.size()); + const T *data() const noexcept; + ::std::size_t size() const noexcept; + bool empty() const noexcept; + const T *begin() const noexcept; + const T *end() const noexcept; + }; + #if defined(__GNUC__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + class [[nodiscard]] RUST2_FFI_OWNER(::std::uint8_t) buf { buf() noexcept; explicit buf(view bytes) : buf(); buf(const buf &other) : buf(); @@ -1874,7 +1897,7 @@ namespace api { input &operator=(input &&) = delete; ~input(); }; - template class items { + template class RUST2_FFI_POINTER(T) items { items(const ::std::vector &vector RUST2_FFI_LIFETIMEBOUND) noexcept : data_(vector.data()), size_(vector.size()); items(::std::initializer_list list) : converted_(list), data_(converted_.data()), size_(converted_.size()); template , ::std::vector> && !::std::is_same_v<::std::decay_t, items> && detail::lasting && ::std::is_convertible_v())), T>>> items(const R &range RUST2_FFI_LIFETIMEBOUND); @@ -1896,7 +1919,7 @@ namespace api { ::std::size_t size() const noexcept; bool empty() const noexcept; }; - template class result { + template class [[nodiscard]] result { static result ok(T value); static result err(E error); bool has_value() const noexcept; @@ -1913,7 +1936,7 @@ namespace api { const E &error() const &; E &&error() &&; }; - template class result { + template class [[nodiscard]] result { static result ok(); static result err(E error); bool has_value() const noexcept; @@ -1932,13 +1955,13 @@ namespace api { }; template using poll_t = ::std::conditional_t<::std::is_void_v, bool, ::std::optional>; class task; - class task { + class [[nodiscard]] task { task() noexcept = default; task(task &&other) noexcept : node_(::std::exchange(other.node_, nullptr)); task &operator=(task &&other) noexcept; ~task(); }; - template class future { + template class [[nodiscard]] future { using output = typename Op::output; future(future &&other) noexcept : raw_(::std::exchange(other.raw_, nullptr)), last_(::std::exchange(other.last_, nullptr)); future &operator=(future &&other) noexcept; diff --git a/ffi/surface/moq/c.h b/ffi/surface/moq/c.h index 637508de6..150b7e064 100644 --- a/ffi/surface/moq/c.h +++ b/ffi/surface/moq/c.h @@ -4,10 +4,20 @@ #include #include #include +#ifndef MOQ_MUST_USE +#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || \ + (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) +#define MOQ_MUST_USE [[nodiscard]] +#elif defined(__GNUC__) +#define MOQ_MUST_USE __attribute__((warn_unused_result)) +#else +#define MOQ_MUST_USE +#endif +#endif #ifdef __cplusplus extern "C" { #endif -#define MOQ_CONTRACT ((uint64_t)0x0ac854b23d858bf7ULL) +#define MOQ_CONTRACT ((uint64_t)0x797d794629bfbf19ULL) uint64_t moq_contract(void); uint32_t moq_target(void); typedef int32_t moq_status; @@ -27,8 +37,8 @@ typedef struct moq_buf { void *owner; } moq_buf; void moq_buf_free(moq_buf buf); -moq_buf moq_buf_copy(moq_buf view); -moq_buf moq_buf_clone(moq_buf buf); +MOQ_MUST_USE moq_buf moq_buf_copy(moq_buf view); +MOQ_MUST_USE moq_buf moq_buf_clone(moq_buf buf); typedef struct moq_u128 { uint64_t lo; uint64_t hi; @@ -2336,43 +2346,43 @@ typedef struct moq_transport_Metrics { #define MOQ_TRANSPORT_SETUP_RECEIVE_WINDOW ((uint64_t)131102ULL) #define MOQ_HANG_CATALOG_MAX_SAFE_INTEGER ((uint64_t)9007199254740991ULL) bool moq_TimeOverflow_eq(const moq_TimeOverflow *a, const moq_TimeOverflow *b); -moq_buf moq_TimeOverflow_to_string(const moq_TimeOverflow *self); -moq_buf moq_TimeOverflow_debug(const moq_TimeOverflow *self); +MOQ_MUST_USE moq_buf moq_TimeOverflow_to_string(const moq_TimeOverflow *self); +MOQ_MUST_USE moq_buf moq_TimeOverflow_debug(const moq_TimeOverflow *self); bool moq_Timescale_eq(const moq_Timescale *a, const moq_Timescale *b); uint64_t moq_Timescale_hash(const moq_Timescale *self); -moq_buf moq_Timescale_to_string(const moq_Timescale *self); -moq_buf moq_Timescale_debug(const moq_Timescale *self); +MOQ_MUST_USE moq_buf moq_Timescale_to_string(const moq_Timescale *self); +MOQ_MUST_USE moq_buf moq_Timescale_debug(const moq_Timescale *self); moq_Timescale moq_Timescale_SECOND(void); moq_Timescale moq_Timescale_MILLI(void); moq_Timescale moq_Timescale_MICRO(void); moq_Timescale moq_Timescale_NANO(void); -bool moq_Timescale_new(uint64_t units_per_second, moq_Timescale *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timescale_new(uint64_t units_per_second, moq_Timescale *out, moq_TimeOverflow *err); uint64_t moq_Timescale_as_u64(const moq_Timescale *self); bool moq_Timestamp_eq(const moq_Timestamp *a, const moq_Timestamp *b); uint64_t moq_Timestamp_hash(const moq_Timestamp *self); -moq_buf moq_Timestamp_debug(const moq_Timestamp *self); +MOQ_MUST_USE moq_buf moq_Timestamp_debug(const moq_Timestamp *self); moq_Timestamp moq_Timestamp_ZERO(void); -bool moq_Timestamp_new(uint64_t value, moq_Timescale scale, moq_Timestamp *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_new(uint64_t value, moq_Timescale scale, moq_Timestamp *out, moq_TimeOverflow *err); moq_Timestamp moq_Timestamp_unscaled(uint64_t key); -bool moq_Timestamp_from_scale(uint64_t value, uint64_t units_per_second, moq_Timestamp *out, moq_TimeOverflow *err); -bool moq_Timestamp_from_secs(uint64_t seconds, moq_Timestamp *out, moq_TimeOverflow *err); -bool moq_Timestamp_from_millis(uint64_t millis, moq_Timestamp *out, moq_TimeOverflow *err); -bool moq_Timestamp_from_micros(uint64_t micros, moq_Timestamp *out, moq_TimeOverflow *err); -bool moq_Timestamp_from_nanos(uint64_t nanos, moq_Timestamp *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_from_scale(uint64_t value, uint64_t units_per_second, moq_Timestamp *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_from_secs(uint64_t seconds, moq_Timestamp *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_from_millis(uint64_t millis, moq_Timestamp *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_from_micros(uint64_t micros, moq_Timestamp *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_from_nanos(uint64_t nanos, moq_Timestamp *out, moq_TimeOverflow *err); uint64_t moq_Timestamp_value(const moq_Timestamp *self); moq_option_Timescale moq_Timestamp_scale(const moq_Timestamp *self); bool moq_Timestamp_is_zero(const moq_Timestamp *self); -bool moq_Timestamp_convert(const moq_Timestamp *self, moq_Timescale new_scale, moq_Timestamp *out, moq_TimeOverflow *err); -bool moq_Timestamp_as_scale(const moq_Timestamp *self, moq_Timescale target, moq_u128 *out, moq_TimeOverflow *err); -bool moq_Timestamp_as_secs(const moq_Timestamp *self, uint64_t *out, moq_TimeOverflow *err); -bool moq_Timestamp_as_millis(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err); -bool moq_Timestamp_as_micros(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err); -bool moq_Timestamp_as_nanos(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err); -bool moq_Timestamp_checked_add(const moq_Timestamp *self, moq_Timestamp rhs, moq_Timestamp *out, moq_TimeOverflow *err); -bool moq_Timestamp_checked_sub(const moq_Timestamp *self, moq_Timestamp rhs, moq_Timestamp *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_convert(const moq_Timestamp *self, moq_Timescale new_scale, moq_Timestamp *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_as_scale(const moq_Timestamp *self, moq_Timescale target, moq_u128 *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_as_secs(const moq_Timestamp *self, uint64_t *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_as_millis(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_as_micros(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_as_nanos(const moq_Timestamp *self, moq_u128 *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_checked_add(const moq_Timestamp *self, moq_Timestamp rhs, moq_Timestamp *out, moq_TimeOverflow *err); +MOQ_MUST_USE bool moq_Timestamp_checked_sub(const moq_Timestamp *self, moq_Timestamp rhs, moq_Timestamp *out, moq_TimeOverflow *err); bool moq_clock_Instant_eq(const moq_clock_Instant *a, const moq_clock_Instant *b); uint64_t moq_clock_Instant_hash(const moq_clock_Instant *self); -moq_buf moq_clock_Instant_debug(const moq_clock_Instant *self); +MOQ_MUST_USE moq_buf moq_clock_Instant_debug(const moq_clock_Instant *self); moq_clock_Instant moq_clock_Instant_ZERO(void); moq_clock_Instant moq_clock_Instant_now(void); moq_duration moq_clock_Instant_elapsed(const moq_clock_Instant *self); @@ -2383,14 +2393,14 @@ moq_option_clock_Instant moq_clock_Instant_checked_add(const moq_clock_Instant * moq_option_clock_Instant moq_clock_Instant_checked_sub(const moq_clock_Instant *self, moq_duration duration); moq_clock_Instant moq_clock_Instant_saturating_add(const moq_clock_Instant *self, moq_duration duration); moq_clock_Instant moq_clock_Instant_saturating_sub(const moq_clock_Instant *self, moq_duration duration); -moq_Instant *moq_clock_Instant_into_std(const moq_clock_Instant *self); +MOQ_MUST_USE moq_Instant *moq_clock_Instant_into_std(const moq_clock_Instant *self); moq_clock_Instant moq_clock_Instant_from_std(const moq_Instant *at); bool moq_clock_Elapsed_eq(const moq_clock_Elapsed *a, const moq_clock_Elapsed *b); -moq_buf moq_clock_Elapsed_to_string(const moq_clock_Elapsed *self); -moq_buf moq_clock_Elapsed_debug(const moq_clock_Elapsed *self); +MOQ_MUST_USE moq_buf moq_clock_Elapsed_to_string(const moq_clock_Elapsed *self); +MOQ_MUST_USE moq_buf moq_clock_Elapsed_debug(const moq_clock_Elapsed *self); bool moq_clock_Wall_eq(const moq_clock_Wall *a, const moq_clock_Wall *b); uint64_t moq_clock_Wall_hash(const moq_clock_Wall *self); -moq_buf moq_clock_Wall_debug(const moq_clock_Wall *self); +MOQ_MUST_USE moq_buf moq_clock_Wall_debug(const moq_clock_Wall *self); moq_clock_Wall moq_clock_Wall_UNIX_EPOCH(void); moq_clock_Wall moq_clock_Wall_MOQ_EPOCH(void); moq_clock_Wall moq_clock_Wall_now(void); @@ -2401,14 +2411,14 @@ moq_clock_Wall moq_clock_Wall_saturating_add(const moq_clock_Wall *self, moq_dur moq_option_clock_Wall moq_clock_Wall_checked_sub(const moq_clock_Wall *self, moq_duration duration); void moq_setup_Token_free(moq_setup_Token *self); bool moq_setup_Token_eq(const moq_setup_Token *a, const moq_setup_Token *b); -moq_buf moq_setup_Token_debug(const moq_setup_Token *self); +MOQ_MUST_USE moq_buf moq_setup_Token_debug(const moq_setup_Token *self); bool moq_session_Limits_eq(const moq_session_Limits *a, const moq_session_Limits *b); -moq_buf moq_session_Limits_debug(const moq_session_Limits *self); +MOQ_MUST_USE moq_buf moq_session_Limits_debug(const moq_session_Limits *self); moq_session_Limits moq_session_Limits_default(void); size_t moq_session_Limits_announces_get(const moq_session_Limits *self); void moq_session_Limits_announces_set(moq_session_Limits *self, size_t value); bool moq_stats_Content_eq(const moq_stats_Content *a, const moq_stats_Content *b); -moq_buf moq_stats_Content_debug(const moq_stats_Content *self); +MOQ_MUST_USE moq_buf moq_stats_Content_debug(const moq_stats_Content *self); moq_stats_Content moq_stats_Content_default(void); uint64_t moq_stats_Content_bytes_get(const moq_stats_Content *self); void moq_stats_Content_bytes_set(moq_stats_Content *self, uint64_t value); @@ -2417,7 +2427,7 @@ void moq_stats_Content_frames_set(moq_stats_Content *self, uint64_t value); uint64_t moq_stats_Content_groups_get(const moq_stats_Content *self); void moq_stats_Content_groups_set(moq_stats_Content *self, uint64_t value); bool moq_stats_Traffic_eq(const moq_stats_Traffic *a, const moq_stats_Traffic *b); -moq_buf moq_stats_Traffic_debug(const moq_stats_Traffic *self); +MOQ_MUST_USE moq_buf moq_stats_Traffic_debug(const moq_stats_Traffic *self); moq_stats_Traffic moq_stats_Traffic_default(void); uint64_t moq_stats_Traffic_announces_started_get(const moq_stats_Traffic *self); void moq_stats_Traffic_announces_started_set(moq_stats_Traffic *self, uint64_t value); @@ -2452,7 +2462,7 @@ uint64_t moq_stats_Traffic_active_broadcasts(const moq_stats_Traffic *self); uint64_t moq_stats_Traffic_active_subscriptions(const moq_stats_Traffic *self); bool moq_stats_Traffic_is_idle(const moq_stats_Traffic *self); bool moq_stats_Presence_eq(const moq_stats_Presence *a, const moq_stats_Presence *b); -moq_buf moq_stats_Presence_debug(const moq_stats_Presence *self); +MOQ_MUST_USE moq_buf moq_stats_Presence_debug(const moq_stats_Presence *self); moq_stats_Presence moq_stats_Presence_default(void); moq_stats_Refusals moq_stats_Presence_sessions_refused_get(const moq_stats_Presence *self); void moq_stats_Presence_sessions_refused_set(moq_stats_Presence *self, moq_stats_Refusals value); @@ -2483,14 +2493,14 @@ void moq_stats_Presence_routes_set(moq_stats_Presence *self, moq_stats_Routes va void moq_stats_Presence_add(moq_stats_Presence *self, moq_stats_Presence other); uint64_t moq_stats_Presence_active(const moq_stats_Presence *self); bool moq_stats_Activity_eq(const moq_stats_Activity *a, const moq_stats_Activity *b); -moq_buf moq_stats_Activity_debug(const moq_stats_Activity *self); +MOQ_MUST_USE moq_buf moq_stats_Activity_debug(const moq_stats_Activity *self); moq_stats_Activity moq_stats_Activity_default(void); uint64_t moq_stats_Activity_idle_get(const moq_stats_Activity *self); void moq_stats_Activity_idle_set(moq_stats_Activity *self, uint64_t value); uint64_t moq_stats_Activity_active_get(const moq_stats_Activity *self); void moq_stats_Activity_active_set(moq_stats_Activity *self, uint64_t value); bool moq_stats_Totals_eq(const moq_stats_Totals *a, const moq_stats_Totals *b); -moq_buf moq_stats_Totals_debug(const moq_stats_Totals *self); +MOQ_MUST_USE moq_buf moq_stats_Totals_debug(const moq_stats_Totals *self); moq_stats_Totals moq_stats_Totals_default(void); uint64_t moq_stats_Totals_tx_get(const moq_stats_Totals *self); void moq_stats_Totals_tx_set(moq_stats_Totals *self, uint64_t value); @@ -2501,7 +2511,7 @@ void moq_stats_Totals_tx_messages_set(moq_stats_Totals *self, uint64_t value); uint64_t moq_stats_Totals_rx_messages_get(const moq_stats_Totals *self); void moq_stats_Totals_rx_messages_set(moq_stats_Totals *self, uint64_t value); bool moq_stats_Failures_eq(const moq_stats_Failures *a, const moq_stats_Failures *b); -moq_buf moq_stats_Failures_debug(const moq_stats_Failures *self); +MOQ_MUST_USE moq_buf moq_stats_Failures_debug(const moq_stats_Failures *self); moq_stats_Failures moq_stats_Failures_default(void); uint64_t moq_stats_Failures_idle_timeout_get(const moq_stats_Failures *self); void moq_stats_Failures_idle_timeout_set(moq_stats_Failures *self, uint64_t value); @@ -2515,7 +2525,7 @@ uint64_t moq_stats_Failures_count(const moq_stats_Failures *self, moq_stats_Fail void moq_stats_Failures_add(moq_stats_Failures *self, moq_stats_Failures other); bool moq_stats_Failures_regressed(const moq_stats_Failures *self, moq_stats_Failures previous); bool moq_stats_Refusals_eq(const moq_stats_Refusals *a, const moq_stats_Refusals *b); -moq_buf moq_stats_Refusals_debug(const moq_stats_Refusals *self); +MOQ_MUST_USE moq_buf moq_stats_Refusals_debug(const moq_stats_Refusals *self); moq_stats_Refusals moq_stats_Refusals_default(void); uint64_t moq_stats_Refusals_refused_get(const moq_stats_Refusals *self); void moq_stats_Refusals_refused_set(moq_stats_Refusals *self, uint64_t value); @@ -2533,7 +2543,7 @@ uint64_t moq_stats_Refusals_count(const moq_stats_Refusals *self, moq_stats_Refu void moq_stats_Refusals_add(moq_stats_Refusals *self, moq_stats_Refusals other); bool moq_stats_Refusals_regressed(const moq_stats_Refusals *self, moq_stats_Refusals previous); bool moq_stats_RouteCloses_eq(const moq_stats_RouteCloses *a, const moq_stats_RouteCloses *b); -moq_buf moq_stats_RouteCloses_debug(const moq_stats_RouteCloses *self); +MOQ_MUST_USE moq_buf moq_stats_RouteCloses_debug(const moq_stats_RouteCloses *self); moq_stats_RouteCloses moq_stats_RouteCloses_default(void); uint64_t moq_stats_RouteCloses_stalled_get(const moq_stats_RouteCloses *self); void moq_stats_RouteCloses_stalled_set(moq_stats_RouteCloses *self, uint64_t value); @@ -2554,7 +2564,7 @@ uint64_t moq_stats_RouteCloses_total(const moq_stats_RouteCloses *self); void moq_stats_RouteCloses_add(moq_stats_RouteCloses *self, moq_stats_RouteCloses other); bool moq_stats_RouteCloses_regressed(const moq_stats_RouteCloses *self, moq_stats_RouteCloses previous); bool moq_stats_RouteRefusals_eq(const moq_stats_RouteRefusals *a, const moq_stats_RouteRefusals *b); -moq_buf moq_stats_RouteRefusals_debug(const moq_stats_RouteRefusals *self); +MOQ_MUST_USE moq_buf moq_stats_RouteRefusals_debug(const moq_stats_RouteRefusals *self); moq_stats_RouteRefusals moq_stats_RouteRefusals_default(void); uint64_t moq_stats_RouteRefusals_path_get(const moq_stats_RouteRefusals *self); void moq_stats_RouteRefusals_path_set(moq_stats_RouteRefusals *self, uint64_t value); @@ -2567,7 +2577,7 @@ uint64_t moq_stats_RouteRefusals_total(const moq_stats_RouteRefusals *self); void moq_stats_RouteRefusals_add(moq_stats_RouteRefusals *self, moq_stats_RouteRefusals other); bool moq_stats_RouteRefusals_regressed(const moq_stats_RouteRefusals *self, moq_stats_RouteRefusals previous); bool moq_stats_Routes_eq(const moq_stats_Routes *a, const moq_stats_Routes *b); -moq_buf moq_stats_Routes_debug(const moq_stats_Routes *self); +MOQ_MUST_USE moq_buf moq_stats_Routes_debug(const moq_stats_Routes *self); moq_stats_Routes moq_stats_Routes_default(void); uint64_t moq_stats_Routes_changed_get(const moq_stats_Routes *self); void moq_stats_Routes_changed_set(moq_stats_Routes *self, uint64_t value); @@ -2584,7 +2594,7 @@ void moq_stats_Routes_closed_set(moq_stats_Routes *self, moq_stats_RouteCloses v void moq_stats_Routes_add(moq_stats_Routes *self, moq_stats_Routes other); bool moq_stats_Routes_regressed(const moq_stats_Routes *self, moq_stats_Routes previous); bool moq_stats_Withdrawals_eq(const moq_stats_Withdrawals *a, const moq_stats_Withdrawals *b); -moq_buf moq_stats_Withdrawals_debug(const moq_stats_Withdrawals *self); +MOQ_MUST_USE moq_buf moq_stats_Withdrawals_debug(const moq_stats_Withdrawals *self); moq_stats_Withdrawals moq_stats_Withdrawals_default(void); uint64_t moq_stats_Withdrawals_dead_get(const moq_stats_Withdrawals *self); void moq_stats_Withdrawals_dead_set(moq_stats_Withdrawals *self, uint64_t value); @@ -2595,20 +2605,20 @@ uint64_t moq_stats_Withdrawals_total(const moq_stats_Withdrawals *self); void moq_stats_Withdrawals_add(moq_stats_Withdrawals *self, moq_stats_Withdrawals other); bool moq_stats_Withdrawals_regressed(const moq_stats_Withdrawals *self, moq_stats_Withdrawals previous); bool moq_transport_ReceiveWindow_eq(const moq_transport_ReceiveWindow *a, const moq_transport_ReceiveWindow *b); -moq_buf moq_transport_ReceiveWindow_debug(const moq_transport_ReceiveWindow *self); +MOQ_MUST_USE moq_buf moq_transport_ReceiveWindow_debug(const moq_transport_ReceiveWindow *self); moq_option_non_zero_u64 moq_transport_ReceiveWindow_connection_get(const moq_transport_ReceiveWindow *self); void moq_transport_ReceiveWindow_connection_set(moq_transport_ReceiveWindow *self, moq_option_non_zero_u64 value); uint64_t moq_transport_ReceiveWindow_stream_get(const moq_transport_ReceiveWindow *self); void moq_transport_ReceiveWindow_stream_set(moq_transport_ReceiveWindow *self, uint64_t value); moq_transport_ReceiveWindow moq_transport_ReceiveWindow_new(moq_option_non_zero_u64 connection, uint64_t stream); bool moq_transport_Limits_eq(const moq_transport_Limits *a, const moq_transport_Limits *b); -moq_buf moq_transport_Limits_debug(const moq_transport_Limits *self); +MOQ_MUST_USE moq_buf moq_transport_Limits_debug(const moq_transport_Limits *self); moq_transport_Limits moq_transport_Limits_default(void); moq_option_non_zero_u64 moq_transport_Limits_receive_window_get(const moq_transport_Limits *self); void moq_transport_Limits_receive_window_set(moq_transport_Limits *self, moq_option_non_zero_u64 value); bool moq_bandwidth_Rate_eq(const moq_bandwidth_Rate *a, const moq_bandwidth_Rate *b); uint64_t moq_bandwidth_Rate_hash(const moq_bandwidth_Rate *self); -moq_buf moq_bandwidth_Rate_debug(const moq_bandwidth_Rate *self); +MOQ_MUST_USE moq_buf moq_bandwidth_Rate_debug(const moq_bandwidth_Rate *self); moq_bandwidth_Rate moq_bandwidth_Rate_default(void); moq_bandwidth_Rate moq_bandwidth_Rate_ZERO(void); moq_bandwidth_Rate moq_bandwidth_Rate_from_bps(uint64_t bps); @@ -2619,22 +2629,22 @@ moq_bandwidth_Rate moq_bandwidth_Rate_scaled(const moq_bandwidth_Rate *self, dou moq_bandwidth_Rate moq_bandwidth_Rate_abs_diff(const moq_bandwidth_Rate *self, moq_bandwidth_Rate other); void moq_datagram_Datagram_free(moq_datagram_Datagram *self); bool moq_datagram_Datagram_eq(const moq_datagram_Datagram *a, const moq_datagram_Datagram *b); -moq_buf moq_datagram_Datagram_debug(const moq_datagram_Datagram *self); +MOQ_MUST_USE moq_buf moq_datagram_Datagram_debug(const moq_datagram_Datagram *self); void moq_frame_Info_free(moq_frame_Info *self); -moq_buf moq_frame_Info_debug(const moq_frame_Info *self); +MOQ_MUST_USE moq_buf moq_frame_Info_debug(const moq_frame_Info *self); void moq_group_Info_free(moq_group_Info *self); bool moq_group_Info_eq(const moq_group_Info *a, const moq_group_Info *b); uint64_t moq_group_Info_hash(const moq_group_Info *self); -moq_buf moq_group_Info_debug(const moq_group_Info *self); +MOQ_MUST_USE moq_buf moq_group_Info_debug(const moq_group_Info *self); void moq_track_Delay_free(moq_track_Delay *self); bool moq_track_Delay_eq(const moq_track_Delay *a, const moq_track_Delay *b); -moq_buf moq_track_Delay_debug(const moq_track_Delay *self); +MOQ_MUST_USE moq_buf moq_track_Delay_debug(const moq_track_Delay *self); moq_track_Delay moq_track_Delay_default(void); moq_track_Delay moq_track_Delay_with_min(const moq_track_Delay *self, moq_option_duration min); moq_track_Delay moq_track_Delay_with_max(const moq_track_Delay *self, moq_option_duration max); bool moq_track_Position_eq(const moq_track_Position *a, const moq_track_Position *b); uint64_t moq_track_Position_hash(const moq_track_Position *self); -moq_buf moq_track_Position_debug(const moq_track_Position *self); +MOQ_MUST_USE moq_buf moq_track_Position_debug(const moq_track_Position *self); moq_track_Position moq_track_Position_default(void); uint64_t moq_track_Position_group_get(const moq_track_Position *self); void moq_track_Position_group_set(moq_track_Position *self, uint64_t value); @@ -2645,32 +2655,32 @@ moq_track_Position moq_track_Position_group(uint64_t group); void moq_track_Range_free(moq_track_Range *self); bool moq_track_Range_eq(const moq_track_Range *a, const moq_track_Range *b); uint64_t moq_track_Range_hash(const moq_track_Range *self); -moq_buf moq_track_Range_debug(const moq_track_Range *self); +MOQ_MUST_USE moq_buf moq_track_Range_debug(const moq_track_Range *self); moq_track_Range moq_track_Range_live(void); moq_track_Range moq_track_Range_oldest(void); bool moq_origin_Cost_eq(const moq_origin_Cost *a, const moq_origin_Cost *b); -moq_buf moq_origin_Cost_debug(const moq_origin_Cost *self); +MOQ_MUST_USE moq_buf moq_origin_Cost_debug(const moq_origin_Cost *self); moq_origin_Cost moq_origin_Cost_default(void); moq_origin_Cost moq_origin_Cost_new(uint64_t cost); uint64_t moq_origin_Cost_value(const moq_origin_Cost *self); bool moq_origin_Priority_eq(const moq_origin_Priority *a, const moq_origin_Priority *b); uint64_t moq_origin_Priority_hash(const moq_origin_Priority *self); -moq_buf moq_origin_Priority_debug(const moq_origin_Priority *self); +MOQ_MUST_USE moq_buf moq_origin_Priority_debug(const moq_origin_Priority *self); moq_origin_Priority moq_origin_Priority_default(void); moq_origin_Priority moq_origin_Priority_new(int8_t priority); int8_t moq_origin_Priority_value(const moq_origin_Priority *self); void moq_hang_catalog_AAC_free(moq_hang_catalog_AAC *self); bool moq_hang_catalog_AAC_eq(const moq_hang_catalog_AAC *a, const moq_hang_catalog_AAC *b); -moq_buf moq_hang_catalog_AAC_to_string(const moq_hang_catalog_AAC *self); -moq_buf moq_hang_catalog_AAC_debug(const moq_hang_catalog_AAC *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_AAC_to_string(const moq_hang_catalog_AAC *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_AAC_debug(const moq_hang_catalog_AAC *self); bool moq_hang_catalog_Clock_eq(const moq_hang_catalog_Clock *a, const moq_hang_catalog_Clock *b); -moq_buf moq_hang_catalog_Clock_debug(const moq_hang_catalog_Clock *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_Clock_debug(const moq_hang_catalog_Clock *self); moq_Timestamp moq_hang_catalog_Clock_wall_get(const moq_hang_catalog_Clock *self); void moq_hang_catalog_Clock_wall_set(moq_hang_catalog_Clock *self, moq_Timestamp value); -bool moq_hang_catalog_Clock_new(moq_Timestamp wall, moq_hang_catalog_Clock *out, moq_hang_Error **err); -bool moq_hang_catalog_Clock_wall_clock(const moq_hang_catalog_Clock *self, moq_Timestamp pts, moq_clock_Wall *out, moq_hang_Error **err); +MOQ_MUST_USE bool moq_hang_catalog_Clock_new(moq_Timestamp wall, moq_hang_catalog_Clock *out, moq_hang_Error **err); +MOQ_MUST_USE bool moq_hang_catalog_Clock_wall_clock(const moq_hang_catalog_Clock *self, moq_Timestamp pts, moq_clock_Wall *out, moq_hang_Error **err); bool moq_hang_catalog_Priorities_eq(const moq_hang_catalog_Priorities *a, const moq_hang_catalog_Priorities *b); -moq_buf moq_hang_catalog_Priorities_debug(const moq_hang_catalog_Priorities *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_Priorities_debug(const moq_hang_catalog_Priorities *self); int8_t moq_hang_catalog_Priorities_catalog_get(const moq_hang_catalog_Priorities *self); void moq_hang_catalog_Priorities_catalog_set(moq_hang_catalog_Priorities *self, int8_t value); int8_t moq_hang_catalog_Priorities_text_get(const moq_hang_catalog_Priorities *self); @@ -2681,670 +2691,670 @@ int8_t moq_hang_catalog_Priorities_video_get(const moq_hang_catalog_Priorities * void moq_hang_catalog_Priorities_video_set(moq_hang_catalog_Priorities *self, int8_t value); void moq_hang_catalog_AV1_free(moq_hang_catalog_AV1 *self); bool moq_hang_catalog_AV1_eq(const moq_hang_catalog_AV1 *a, const moq_hang_catalog_AV1 *b); -moq_buf moq_hang_catalog_AV1_to_string(const moq_hang_catalog_AV1 *self); -moq_buf moq_hang_catalog_AV1_debug(const moq_hang_catalog_AV1 *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_AV1_to_string(const moq_hang_catalog_AV1 *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_AV1_debug(const moq_hang_catalog_AV1 *self); moq_hang_catalog_AV1 moq_hang_catalog_AV1_default(void); -moq_buf moq_hang_catalog_AV1_PREFIX(void); +MOQ_MUST_USE moq_buf moq_hang_catalog_AV1_PREFIX(void); void moq_hang_catalog_Mastering_free(moq_hang_catalog_Mastering *self); bool moq_hang_catalog_Mastering_eq(const moq_hang_catalog_Mastering *a, const moq_hang_catalog_Mastering *b); -moq_buf moq_hang_catalog_Mastering_debug(const moq_hang_catalog_Mastering *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_Mastering_debug(const moq_hang_catalog_Mastering *self); void moq_hang_catalog_Chromaticity_free(moq_hang_catalog_Chromaticity *self); bool moq_hang_catalog_Chromaticity_eq(const moq_hang_catalog_Chromaticity *a, const moq_hang_catalog_Chromaticity *b); -moq_buf moq_hang_catalog_Chromaticity_debug(const moq_hang_catalog_Chromaticity *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_Chromaticity_debug(const moq_hang_catalog_Chromaticity *self); void moq_hang_catalog_ContentLight_free(moq_hang_catalog_ContentLight *self); bool moq_hang_catalog_ContentLight_eq(const moq_hang_catalog_ContentLight *a, const moq_hang_catalog_ContentLight *b); -moq_buf moq_hang_catalog_ContentLight_debug(const moq_hang_catalog_ContentLight *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_ContentLight_debug(const moq_hang_catalog_ContentLight *self); void moq_hang_catalog_H264_free(moq_hang_catalog_H264 *self); bool moq_hang_catalog_H264_eq(const moq_hang_catalog_H264 *a, const moq_hang_catalog_H264 *b); -moq_buf moq_hang_catalog_H264_to_string(const moq_hang_catalog_H264 *self); -moq_buf moq_hang_catalog_H264_debug(const moq_hang_catalog_H264 *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_H264_to_string(const moq_hang_catalog_H264 *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_H264_debug(const moq_hang_catalog_H264 *self); void moq_hang_catalog_H265_free(moq_hang_catalog_H265 *self); bool moq_hang_catalog_H265_eq(const moq_hang_catalog_H265 *a, const moq_hang_catalog_H265 *b); -moq_buf moq_hang_catalog_H265_to_string(const moq_hang_catalog_H265 *self); -moq_buf moq_hang_catalog_H265_debug(const moq_hang_catalog_H265 *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_H265_to_string(const moq_hang_catalog_H265 *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_H265_debug(const moq_hang_catalog_H265 *self); void moq_hang_catalog_VP9_free(moq_hang_catalog_VP9 *self); bool moq_hang_catalog_VP9_eq(const moq_hang_catalog_VP9 *a, const moq_hang_catalog_VP9 *b); -moq_buf moq_hang_catalog_VP9_to_string(const moq_hang_catalog_VP9 *self); -moq_buf moq_hang_catalog_VP9_debug(const moq_hang_catalog_VP9 *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_VP9_to_string(const moq_hang_catalog_VP9 *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_VP9_debug(const moq_hang_catalog_VP9 *self); moq_hang_catalog_VP9 moq_hang_catalog_VP9_default(void); void moq_hang_catalog_Display_free(moq_hang_catalog_Display *self); bool moq_hang_catalog_Display_eq(const moq_hang_catalog_Display *a, const moq_hang_catalog_Display *b); -moq_buf moq_hang_catalog_Display_debug(const moq_hang_catalog_Display *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_Display_debug(const moq_hang_catalog_Display *self); void moq_hang_container_Frame_free(moq_hang_container_Frame *self); -moq_buf moq_hang_container_Frame_debug(const moq_hang_container_Frame *self); -bool moq_hang_container_Frame_encode(const moq_hang_container_Frame *self, moq_buf buf, moq_buf *buf_out, moq_hang_Error **err); -bool moq_hang_container_Frame_decode(moq_buf buf, moq_hang_container_Frame *out, moq_hang_Error **err); -bool moq_hang_container_Frame_write_to(const moq_hang_container_Frame *self, moq_group_Producer *group, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_container_Frame_debug(const moq_hang_container_Frame *self); +MOQ_MUST_USE bool moq_hang_container_Frame_encode(const moq_hang_container_Frame *self, moq_buf buf, moq_buf *buf_out, moq_hang_Error **err); +MOQ_MUST_USE bool moq_hang_container_Frame_decode(moq_buf buf, moq_hang_container_Frame *out, moq_hang_Error **err); +MOQ_MUST_USE bool moq_hang_container_Frame_write_to(const moq_hang_container_Frame *self, moq_group_Producer *group, moq_hang_Error **err, moq_status *status); void moq_mux_container_Frame_free(moq_mux_container_Frame *self); -moq_buf moq_mux_container_Frame_debug(const moq_mux_container_Frame *self); +MOQ_MUST_USE moq_buf moq_mux_container_Frame_debug(const moq_mux_container_Frame *self); void moq_mux_container_TimestampRewind_free(moq_mux_container_TimestampRewind *self); bool moq_mux_container_TimestampRewind_eq(const moq_mux_container_TimestampRewind *a, const moq_mux_container_TimestampRewind *b); -moq_buf moq_mux_container_TimestampRewind_to_string(const moq_mux_container_TimestampRewind *self); -moq_buf moq_mux_container_TimestampRewind_debug(const moq_mux_container_TimestampRewind *self); +MOQ_MUST_USE moq_buf moq_mux_container_TimestampRewind_to_string(const moq_mux_container_TimestampRewind *self); +MOQ_MUST_USE moq_buf moq_mux_container_TimestampRewind_debug(const moq_mux_container_TimestampRewind *self); void moq_mux_container_Playout_free(moq_mux_container_Playout *self); bool moq_mux_container_Playout_eq(const moq_mux_container_Playout *a, const moq_mux_container_Playout *b); -moq_buf moq_mux_container_Playout_debug(const moq_mux_container_Playout *self); +MOQ_MUST_USE moq_buf moq_mux_container_Playout_debug(const moq_mux_container_Playout *self); moq_mux_container_Playout moq_mux_container_Playout_default(void); moq_mux_container_Playout moq_mux_container_Playout_new(moq_track_Delay delay, moq_duration warmup); -moq_track_Subscription *moq_mux_container_Playout_subscription(const moq_mux_container_Playout *self, moq_track_Subscription *subscription, moq_status *status); -moq_mux_container_Consumer_Container *moq_mux_container_Playout_consumer_Container(const moq_mux_container_Playout *self, moq_track_Subscriber *track, moq_mux_catalog_hang_Container *format, moq_status *status); -moq_mux_container_Consumer_fmp4_Wire *moq_mux_container_Playout_consumer_fmp4_Wire(const moq_mux_container_Playout *self, moq_track_Subscriber *track, moq_mux_container_fmp4_Wire *format, moq_status *status); -moq_mux_container_Consumer_legacy_Wire *moq_mux_container_Playout_consumer_legacy_Wire(const moq_mux_container_Playout *self, moq_track_Subscriber *track, moq_mux_container_legacy_Wire format, moq_status *status); -moq_mux_container_Consumer_loc_Wire *moq_mux_container_Playout_consumer_loc_Wire(const moq_mux_container_Playout *self, moq_track_Subscriber *track, moq_mux_container_loc_Wire format, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Playout_subscription(const moq_mux_container_Playout *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_mux_container_Consumer_Container *moq_mux_container_Playout_consumer_Container(const moq_mux_container_Playout *self, moq_track_Subscriber *track, moq_mux_catalog_hang_Container *format, moq_status *status); +MOQ_MUST_USE moq_mux_container_Consumer_fmp4_Wire *moq_mux_container_Playout_consumer_fmp4_Wire(const moq_mux_container_Playout *self, moq_track_Subscriber *track, moq_mux_container_fmp4_Wire *format, moq_status *status); +MOQ_MUST_USE moq_mux_container_Consumer_legacy_Wire *moq_mux_container_Playout_consumer_legacy_Wire(const moq_mux_container_Playout *self, moq_track_Subscriber *track, moq_mux_container_legacy_Wire format, moq_status *status); +MOQ_MUST_USE moq_mux_container_Consumer_loc_Wire *moq_mux_container_Playout_consumer_loc_Wire(const moq_mux_container_Playout *self, moq_track_Subscriber *track, moq_mux_container_loc_Wire format, moq_status *status); void moq_mux_codec_flac_Config_free(moq_mux_codec_flac_Config *self); bool moq_mux_codec_flac_Config_eq(const moq_mux_codec_flac_Config *a, const moq_mux_codec_flac_Config *b); -moq_buf moq_mux_codec_flac_Config_debug(const moq_mux_codec_flac_Config *self); -bool moq_mux_codec_flac_Config_parse_stream_info(moq_buf buf, moq_buf *buf_out, moq_mux_codec_flac_Config *out, moq_mux_codec_flac_Error *err); -bool moq_mux_codec_flac_Config_parse(moq_buf buf, moq_buf *buf_out, moq_mux_codec_flac_Config *out, moq_mux_codec_flac_Error *err); -moq_buf moq_mux_codec_flac_Config_encode_stream_info(const moq_mux_codec_flac_Config *self); -moq_buf moq_mux_codec_flac_Config_description(const moq_mux_codec_flac_Config *self); +MOQ_MUST_USE moq_buf moq_mux_codec_flac_Config_debug(const moq_mux_codec_flac_Config *self); +MOQ_MUST_USE bool moq_mux_codec_flac_Config_parse_stream_info(moq_buf buf, moq_buf *buf_out, moq_mux_codec_flac_Config *out, moq_mux_codec_flac_Error *err); +MOQ_MUST_USE bool moq_mux_codec_flac_Config_parse(moq_buf buf, moq_buf *buf_out, moq_mux_codec_flac_Config *out, moq_mux_codec_flac_Error *err); +MOQ_MUST_USE moq_buf moq_mux_codec_flac_Config_encode_stream_info(const moq_mux_codec_flac_Config *self); +MOQ_MUST_USE moq_buf moq_mux_codec_flac_Config_description(const moq_mux_codec_flac_Config *self); void moq_mux_codec_h264_Sps_free(moq_mux_codec_h264_Sps *self); -moq_buf moq_mux_codec_h264_Sps_debug(const moq_mux_codec_h264_Sps *self); -bool moq_mux_codec_h264_Sps_parse(moq_buf nal, moq_mux_codec_h264_Sps *out, moq_mux_codec_h264_Error **err); +MOQ_MUST_USE moq_buf moq_mux_codec_h264_Sps_debug(const moq_mux_codec_h264_Sps *self); +MOQ_MUST_USE bool moq_mux_codec_h264_Sps_parse(moq_buf nal, moq_mux_codec_h264_Sps *out, moq_mux_codec_h264_Error **err); void moq_mux_codec_h265_VideoSignal_free(moq_mux_codec_h265_VideoSignal *self); bool moq_mux_codec_h265_VideoSignal_eq(const moq_mux_codec_h265_VideoSignal *a, const moq_mux_codec_h265_VideoSignal *b); -moq_buf moq_mux_codec_h265_VideoSignal_debug(const moq_mux_codec_h265_VideoSignal *self); +MOQ_MUST_USE moq_buf moq_mux_codec_h265_VideoSignal_debug(const moq_mux_codec_h265_VideoSignal *self); void moq_mux_codec_mp3_Config_free(moq_mux_codec_mp3_Config *self); -bool moq_mux_codec_mp3_Config_parse(moq_buf data_, moq_mux_codec_mp3_Config *out, moq_mux_codec_mp3_Error *err); +MOQ_MUST_USE bool moq_mux_codec_mp3_Config_parse(moq_buf data_, moq_mux_codec_mp3_Config *out, moq_mux_codec_mp3_Error *err); bool moq_mux_codec_opus_Mapping_eq(const moq_mux_codec_opus_Mapping *a, const moq_mux_codec_opus_Mapping *b); -moq_buf moq_mux_codec_opus_Mapping_debug(const moq_mux_codec_opus_Mapping *self); +MOQ_MUST_USE moq_buf moq_mux_codec_opus_Mapping_debug(const moq_mux_codec_opus_Mapping *self); uint8_t moq_mux_codec_opus_Mapping_family(const moq_mux_codec_opus_Mapping *self); uint8_t moq_mux_codec_opus_Mapping_streams(const moq_mux_codec_opus_Mapping *self); uint8_t moq_mux_codec_opus_Mapping_coupled(const moq_mux_codec_opus_Mapping *self); -moq_buf moq_mux_codec_opus_Mapping_table(const moq_mux_codec_opus_Mapping *self); +MOQ_MUST_USE moq_buf moq_mux_codec_opus_Mapping_table(const moq_mux_codec_opus_Mapping *self); void moq_mux_container_fmp4_Fragment_free(moq_mux_container_fmp4_Fragment *self); -moq_buf moq_mux_container_fmp4_Fragment_debug(const moq_mux_container_fmp4_Fragment *self); +MOQ_MUST_USE moq_buf moq_mux_container_fmp4_Fragment_debug(const moq_mux_container_fmp4_Fragment *self); void moq_mux_container_legacy_Wire_free(moq_mux_container_legacy_Wire *self); void moq_mux_container_loc_Wire_free(moq_mux_container_loc_Wire *self); void moq_mux_container_ts_Descriptor_free(moq_mux_container_ts_Descriptor *self); bool moq_mux_container_ts_Descriptor_eq(const moq_mux_container_ts_Descriptor *a, const moq_mux_container_ts_Descriptor *b); -moq_buf moq_mux_container_ts_Descriptor_debug(const moq_mux_container_ts_Descriptor *self); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Descriptor_debug(const moq_mux_container_ts_Descriptor *self); void moq_rustls_client_TicketRequest_free(moq_rustls_client_TicketRequest *self); bool moq_rustls_client_TicketRequest_eq(const moq_rustls_client_TicketRequest *a, const moq_rustls_client_TicketRequest *b); -moq_buf moq_rustls_client_TicketRequest_debug(const moq_rustls_client_TicketRequest *self); +MOQ_MUST_USE moq_buf moq_rustls_client_TicketRequest_debug(const moq_rustls_client_TicketRequest *self); void moq_rustls_crypto_hpke_HpkePublicKey_free(moq_rustls_crypto_hpke_HpkePublicKey *self); -moq_buf moq_rustls_crypto_hpke_HpkePublicKey_debug(const moq_rustls_crypto_hpke_HpkePublicKey *self); -moq_buf moq_EncodeError_to_string(const moq_EncodeError *self); -moq_buf moq_EncodeError_debug(const moq_EncodeError *self); +MOQ_MUST_USE moq_buf moq_rustls_crypto_hpke_HpkePublicKey_debug(const moq_rustls_crypto_hpke_HpkePublicKey *self); +MOQ_MUST_USE moq_buf moq_EncodeError_to_string(const moq_EncodeError *self); +MOQ_MUST_USE moq_buf moq_EncodeError_debug(const moq_EncodeError *self); void moq_InvalidPattern_free(moq_InvalidPattern *self); bool moq_InvalidPattern_eq(const moq_InvalidPattern *a, const moq_InvalidPattern *b); -moq_buf moq_InvalidPattern_to_string(const moq_InvalidPattern *self); -moq_buf moq_InvalidPattern_debug(const moq_InvalidPattern *self); +MOQ_MUST_USE moq_buf moq_InvalidPattern_to_string(const moq_InvalidPattern *self); +MOQ_MUST_USE moq_buf moq_InvalidPattern_debug(const moq_InvalidPattern *self); void moq_SessionError_free(moq_SessionError *self); bool moq_SessionError_eq(const moq_SessionError *a, const moq_SessionError *b); -moq_buf moq_SessionError_to_string(const moq_SessionError *self); -moq_buf moq_SessionError_debug(const moq_SessionError *self); +MOQ_MUST_USE moq_buf moq_SessionError_to_string(const moq_SessionError *self); +MOQ_MUST_USE moq_buf moq_SessionError_debug(const moq_SessionError *self); uint32_t moq_SessionError_to_code(const moq_SessionError *self); moq_SessionError moq_SessionError_from_code(uint32_t code); void moq_StreamError_free(moq_StreamError *self); bool moq_StreamError_eq(const moq_StreamError *a, const moq_StreamError *b); -moq_buf moq_StreamError_to_string(const moq_StreamError *self); -moq_buf moq_StreamError_debug(const moq_StreamError *self); +MOQ_MUST_USE moq_buf moq_StreamError_to_string(const moq_StreamError *self); +MOQ_MUST_USE moq_buf moq_StreamError_debug(const moq_StreamError *self); uint32_t moq_StreamError_to_code(const moq_StreamError *self); moq_StreamError moq_StreamError_from_code(uint32_t code); bool moq_Retry_eq(const moq_Retry *a, const moq_Retry *b); -moq_buf moq_Retry_debug(const moq_Retry *self); +MOQ_MUST_USE moq_buf moq_Retry_debug(const moq_Retry *self); bool moq_IntersectionError_eq(const moq_IntersectionError *a, const moq_IntersectionError *b); -moq_buf moq_IntersectionError_to_string(const moq_IntersectionError *self); -moq_buf moq_IntersectionError_debug(const moq_IntersectionError *self); +MOQ_MUST_USE moq_buf moq_IntersectionError_to_string(const moq_IntersectionError *self); +MOQ_MUST_USE moq_buf moq_IntersectionError_debug(const moq_IntersectionError *self); void moq_Segment_free(moq_Segment *self); bool moq_Segment_eq(const moq_Segment *a, const moq_Segment *b); uint64_t moq_Segment_hash(const moq_Segment *self); -moq_buf moq_Segment_to_string(const moq_Segment *self); -moq_buf moq_Segment_debug(const moq_Segment *self); +MOQ_MUST_USE moq_buf moq_Segment_to_string(const moq_Segment *self); +MOQ_MUST_USE moq_buf moq_Segment_debug(const moq_Segment *self); bool moq_clock_MissedTickBehavior_eq(const moq_clock_MissedTickBehavior *a, const moq_clock_MissedTickBehavior *b); -moq_buf moq_clock_MissedTickBehavior_debug(const moq_clock_MissedTickBehavior *self); +MOQ_MUST_USE moq_buf moq_clock_MissedTickBehavior_debug(const moq_clock_MissedTickBehavior *self); moq_clock_MissedTickBehavior moq_clock_MissedTickBehavior_default(void); bool moq_tokio_ConnectError_eq(const moq_tokio_ConnectError *a, const moq_tokio_ConnectError *b); -moq_buf moq_tokio_ConnectError_to_string(const moq_tokio_ConnectError *self); -moq_buf moq_tokio_ConnectError_debug(const moq_tokio_ConnectError *self); +MOQ_MUST_USE moq_buf moq_tokio_ConnectError_to_string(const moq_tokio_ConnectError *self); +MOQ_MUST_USE moq_buf moq_tokio_ConnectError_debug(const moq_tokio_ConnectError *self); bool moq_tokio_ConnectError_is_auth(const moq_tokio_ConnectError *self); bool moq_tokio_Restart_eq(const moq_tokio_Restart *a, const moq_tokio_Restart *b); -moq_buf moq_tokio_Restart_debug(const moq_tokio_Restart *self); +MOQ_MUST_USE moq_buf moq_tokio_Restart_debug(const moq_tokio_Restart *self); moq_tokio_Restart moq_tokio_Restart_default(void); bool moq_tokio_Status_eq(const moq_tokio_Status *a, const moq_tokio_Status *b); -moq_buf moq_tokio_Status_debug(const moq_tokio_Status *self); +MOQ_MUST_USE moq_buf moq_tokio_Status_debug(const moq_tokio_Status *self); bool moq_tokio_Transport_eq(const moq_tokio_Transport *a, const moq_tokio_Transport *b); uint64_t moq_tokio_Transport_hash(const moq_tokio_Transport *self); -moq_buf moq_tokio_Transport_to_string(const moq_tokio_Transport *self); -moq_buf moq_tokio_Transport_debug(const moq_tokio_Transport *self); -moq_buf moq_tokio_Transport_as_str(const moq_tokio_Transport *self); +MOQ_MUST_USE moq_buf moq_tokio_Transport_to_string(const moq_tokio_Transport *self); +MOQ_MUST_USE moq_buf moq_tokio_Transport_debug(const moq_tokio_Transport *self); +MOQ_MUST_USE moq_buf moq_tokio_Transport_as_str(const moq_tokio_Transport *self); bool moq_path_Error_eq(const moq_path_Error *a, const moq_path_Error *b); -moq_buf moq_path_Error_to_string(const moq_path_Error *self); -moq_buf moq_path_Error_debug(const moq_path_Error *self); +MOQ_MUST_USE moq_buf moq_path_Error_to_string(const moq_path_Error *self); +MOQ_MUST_USE moq_buf moq_path_Error_debug(const moq_path_Error *self); bool moq_setup_Role_eq(const moq_setup_Role *a, const moq_setup_Role *b); -moq_buf moq_setup_Role_to_string(const moq_setup_Role *self); -moq_buf moq_setup_Role_debug(const moq_setup_Role *self); -moq_buf moq_setup_Role_as_str(const moq_setup_Role *self); +MOQ_MUST_USE moq_buf moq_setup_Role_to_string(const moq_setup_Role *self); +MOQ_MUST_USE moq_buf moq_setup_Role_debug(const moq_setup_Role *self); +MOQ_MUST_USE moq_buf moq_setup_Role_as_str(const moq_setup_Role *self); bool moq_reconnect_Verdict_eq(const moq_reconnect_Verdict *a, const moq_reconnect_Verdict *b); -moq_buf moq_reconnect_Verdict_debug(const moq_reconnect_Verdict *self); +MOQ_MUST_USE moq_buf moq_reconnect_Verdict_debug(const moq_reconnect_Verdict *self); bool moq_reconnect_ConfigError_eq(const moq_reconnect_ConfigError *a, const moq_reconnect_ConfigError *b); -moq_buf moq_reconnect_ConfigError_to_string(const moq_reconnect_ConfigError *self); -moq_buf moq_reconnect_ConfigError_debug(const moq_reconnect_ConfigError *self); +MOQ_MUST_USE moq_buf moq_reconnect_ConfigError_to_string(const moq_reconnect_ConfigError *self); +MOQ_MUST_USE moq_buf moq_reconnect_ConfigError_debug(const moq_reconnect_ConfigError *self); bool moq_reconnect_Redirect_eq(const moq_reconnect_Redirect *a, const moq_reconnect_Redirect *b); -moq_buf moq_reconnect_Redirect_debug(const moq_reconnect_Redirect *self); +MOQ_MUST_USE moq_buf moq_reconnect_Redirect_debug(const moq_reconnect_Redirect *self); moq_reconnect_Redirect moq_reconnect_Redirect_default(void); bool moq_stats_Role_eq(const moq_stats_Role *a, const moq_stats_Role *b); uint64_t moq_stats_Role_hash(const moq_stats_Role *self); -moq_buf moq_stats_Role_debug(const moq_stats_Role *self); -moq_buf moq_stats_Role_as_str(const moq_stats_Role *self); +MOQ_MUST_USE moq_buf moq_stats_Role_debug(const moq_stats_Role *self); +MOQ_MUST_USE moq_buf moq_stats_Role_as_str(const moq_stats_Role *self); bool moq_stats_Message_eq(const moq_stats_Message *a, const moq_stats_Message *b); -moq_buf moq_stats_Message_debug(const moq_stats_Message *self); -moq_buf moq_stats_Message_as_str(const moq_stats_Message *self); +MOQ_MUST_USE moq_buf moq_stats_Message_debug(const moq_stats_Message *self); +MOQ_MUST_USE moq_buf moq_stats_Message_as_str(const moq_stats_Message *self); bool moq_stats_Failure_eq(const moq_stats_Failure *a, const moq_stats_Failure *b); -moq_buf moq_stats_Failure_debug(const moq_stats_Failure *self); -moq_vec_stats_Failure moq_stats_Failure_ALL(void); -moq_buf moq_stats_Failure_as_str(const moq_stats_Failure *self); +MOQ_MUST_USE moq_buf moq_stats_Failure_debug(const moq_stats_Failure *self); +MOQ_MUST_USE moq_vec_stats_Failure moq_stats_Failure_ALL(void); +MOQ_MUST_USE moq_buf moq_stats_Failure_as_str(const moq_stats_Failure *self); bool moq_stats_RefusalKind_eq(const moq_stats_RefusalKind *a, const moq_stats_RefusalKind *b); -moq_buf moq_stats_RefusalKind_debug(const moq_stats_RefusalKind *self); -moq_vec_stats_RefusalKind moq_stats_RefusalKind_ALL(void); -moq_buf moq_stats_RefusalKind_as_str(const moq_stats_RefusalKind *self); +MOQ_MUST_USE moq_buf moq_stats_RefusalKind_debug(const moq_stats_RefusalKind *self); +MOQ_MUST_USE moq_vec_stats_RefusalKind moq_stats_RefusalKind_ALL(void); +MOQ_MUST_USE moq_buf moq_stats_RefusalKind_as_str(const moq_stats_RefusalKind *self); bool moq_stats_RouteClose_eq(const moq_stats_RouteClose *a, const moq_stats_RouteClose *b); -moq_buf moq_stats_RouteClose_debug(const moq_stats_RouteClose *self); -moq_vec_stats_RouteClose moq_stats_RouteClose_ALL(void); -moq_buf moq_stats_RouteClose_as_str(const moq_stats_RouteClose *self); +MOQ_MUST_USE moq_buf moq_stats_RouteClose_debug(const moq_stats_RouteClose *self); +MOQ_MUST_USE moq_vec_stats_RouteClose moq_stats_RouteClose_ALL(void); +MOQ_MUST_USE moq_buf moq_stats_RouteClose_as_str(const moq_stats_RouteClose *self); bool moq_stats_RouteRefusal_eq(const moq_stats_RouteRefusal *a, const moq_stats_RouteRefusal *b); -moq_buf moq_stats_RouteRefusal_debug(const moq_stats_RouteRefusal *self); -moq_vec_stats_RouteRefusal moq_stats_RouteRefusal_ALL(void); -moq_buf moq_stats_RouteRefusal_as_str(const moq_stats_RouteRefusal *self); +MOQ_MUST_USE moq_buf moq_stats_RouteRefusal_debug(const moq_stats_RouteRefusal *self); +MOQ_MUST_USE moq_vec_stats_RouteRefusal moq_stats_RouteRefusal_ALL(void); +MOQ_MUST_USE moq_buf moq_stats_RouteRefusal_as_str(const moq_stats_RouteRefusal *self); bool moq_stats_Withdrawal_eq(const moq_stats_Withdrawal *a, const moq_stats_Withdrawal *b); -moq_buf moq_stats_Withdrawal_debug(const moq_stats_Withdrawal *self); -moq_vec_stats_Withdrawal moq_stats_Withdrawal_ALL(void); -moq_buf moq_stats_Withdrawal_as_str(const moq_stats_Withdrawal *self); +MOQ_MUST_USE moq_buf moq_stats_Withdrawal_debug(const moq_stats_Withdrawal *self); +MOQ_MUST_USE moq_vec_stats_Withdrawal moq_stats_Withdrawal_ALL(void); +MOQ_MUST_USE moq_buf moq_stats_Withdrawal_as_str(const moq_stats_Withdrawal *self); bool moq_transport_Address_eq(const moq_transport_Address *a, const moq_transport_Address *b); -moq_buf moq_transport_Address_debug(const moq_transport_Address *self); +MOQ_MUST_USE moq_buf moq_transport_Address_debug(const moq_transport_Address *self); void moq_transport_LimitsError_free(moq_transport_LimitsError *self); bool moq_transport_LimitsError_eq(const moq_transport_LimitsError *a, const moq_transport_LimitsError *b); -moq_buf moq_transport_LimitsError_to_string(const moq_transport_LimitsError *self); -moq_buf moq_transport_LimitsError_debug(const moq_transport_LimitsError *self); +MOQ_MUST_USE moq_buf moq_transport_LimitsError_to_string(const moq_transport_LimitsError *self); +MOQ_MUST_USE moq_buf moq_transport_LimitsError_debug(const moq_transport_LimitsError *self); bool moq_transport_CloseKind_eq(const moq_transport_CloseKind *a, const moq_transport_CloseKind *b); -moq_buf moq_transport_CloseKind_debug(const moq_transport_CloseKind *self); +MOQ_MUST_USE moq_buf moq_transport_CloseKind_debug(const moq_transport_CloseKind *self); moq_transport_CloseKind moq_transport_CloseKind_default(void); bool moq_broadcast_Kind_eq(const moq_broadcast_Kind *a, const moq_broadcast_Kind *b); uint64_t moq_broadcast_Kind_hash(const moq_broadcast_Kind *self); -moq_buf moq_broadcast_Kind_debug(const moq_broadcast_Kind *self); +MOQ_MUST_USE moq_buf moq_broadcast_Kind_debug(const moq_broadcast_Kind *self); bool moq_track_Compression_eq(const moq_track_Compression *a, const moq_track_Compression *b); uint64_t moq_track_Compression_hash(const moq_track_Compression *self); -moq_buf moq_track_Compression_debug(const moq_track_Compression *self); +MOQ_MUST_USE moq_buf moq_track_Compression_debug(const moq_track_Compression *self); moq_track_Compression moq_track_Compression_default(void); void moq_track_Anchor_free(moq_track_Anchor *self); bool moq_track_Anchor_eq(const moq_track_Anchor *a, const moq_track_Anchor *b); uint64_t moq_track_Anchor_hash(const moq_track_Anchor *self); -moq_buf moq_track_Anchor_debug(const moq_track_Anchor *self); +MOQ_MUST_USE moq_buf moq_track_Anchor_debug(const moq_track_Anchor *self); bool moq_track_Order_eq(const moq_track_Order *a, const moq_track_Order *b); uint64_t moq_track_Order_hash(const moq_track_Order *self); -moq_buf moq_track_Order_debug(const moq_track_Order *self); +MOQ_MUST_USE moq_buf moq_track_Order_debug(const moq_track_Order *self); moq_track_Order moq_track_Order_default(void); bool moq_origin_Link_eq(const moq_origin_Link *a, const moq_origin_Link *b); uint64_t moq_origin_Link_hash(const moq_origin_Link *self); -moq_buf moq_origin_Link_debug(const moq_origin_Link *self); +MOQ_MUST_USE moq_buf moq_origin_Link_debug(const moq_origin_Link *self); moq_origin_Link moq_origin_Link_default(void); bool moq_origin_RouteKind_eq(const moq_origin_RouteKind *a, const moq_origin_RouteKind *b); -moq_buf moq_origin_RouteKind_debug(const moq_origin_RouteKind *self); +MOQ_MUST_USE moq_buf moq_origin_RouteKind_debug(const moq_origin_RouteKind *self); void moq_hang_catalog_AudioCodec_free(moq_hang_catalog_AudioCodec *self); bool moq_hang_catalog_AudioCodec_eq(const moq_hang_catalog_AudioCodec *a, const moq_hang_catalog_AudioCodec *b); -moq_buf moq_hang_catalog_AudioCodec_to_string(const moq_hang_catalog_AudioCodec *self); -moq_buf moq_hang_catalog_AudioCodec_debug(const moq_hang_catalog_AudioCodec *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_AudioCodec_to_string(const moq_hang_catalog_AudioCodec *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_AudioCodec_debug(const moq_hang_catalog_AudioCodec *self); moq_hang_catalog_AudioCodecKind moq_hang_catalog_AudioCodec_kind(const moq_hang_catalog_AudioCodec *self); bool moq_hang_catalog_AudioCodecKind_eq(const moq_hang_catalog_AudioCodecKind *a, const moq_hang_catalog_AudioCodecKind *b); uint64_t moq_hang_catalog_AudioCodecKind_hash(const moq_hang_catalog_AudioCodecKind *self); -moq_buf moq_hang_catalog_AudioCodecKind_debug(const moq_hang_catalog_AudioCodecKind *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_AudioCodecKind_debug(const moq_hang_catalog_AudioCodecKind *self); void moq_hang_catalog_AudioLayout_free(moq_hang_catalog_AudioLayout *self); bool moq_hang_catalog_AudioLayout_eq(const moq_hang_catalog_AudioLayout *a, const moq_hang_catalog_AudioLayout *b); -moq_buf moq_hang_catalog_AudioLayout_to_string(const moq_hang_catalog_AudioLayout *self); -moq_buf moq_hang_catalog_AudioLayout_debug(const moq_hang_catalog_AudioLayout *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_AudioLayout_to_string(const moq_hang_catalog_AudioLayout *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_AudioLayout_debug(const moq_hang_catalog_AudioLayout *self); void moq_hang_catalog_Mode_free(moq_hang_catalog_Mode *self); bool moq_hang_catalog_Mode_eq(const moq_hang_catalog_Mode *a, const moq_hang_catalog_Mode *b); -moq_buf moq_hang_catalog_Mode_to_string(const moq_hang_catalog_Mode *self); -moq_buf moq_hang_catalog_Mode_debug(const moq_hang_catalog_Mode *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_Mode_to_string(const moq_hang_catalog_Mode *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_Mode_debug(const moq_hang_catalog_Mode *self); void moq_hang_catalog_TextFormat_free(moq_hang_catalog_TextFormat *self); bool moq_hang_catalog_TextFormat_eq(const moq_hang_catalog_TextFormat *a, const moq_hang_catalog_TextFormat *b); -moq_buf moq_hang_catalog_TextFormat_to_string(const moq_hang_catalog_TextFormat *self); -moq_buf moq_hang_catalog_TextFormat_debug(const moq_hang_catalog_TextFormat *self); -moq_hang_catalog_TextFormat moq_hang_catalog_TextFormat_default(void); +MOQ_MUST_USE moq_buf moq_hang_catalog_TextFormat_to_string(const moq_hang_catalog_TextFormat *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_TextFormat_debug(const moq_hang_catalog_TextFormat *self); +MOQ_MUST_USE moq_hang_catalog_TextFormat moq_hang_catalog_TextFormat_default(void); void moq_hang_catalog_TextRole_free(moq_hang_catalog_TextRole *self); bool moq_hang_catalog_TextRole_eq(const moq_hang_catalog_TextRole *a, const moq_hang_catalog_TextRole *b); -moq_buf moq_hang_catalog_TextRole_to_string(const moq_hang_catalog_TextRole *self); -moq_buf moq_hang_catalog_TextRole_debug(const moq_hang_catalog_TextRole *self); -moq_hang_catalog_TextRole moq_hang_catalog_TextRole_default(void); +MOQ_MUST_USE moq_buf moq_hang_catalog_TextRole_to_string(const moq_hang_catalog_TextRole *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_TextRole_debug(const moq_hang_catalog_TextRole *self); +MOQ_MUST_USE moq_hang_catalog_TextRole moq_hang_catalog_TextRole_default(void); void moq_hang_catalog_VideoCodec_free(moq_hang_catalog_VideoCodec *self); bool moq_hang_catalog_VideoCodec_eq(const moq_hang_catalog_VideoCodec *a, const moq_hang_catalog_VideoCodec *b); -moq_buf moq_hang_catalog_VideoCodec_to_string(const moq_hang_catalog_VideoCodec *self); -moq_buf moq_hang_catalog_VideoCodec_debug(const moq_hang_catalog_VideoCodec *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_VideoCodec_to_string(const moq_hang_catalog_VideoCodec *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_VideoCodec_debug(const moq_hang_catalog_VideoCodec *self); moq_hang_catalog_VideoCodecKind moq_hang_catalog_VideoCodec_kind(const moq_hang_catalog_VideoCodec *self); bool moq_hang_catalog_VideoCodecKind_eq(const moq_hang_catalog_VideoCodecKind *a, const moq_hang_catalog_VideoCodecKind *b); uint64_t moq_hang_catalog_VideoCodecKind_hash(const moq_hang_catalog_VideoCodecKind *self); -moq_buf moq_hang_catalog_VideoCodecKind_debug(const moq_hang_catalog_VideoCodecKind *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_VideoCodecKind_debug(const moq_hang_catalog_VideoCodecKind *self); bool moq_hang_catalog_ColorRange_eq(const moq_hang_catalog_ColorRange *a, const moq_hang_catalog_ColorRange *b); uint64_t moq_hang_catalog_ColorRange_hash(const moq_hang_catalog_ColorRange *self); -moq_buf moq_hang_catalog_ColorRange_debug(const moq_hang_catalog_ColorRange *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_ColorRange_debug(const moq_hang_catalog_ColorRange *self); void moq_hang_catalog_Stereo_free(moq_hang_catalog_Stereo *self); bool moq_hang_catalog_Stereo_eq(const moq_hang_catalog_Stereo *a, const moq_hang_catalog_Stereo *b); -moq_buf moq_hang_catalog_Stereo_to_string(const moq_hang_catalog_Stereo *self); -moq_buf moq_hang_catalog_Stereo_debug(const moq_hang_catalog_Stereo *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_Stereo_to_string(const moq_hang_catalog_Stereo *self); +MOQ_MUST_USE moq_buf moq_hang_catalog_Stereo_debug(const moq_hang_catalog_Stereo *self); bool moq_mux_catalog_CatalogFormat_eq(const moq_mux_catalog_CatalogFormat *a, const moq_mux_catalog_CatalogFormat *b); uint64_t moq_mux_catalog_CatalogFormat_hash(const moq_mux_catalog_CatalogFormat *self); -moq_buf moq_mux_catalog_CatalogFormat_debug(const moq_mux_catalog_CatalogFormat *self); +MOQ_MUST_USE moq_buf moq_mux_catalog_CatalogFormat_debug(const moq_mux_catalog_CatalogFormat *self); moq_mux_catalog_CatalogFormat moq_mux_catalog_CatalogFormat_default(void); moq_mux_catalog_CatalogFormat moq_mux_catalog_CatalogFormat_DEFAULT(void); -moq_buf moq_mux_catalog_CatalogFormat_extension(const moq_mux_catalog_CatalogFormat *self); +MOQ_MUST_USE moq_buf moq_mux_catalog_CatalogFormat_extension(const moq_mux_catalog_CatalogFormat *self); moq_option_mux_catalog_CatalogFormat moq_mux_catalog_CatalogFormat_detect(moq_buf name); bool moq_mux_container_Kind_eq(const moq_mux_container_Kind *a, const moq_mux_container_Kind *b); -moq_buf moq_mux_container_Kind_debug(const moq_mux_container_Kind *self); +MOQ_MUST_USE moq_buf moq_mux_container_Kind_debug(const moq_mux_container_Kind *self); void moq_mux_container_Read_free(moq_mux_container_Read *self); -moq_buf moq_mux_container_Read_debug(const moq_mux_container_Read *self); +MOQ_MUST_USE moq_buf moq_mux_container_Read_debug(const moq_mux_container_Read *self); void moq_mux_container_ReorderError_free(moq_mux_container_ReorderError *self); bool moq_mux_container_ReorderError_eq(const moq_mux_container_ReorderError *a, const moq_mux_container_ReorderError *b); -moq_buf moq_mux_container_ReorderError_to_string(const moq_mux_container_ReorderError *self); -moq_buf moq_mux_container_ReorderError_debug(const moq_mux_container_ReorderError *self); +MOQ_MUST_USE moq_buf moq_mux_container_ReorderError_to_string(const moq_mux_container_ReorderError *self); +MOQ_MUST_USE moq_buf moq_mux_container_ReorderError_debug(const moq_mux_container_ReorderError *self); bool moq_mux_import_AudioFormat_eq(const moq_mux_import_AudioFormat *a, const moq_mux_import_AudioFormat *b); uint64_t moq_mux_import_AudioFormat_hash(const moq_mux_import_AudioFormat *self); -moq_buf moq_mux_import_AudioFormat_to_string(const moq_mux_import_AudioFormat *self); -moq_buf moq_mux_import_AudioFormat_debug(const moq_mux_import_AudioFormat *self); +MOQ_MUST_USE moq_buf moq_mux_import_AudioFormat_to_string(const moq_mux_import_AudioFormat *self); +MOQ_MUST_USE moq_buf moq_mux_import_AudioFormat_debug(const moq_mux_import_AudioFormat *self); bool moq_mux_import_ContainerFormat_eq(const moq_mux_import_ContainerFormat *a, const moq_mux_import_ContainerFormat *b); uint64_t moq_mux_import_ContainerFormat_hash(const moq_mux_import_ContainerFormat *self); -moq_buf moq_mux_import_ContainerFormat_to_string(const moq_mux_import_ContainerFormat *self); -moq_buf moq_mux_import_ContainerFormat_debug(const moq_mux_import_ContainerFormat *self); +MOQ_MUST_USE moq_buf moq_mux_import_ContainerFormat_to_string(const moq_mux_import_ContainerFormat *self); +MOQ_MUST_USE moq_buf moq_mux_import_ContainerFormat_debug(const moq_mux_import_ContainerFormat *self); void moq_mux_import_Format_free(moq_mux_import_Format *self); bool moq_mux_import_Format_eq(const moq_mux_import_Format *a, const moq_mux_import_Format *b); uint64_t moq_mux_import_Format_hash(const moq_mux_import_Format *self); -moq_buf moq_mux_import_Format_to_string(const moq_mux_import_Format *self); -moq_buf moq_mux_import_Format_debug(const moq_mux_import_Format *self); +MOQ_MUST_USE moq_buf moq_mux_import_Format_to_string(const moq_mux_import_Format *self); +MOQ_MUST_USE moq_buf moq_mux_import_Format_debug(const moq_mux_import_Format *self); moq_mux_import_Kind moq_mux_import_Format_kind(const moq_mux_import_Format *self); bool moq_mux_import_Kind_eq(const moq_mux_import_Kind *a, const moq_mux_import_Kind *b); uint64_t moq_mux_import_Kind_hash(const moq_mux_import_Kind *self); -moq_buf moq_mux_import_Kind_debug(const moq_mux_import_Kind *self); -moq_buf moq_mux_import_Kind_name(const moq_mux_import_Kind *self); +MOQ_MUST_USE moq_buf moq_mux_import_Kind_debug(const moq_mux_import_Kind *self); +MOQ_MUST_USE moq_buf moq_mux_import_Kind_name(const moq_mux_import_Kind *self); bool moq_mux_import_VideoFormat_eq(const moq_mux_import_VideoFormat *a, const moq_mux_import_VideoFormat *b); uint64_t moq_mux_import_VideoFormat_hash(const moq_mux_import_VideoFormat *self); -moq_buf moq_mux_import_VideoFormat_to_string(const moq_mux_import_VideoFormat *self); -moq_buf moq_mux_import_VideoFormat_debug(const moq_mux_import_VideoFormat *self); +MOQ_MUST_USE moq_buf moq_mux_import_VideoFormat_to_string(const moq_mux_import_VideoFormat *self); +MOQ_MUST_USE moq_buf moq_mux_import_VideoFormat_debug(const moq_mux_import_VideoFormat *self); void moq_mux_rate_Target_free(moq_mux_rate_Target *self); bool moq_mux_rate_Target_eq(const moq_mux_rate_Target *a, const moq_mux_rate_Target *b); -moq_buf moq_mux_rate_Target_debug(const moq_mux_rate_Target *self); +MOQ_MUST_USE moq_buf moq_mux_rate_Target_debug(const moq_mux_rate_Target *self); void moq_tokio_listen_Bind_free(moq_tokio_listen_Bind *self); bool moq_tokio_listen_Bind_eq(const moq_tokio_listen_Bind *a, const moq_tokio_listen_Bind *b); -moq_buf moq_tokio_listen_Bind_to_string(const moq_tokio_listen_Bind *self); -moq_buf moq_tokio_listen_Bind_debug(const moq_tokio_listen_Bind *self); -bool moq_tokio_listen_Bind_resolve(const moq_tokio_listen_Bind *self, moq_socket_addr *out, moq_buf *err); +MOQ_MUST_USE moq_buf moq_tokio_listen_Bind_to_string(const moq_tokio_listen_Bind *self); +MOQ_MUST_USE moq_buf moq_tokio_listen_Bind_debug(const moq_tokio_listen_Bind *self); +MOQ_MUST_USE bool moq_tokio_listen_Bind_resolve(const moq_tokio_listen_Bind *self, moq_socket_addr *out, moq_buf *err); void moq_transport_memory_Error_free(moq_transport_memory_Error *self); -moq_buf moq_transport_memory_Error_to_string(const moq_transport_memory_Error *self); -moq_buf moq_transport_memory_Error_debug(const moq_transport_memory_Error *self); +MOQ_MUST_USE moq_buf moq_transport_memory_Error_to_string(const moq_transport_memory_Error *self); +MOQ_MUST_USE moq_buf moq_transport_memory_Error_debug(const moq_transport_memory_Error *self); bool moq_transport_poll_Acked_eq(const moq_transport_poll_Acked *a, const moq_transport_poll_Acked *b); -moq_buf moq_transport_poll_Acked_debug(const moq_transport_poll_Acked *self); +MOQ_MUST_USE moq_buf moq_transport_poll_Acked_debug(const moq_transport_poll_Acked *self); void moq_mux_catalog_msf_Error_free(moq_mux_catalog_msf_Error *self); -moq_buf moq_mux_catalog_msf_Error_to_string(const moq_mux_catalog_msf_Error *self); -moq_buf moq_mux_catalog_msf_Error_debug(const moq_mux_catalog_msf_Error *self); -moq_buf moq_mux_codec_flac_Error_to_string(const moq_mux_codec_flac_Error *self); -moq_buf moq_mux_codec_flac_Error_debug(const moq_mux_codec_flac_Error *self); -moq_buf moq_mux_codec_mp3_Error_to_string(const moq_mux_codec_mp3_Error *self); -moq_buf moq_mux_codec_mp3_Error_debug(const moq_mux_codec_mp3_Error *self); +MOQ_MUST_USE moq_buf moq_mux_catalog_msf_Error_to_string(const moq_mux_catalog_msf_Error *self); +MOQ_MUST_USE moq_buf moq_mux_catalog_msf_Error_debug(const moq_mux_catalog_msf_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_flac_Error_to_string(const moq_mux_codec_flac_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_flac_Error_debug(const moq_mux_codec_flac_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_mp3_Error_to_string(const moq_mux_codec_mp3_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_mp3_Error_debug(const moq_mux_codec_mp3_Error *self); void moq_mux_codec_opus_Error_free(moq_mux_codec_opus_Error *self); -moq_buf moq_mux_codec_opus_Error_to_string(const moq_mux_codec_opus_Error *self); -moq_buf moq_mux_codec_opus_Error_debug(const moq_mux_codec_opus_Error *self); -moq_buf moq_mux_codec_vp8_Error_to_string(const moq_mux_codec_vp8_Error *self); -moq_buf moq_mux_codec_vp8_Error_debug(const moq_mux_codec_vp8_Error *self); -moq_buf moq_mux_codec_vp9_Error_to_string(const moq_mux_codec_vp9_Error *self); -moq_buf moq_mux_codec_vp9_Error_debug(const moq_mux_codec_vp9_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_opus_Error_to_string(const moq_mux_codec_opus_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_opus_Error_debug(const moq_mux_codec_opus_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_vp8_Error_to_string(const moq_mux_codec_vp8_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_vp8_Error_debug(const moq_mux_codec_vp8_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_vp9_Error_to_string(const moq_mux_codec_vp9_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_vp9_Error_debug(const moq_mux_codec_vp9_Error *self); void moq_mux_container_fmp4_Chunk_free(moq_mux_container_fmp4_Chunk *self); -moq_buf moq_mux_container_fmp4_Chunk_debug(const moq_mux_container_fmp4_Chunk *self); -moq_buf moq_mux_container_fmp4_Chunk_data(const moq_mux_container_fmp4_Chunk *self); -moq_buf moq_mux_container_fmp4_Chunk_into_data(const moq_mux_container_fmp4_Chunk *self); -moq_buf moq_mux_container_fmp4_Chunk_init(const moq_mux_container_fmp4_Chunk *self); -moq_option_mux_container_fmp4_Fragment moq_mux_container_fmp4_Chunk_fragment(const moq_mux_container_fmp4_Chunk *self); +MOQ_MUST_USE moq_buf moq_mux_container_fmp4_Chunk_debug(const moq_mux_container_fmp4_Chunk *self); +MOQ_MUST_USE moq_buf moq_mux_container_fmp4_Chunk_data(const moq_mux_container_fmp4_Chunk *self); +MOQ_MUST_USE moq_buf moq_mux_container_fmp4_Chunk_into_data(const moq_mux_container_fmp4_Chunk *self); +MOQ_MUST_USE moq_buf moq_mux_container_fmp4_Chunk_init(const moq_mux_container_fmp4_Chunk *self); +MOQ_MUST_USE moq_option_mux_container_fmp4_Fragment moq_mux_container_fmp4_Chunk_fragment(const moq_mux_container_fmp4_Chunk *self); bool moq_mux_container_ts_Framing_eq(const moq_mux_container_ts_Framing *a, const moq_mux_container_ts_Framing *b); -moq_buf moq_mux_container_ts_Framing_debug(const moq_mux_container_ts_Framing *self); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Framing_debug(const moq_mux_container_ts_Framing *self); moq_mux_container_ts_Framing moq_mux_container_ts_Framing_default(void); void moq_mux_container_ts_Step_free(moq_mux_container_ts_Step *self); bool moq_mux_container_ts_Step_eq(const moq_mux_container_ts_Step *a, const moq_mux_container_ts_Step *b); -moq_buf moq_mux_container_ts_Step_to_string(const moq_mux_container_ts_Step *self); -moq_buf moq_mux_container_ts_Step_debug(const moq_mux_container_ts_Step *self); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Step_to_string(const moq_mux_container_ts_Step *self); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Step_debug(const moq_mux_container_ts_Step *self); void moq_mux_codec_aac_adts_Error_free(moq_mux_codec_aac_adts_Error *self); bool moq_mux_codec_aac_adts_Error_eq(const moq_mux_codec_aac_adts_Error *a, const moq_mux_codec_aac_adts_Error *b); -moq_buf moq_mux_codec_aac_adts_Error_to_string(const moq_mux_codec_aac_adts_Error *self); -moq_buf moq_mux_codec_aac_adts_Error_debug(const moq_mux_codec_aac_adts_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_aac_adts_Error_to_string(const moq_mux_codec_aac_adts_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_aac_adts_Error_debug(const moq_mux_codec_aac_adts_Error *self); bool moq_mux_container_ts_stats_Class_eq(const moq_mux_container_ts_stats_Class *a, const moq_mux_container_ts_stats_Class *b); -moq_buf moq_mux_container_ts_stats_Class_debug(const moq_mux_container_ts_stats_Class *self); +MOQ_MUST_USE moq_buf moq_mux_container_ts_stats_Class_debug(const moq_mux_container_ts_stats_Class *self); moq_mux_container_ts_stats_Class moq_mux_container_ts_stats_Class_default(void); bool moq_moq_tokio_quic_CongestionControl_eq(const moq_moq_tokio_quic_CongestionControl *a, const moq_moq_tokio_quic_CongestionControl *b); uint64_t moq_moq_tokio_quic_CongestionControl_hash(const moq_moq_tokio_quic_CongestionControl *self); -moq_buf moq_moq_tokio_quic_CongestionControl_debug(const moq_moq_tokio_quic_CongestionControl *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_quic_CongestionControl_debug(const moq_moq_tokio_quic_CongestionControl *self); moq_moq_tokio_quic_CongestionControl moq_moq_tokio_quic_CongestionControl_default(void); bool moq_moq_tokio_accept_Failure_eq(const moq_moq_tokio_accept_Failure *a, const moq_moq_tokio_accept_Failure *b); uint64_t moq_moq_tokio_accept_Failure_hash(const moq_moq_tokio_accept_Failure *self); -moq_buf moq_moq_tokio_accept_Failure_to_string(const moq_moq_tokio_accept_Failure *self); -moq_buf moq_moq_tokio_accept_Failure_debug(const moq_moq_tokio_accept_Failure *self); -moq_vec_moq_tokio_accept_Failure moq_moq_tokio_accept_Failure_ALL(void); -moq_buf moq_moq_tokio_accept_Failure_as_str(const moq_moq_tokio_accept_Failure *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_accept_Failure_to_string(const moq_moq_tokio_accept_Failure *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_accept_Failure_debug(const moq_moq_tokio_accept_Failure *self); +MOQ_MUST_USE moq_vec_moq_tokio_accept_Failure moq_moq_tokio_accept_Failure_ALL(void); +MOQ_MUST_USE moq_buf moq_moq_tokio_accept_Failure_as_str(const moq_moq_tokio_accept_Failure *self); bool moq_moq_tokio_Redirect_eq(const moq_moq_tokio_Redirect *a, const moq_moq_tokio_Redirect *b); -moq_buf moq_moq_tokio_Redirect_debug(const moq_moq_tokio_Redirect *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_Redirect_debug(const moq_moq_tokio_Redirect *self); moq_moq_tokio_Redirect moq_moq_tokio_Redirect_default(void); void moq_moq_quic_Rate_free(moq_moq_quic_Rate *self); bool moq_moq_quic_Rate_eq(const moq_moq_quic_Rate *a, const moq_moq_quic_Rate *b); -moq_buf moq_moq_quic_Rate_debug(const moq_moq_quic_Rate *self); +MOQ_MUST_USE moq_buf moq_moq_quic_Rate_debug(const moq_moq_quic_Rate *self); void moq_moq_tokio_connect_Error_free(moq_moq_tokio_connect_Error *self); bool moq_moq_tokio_connect_Error_eq(const moq_moq_tokio_connect_Error *a, const moq_moq_tokio_connect_Error *b); -moq_buf moq_moq_tokio_connect_Error_to_string(const moq_moq_tokio_connect_Error *self); -moq_buf moq_moq_tokio_connect_Error_debug(const moq_moq_tokio_connect_Error *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_connect_Error_to_string(const moq_moq_tokio_connect_Error *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_connect_Error_debug(const moq_moq_tokio_connect_Error *self); void moq_rustls_ProtocolVersion_free(moq_rustls_ProtocolVersion *self); bool moq_rustls_ProtocolVersion_eq(const moq_rustls_ProtocolVersion *a, const moq_rustls_ProtocolVersion *b); -moq_buf moq_rustls_ProtocolVersion_debug(const moq_rustls_ProtocolVersion *self); +MOQ_MUST_USE moq_buf moq_rustls_ProtocolVersion_debug(const moq_rustls_ProtocolVersion *self); moq_array_u8_2 moq_rustls_ProtocolVersion_to_array(const moq_rustls_ProtocolVersion *self); -moq_buf moq_rustls_ProtocolVersion_as_str(const moq_rustls_ProtocolVersion *self); +MOQ_MUST_USE moq_buf moq_rustls_ProtocolVersion_as_str(const moq_rustls_ProtocolVersion *self); bool moq_rustls_client_Tls12Resumption_eq(const moq_rustls_client_Tls12Resumption *a, const moq_rustls_client_Tls12Resumption *b); -moq_buf moq_rustls_client_Tls12Resumption_debug(const moq_rustls_client_Tls12Resumption *self); +MOQ_MUST_USE moq_buf moq_rustls_client_Tls12Resumption_debug(const moq_rustls_client_Tls12Resumption *self); bool moq_moq_quic_connection_mux_Version_eq(const moq_moq_quic_connection_mux_Version *a, const moq_moq_quic_connection_mux_Version *b); uint64_t moq_moq_quic_connection_mux_Version_hash(const moq_moq_quic_connection_mux_Version *self); -moq_buf moq_moq_quic_connection_mux_Version_debug(const moq_moq_quic_connection_mux_Version *self); -moq_vec_moq_quic_connection_mux_Version moq_moq_quic_connection_mux_Version_ALL(void); +MOQ_MUST_USE moq_buf moq_moq_quic_connection_mux_Version_debug(const moq_moq_quic_connection_mux_Version *self); +MOQ_MUST_USE moq_vec_moq_quic_connection_mux_Version moq_moq_quic_connection_mux_Version_ALL(void); bool moq_moq_quic_connection_mux_Version_uses_records(const moq_moq_quic_connection_mux_Version *self); -moq_buf moq_moq_quic_connection_mux_Version_alpn(const moq_moq_quic_connection_mux_Version *self); -moq_buf moq_moq_quic_connection_mux_Version_prefix(const moq_moq_quic_connection_mux_Version *self); +MOQ_MUST_USE moq_buf moq_moq_quic_connection_mux_Version_alpn(const moq_moq_quic_connection_mux_Version *self); +MOQ_MUST_USE moq_buf moq_moq_quic_connection_mux_Version_prefix(const moq_moq_quic_connection_mux_Version *self); bool moq_moq_sock_demux_Discard_eq(const moq_moq_sock_demux_Discard *a, const moq_moq_sock_demux_Discard *b); -moq_buf moq_moq_sock_demux_Discard_debug(const moq_moq_sock_demux_Discard *self); -moq_vec_moq_sock_demux_Discard moq_moq_sock_demux_Discard_ALL(void); -moq_buf moq_moq_sock_demux_Discard_as_str(const moq_moq_sock_demux_Discard *self); +MOQ_MUST_USE moq_buf moq_moq_sock_demux_Discard_debug(const moq_moq_sock_demux_Discard *self); +MOQ_MUST_USE moq_vec_moq_sock_demux_Discard moq_moq_sock_demux_Discard_ALL(void); +MOQ_MUST_USE moq_buf moq_moq_sock_demux_Discard_as_str(const moq_moq_sock_demux_Discard *self); bool moq_moq_sock_udp_EcnCodepoint_eq(const moq_moq_sock_udp_EcnCodepoint *a, const moq_moq_sock_udp_EcnCodepoint *b); -moq_buf moq_moq_sock_udp_EcnCodepoint_debug(const moq_moq_sock_udp_EcnCodepoint *self); +MOQ_MUST_USE moq_buf moq_moq_sock_udp_EcnCodepoint_debug(const moq_moq_sock_udp_EcnCodepoint *self); moq_option_moq_sock_udp_EcnCodepoint moq_moq_sock_udp_EcnCodepoint_from_bits(uint8_t x); bool moq_Level_eq(const moq_Level *a, const moq_Level *b); uint64_t moq_Level_hash(const moq_Level *self); -moq_buf moq_Level_to_string(const moq_Level *self); +MOQ_MUST_USE moq_buf moq_Level_to_string(const moq_Level *self); void moq_Park_free(moq_Park *self); void moq_Park_drop(moq_Park *self, moq_status *status); -moq_Park *moq_Park_clone(const moq_Park *self, moq_status *status); -moq_buf moq_Park_debug(const moq_Park *self, moq_status *status); -moq_Park *moq_Park_default(void); -moq_Park *moq_Park_new(moq_Waiter *waiter, moq_status *status); -moq_Waiter *moq_Park_hold(moq_Park *self, moq_waker cx, moq_status *status); +MOQ_MUST_USE moq_Park *moq_Park_clone(const moq_Park *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Park_debug(const moq_Park *self, moq_status *status); +MOQ_MUST_USE moq_Park *moq_Park_default(void); +MOQ_MUST_USE moq_Park *moq_Park_new(moq_Waiter *waiter, moq_status *status); +MOQ_MUST_USE moq_Waiter *moq_Park_hold(moq_Park *self, moq_waker cx, moq_status *status); void moq_Waiter_free(moq_Waiter *self); void moq_Waiter_drop(moq_Waiter *self, moq_status *status); -moq_Waiter *moq_Waiter_clone(const moq_Waiter *self, moq_status *status); -moq_Waiter *moq_Waiter_new(moq_waker waker_); -moq_Waiter *moq_Waiter_noop(void); +MOQ_MUST_USE moq_Waiter *moq_Waiter_clone(const moq_Waiter *self, moq_status *status); +MOQ_MUST_USE moq_Waiter *moq_Waiter_new(moq_waker waker_); +MOQ_MUST_USE moq_Waiter *moq_Waiter_noop(void); void moq_Waiter_register(const moq_Waiter *self, moq_WaiterList *list, moq_status *status); -moq_waker moq_Waiter_waker(const moq_Waiter *self, moq_status *status); -moq_waker moq_Waiter_context(const moq_Waiter *self, moq_status *status); -moq_buf moq_Waiter_batch(const moq_Waiter *self, moq_buf (*poll)(void *data), void *poll_data, moq_status *status); +MOQ_MUST_USE moq_waker moq_Waiter_waker(const moq_Waiter *self, moq_status *status); +MOQ_MUST_USE moq_waker moq_Waiter_context(const moq_Waiter *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Waiter_batch(const moq_Waiter *self, moq_buf (*poll)(void *data), void *poll_data, moq_status *status); typedef struct moq_Waiter_poll_future_future moq_Waiter_poll_future_future; -moq_Waiter_poll_future_future *moq_Waiter_poll_future(moq_foreign_future future_); -moq_poll moq_Waiter_poll_future_start(moq_foreign_future future_, moq_Waiter_poll_future_future **future); -moq_poll moq_Waiter_poll_future_poll(moq_Waiter_poll_future_future *future, moq_waker waker); +MOQ_MUST_USE moq_Waiter_poll_future_future *moq_Waiter_poll_future(moq_foreign_future future_); +MOQ_MUST_USE moq_poll moq_Waiter_poll_future_start(moq_foreign_future future_, moq_Waiter_poll_future_future **future); +MOQ_MUST_USE moq_poll moq_Waiter_poll_future_poll(moq_Waiter_poll_future_future *future, moq_waker waker); void moq_Waiter_poll_future_future_free(moq_Waiter_poll_future_future *future); void moq_WaiterList_free(moq_WaiterList *self); void moq_WaiterList_drop(moq_WaiterList *self, moq_status *status); -moq_buf moq_WaiterList_debug(const moq_WaiterList *self, moq_status *status); -moq_WaiterList *moq_WaiterList_default(void); -moq_WaiterList *moq_WaiterList_new(void); +MOQ_MUST_USE moq_buf moq_WaiterList_debug(const moq_WaiterList *self, moq_status *status); +MOQ_MUST_USE moq_WaiterList *moq_WaiterList_default(void); +MOQ_MUST_USE moq_WaiterList *moq_WaiterList_new(void); void moq_WaiterList_register(moq_WaiterList *self, const moq_Waiter *waiter, moq_status *status); -moq_WaiterList *moq_WaiterList_take(moq_WaiterList *self, moq_status *status); +MOQ_MUST_USE moq_WaiterList *moq_WaiterList_take(moq_WaiterList *self, moq_status *status); bool moq_WaiterList_is_empty(const moq_WaiterList *self, moq_status *status); void moq_WaiterList_wake(moq_WaiterList *self, moq_status *status); void moq_DecodeError_free(moq_DecodeError *self); bool moq_DecodeError_borrowed(const moq_DecodeError *self); -moq_DecodeError *moq_DecodeError_clone(const moq_DecodeError *self); -moq_buf moq_DecodeError_to_string(const moq_DecodeError *self); -moq_buf moq_DecodeError_debug(const moq_DecodeError *self); +MOQ_MUST_USE moq_DecodeError *moq_DecodeError_clone(const moq_DecodeError *self); +MOQ_MUST_USE moq_buf moq_DecodeError_to_string(const moq_DecodeError *self); +MOQ_MUST_USE moq_buf moq_DecodeError_debug(const moq_DecodeError *self); void moq_Driver_free(moq_Driver *self); void moq_Driver_drop(moq_Driver *self, moq_status *status); -moq_buf moq_Driver_debug(const moq_Driver *self, moq_status *status); -bool moq_Driver_poll(moq_Driver *self, moq_clock_Instant now, const moq_Waiter *waiter, moq_option_clock_Instant *out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_Driver_debug(const moq_Driver *self, moq_status *status); +MOQ_MUST_USE bool moq_Driver_poll(moq_Driver *self, moq_clock_Instant now, const moq_Waiter *waiter, moq_option_clock_Instant *out, moq_Error **err, moq_status *status); void moq_Instance_free(moq_Instance *self); void moq_Instance_drop(moq_Instance *self, moq_status *status); bool moq_Instance_borrowed(const moq_Instance *self); -moq_Instance *moq_Instance_clone(const moq_Instance *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_Instance_clone(const moq_Instance *self, moq_status *status); bool moq_Instance_eq(const moq_Instance *a, const moq_Instance *b, moq_status *status); uint64_t moq_Instance_hash(const moq_Instance *self, moq_status *status); -moq_buf moq_Instance_to_string(const moq_Instance *self, moq_status *status); -moq_buf moq_Instance_debug(const moq_Instance *self, moq_status *status); -moq_Instance *moq_Instance_random(void); -moq_buf moq_Instance_as_str(const moq_Instance *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Instance_to_string(const moq_Instance *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Instance_debug(const moq_Instance *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_Instance_random(void); +MOQ_MUST_USE moq_buf moq_Instance_as_str(const moq_Instance *self, moq_status *status); bool moq_Instance_is_minted(const moq_Instance *self, moq_status *status); void moq_Path_free(moq_Path *self); void moq_Path_drop(moq_Path *self, moq_status *status); bool moq_Path_borrowed(const moq_Path *self); -moq_Path *moq_Path_clone(const moq_Path *self, moq_status *status); +MOQ_MUST_USE moq_Path *moq_Path_clone(const moq_Path *self, moq_status *status); bool moq_Path_eq(const moq_Path *a, const moq_Path *b, moq_status *status); uint64_t moq_Path_hash(const moq_Path *self, moq_status *status); -moq_buf moq_Path_to_string(const moq_Path *self, moq_status *status); -moq_buf moq_Path_debug(const moq_Path *self, moq_status *status); -moq_Path *moq_Path_default(void); -bool moq_Path_new(moq_buf s, moq_Path **out, moq_path_Error *err); -moq_Path *moq_Path_from_static(moq_buf s); +MOQ_MUST_USE moq_buf moq_Path_to_string(const moq_Path *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Path_debug(const moq_Path *self, moq_status *status); +MOQ_MUST_USE moq_Path *moq_Path_default(void); +MOQ_MUST_USE bool moq_Path_new(moq_buf s, moq_Path **out, moq_path_Error *err); +MOQ_MUST_USE moq_Path *moq_Path_from_static(moq_buf s); bool moq_Path_has_prefix(const moq_Path *self, const moq_Path *prefix, moq_status *status); -moq_Path *moq_Path_strip_prefix(const moq_Path *self, const moq_Path *prefix, moq_status *status); -moq_Path *moq_Path_head(const moq_Path *self, size_t n, moq_status *status); -moq_buf moq_Path_as_str(const moq_Path *self, moq_status *status); -moq_Path *moq_Path_empty(void); +MOQ_MUST_USE moq_Path *moq_Path_strip_prefix(const moq_Path *self, const moq_Path *prefix, moq_status *status); +MOQ_MUST_USE moq_Path *moq_Path_head(const moq_Path *self, size_t n, moq_status *status); +MOQ_MUST_USE moq_buf moq_Path_as_str(const moq_Path *self, moq_status *status); +MOQ_MUST_USE moq_Path *moq_Path_empty(void); bool moq_Path_is_empty(const moq_Path *self, moq_status *status); size_t moq_Path_len(const moq_Path *self, moq_status *status); -bool moq_Path_join(const moq_Path *self, const moq_Path *other, moq_Path **out, moq_path_Error *err, moq_status *status); -bool moq_Path_resolve(const moq_Path *self, const moq_path_Relative *rel, moq_Path **out, moq_path_Error *err, moq_status *status); -moq_Path *moq_Path_try_resolve(const moq_Path *self, const moq_path_Relative *rel, moq_status *status); -moq_path_Relative *moq_Path_relative(const moq_Path *self, const moq_Path *base, moq_status *status); +MOQ_MUST_USE bool moq_Path_join(const moq_Path *self, const moq_Path *other, moq_Path **out, moq_path_Error *err, moq_status *status); +MOQ_MUST_USE bool moq_Path_resolve(const moq_Path *self, const moq_path_Relative *rel, moq_Path **out, moq_path_Error *err, moq_status *status); +MOQ_MUST_USE moq_Path *moq_Path_try_resolve(const moq_Path *self, const moq_path_Relative *rel, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_Path_relative(const moq_Path *self, const moq_Path *base, moq_status *status); void moq_Pattern_free(moq_Pattern *self); void moq_Pattern_drop(moq_Pattern *self, moq_status *status); bool moq_Pattern_borrowed(const moq_Pattern *self); -moq_Pattern *moq_Pattern_clone(const moq_Pattern *self, moq_status *status); +MOQ_MUST_USE moq_Pattern *moq_Pattern_clone(const moq_Pattern *self, moq_status *status); bool moq_Pattern_eq(const moq_Pattern *a, const moq_Pattern *b, moq_status *status); uint64_t moq_Pattern_hash(const moq_Pattern *self, moq_status *status); -moq_buf moq_Pattern_to_string(const moq_Pattern *self, moq_status *status); -moq_buf moq_Pattern_debug(const moq_Pattern *self, moq_status *status); -moq_Pattern *moq_Pattern_default(void); -bool moq_Pattern_new(moq_vec_Segment segments, moq_Pattern **out, moq_InvalidPattern *err); -moq_Pattern *moq_Pattern_all(void); -bool moq_Pattern_literal(moq_buf path, moq_Pattern **out, moq_InvalidPattern *err); -bool moq_Pattern_subtree(moq_buf path, moq_Pattern **out, moq_InvalidPattern *err); -moq_buf moq_Pattern_as_str(const moq_Pattern *self, moq_status *status); -moq_vec_Segment moq_Pattern_segments(const moq_Pattern *self, moq_status *status); -moq_buf moq_Pattern_head(const moq_Pattern *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Pattern_to_string(const moq_Pattern *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Pattern_debug(const moq_Pattern *self, moq_status *status); +MOQ_MUST_USE moq_Pattern *moq_Pattern_default(void); +MOQ_MUST_USE bool moq_Pattern_new(moq_vec_Segment segments, moq_Pattern **out, moq_InvalidPattern *err); +MOQ_MUST_USE moq_Pattern *moq_Pattern_all(void); +MOQ_MUST_USE bool moq_Pattern_literal(moq_buf path, moq_Pattern **out, moq_InvalidPattern *err); +MOQ_MUST_USE bool moq_Pattern_subtree(moq_buf path, moq_Pattern **out, moq_InvalidPattern *err); +MOQ_MUST_USE moq_buf moq_Pattern_as_str(const moq_Pattern *self, moq_status *status); +MOQ_MUST_USE moq_vec_Segment moq_Pattern_segments(const moq_Pattern *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Pattern_head(const moq_Pattern *self, moq_status *status); bool moq_Pattern_is_literal(const moq_Pattern *self, moq_status *status); -moq_buf moq_Pattern_as_prefix(const moq_Pattern *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Pattern_as_prefix(const moq_Pattern *self, moq_status *status); bool moq_Pattern_has_globstar(const moq_Pattern *self, moq_status *status); bool moq_Pattern_matches(const moq_Pattern *self, moq_buf path, moq_status *status); bool moq_Pattern_contains(const moq_Pattern *self, const moq_Pattern *other, moq_status *status); bool moq_Pattern_overlaps(const moq_Pattern *self, const moq_Pattern *other, moq_status *status); -moq_Specificity *moq_Pattern_specificity(const moq_Pattern *self, moq_status *status); -moq_Patterns *moq_Pattern_rebase(const moq_Pattern *self, moq_buf root, moq_status *status); -bool moq_Pattern_intersect(const moq_Pattern *self, const moq_Pattern *other, moq_Patterns **out, moq_IntersectionError *err, moq_status *status); -moq_vec_Pattern moq_Pattern_captures(const moq_Pattern *self, const moq_Pattern *matched, moq_status *status); -bool moq_Pattern_rooted(const moq_Pattern *self, moq_buf root, moq_Pattern **out, moq_InvalidPattern *err, moq_status *status); +MOQ_MUST_USE moq_Specificity *moq_Pattern_specificity(const moq_Pattern *self, moq_status *status); +MOQ_MUST_USE moq_Patterns *moq_Pattern_rebase(const moq_Pattern *self, moq_buf root, moq_status *status); +MOQ_MUST_USE bool moq_Pattern_intersect(const moq_Pattern *self, const moq_Pattern *other, moq_Patterns **out, moq_IntersectionError *err, moq_status *status); +MOQ_MUST_USE moq_vec_Pattern moq_Pattern_captures(const moq_Pattern *self, const moq_Pattern *matched, moq_status *status); +MOQ_MUST_USE bool moq_Pattern_rooted(const moq_Pattern *self, moq_buf root, moq_Pattern **out, moq_InvalidPattern *err, moq_status *status); void moq_Patterns_free(moq_Patterns *self); void moq_Patterns_drop(moq_Patterns *self, moq_status *status); -moq_Patterns *moq_Patterns_clone(const moq_Patterns *self, moq_status *status); +MOQ_MUST_USE moq_Patterns *moq_Patterns_clone(const moq_Patterns *self, moq_status *status); bool moq_Patterns_eq(const moq_Patterns *a, const moq_Patterns *b, moq_status *status); uint64_t moq_Patterns_hash(const moq_Patterns *self, moq_status *status); -moq_buf moq_Patterns_debug(const moq_Patterns *self, moq_status *status); -moq_Patterns *moq_Patterns_default(void); -moq_Patterns *moq_Patterns_new(void); +MOQ_MUST_USE moq_buf moq_Patterns_debug(const moq_Patterns *self, moq_status *status); +MOQ_MUST_USE moq_Patterns *moq_Patterns_default(void); +MOQ_MUST_USE moq_Patterns *moq_Patterns_new(void); bool moq_Patterns_insert(moq_Patterns *self, moq_Pattern *pattern, moq_status *status); bool moq_Patterns_matches(const moq_Patterns *self, moq_buf path, moq_status *status); bool moq_Patterns_contains(const moq_Patterns *self, const moq_Pattern *pattern, moq_status *status); bool moq_Patterns_covers(const moq_Patterns *self, const moq_Patterns *other, moq_status *status); bool moq_Patterns_overlaps(const moq_Patterns *self, const moq_Pattern *pattern, moq_status *status); -bool moq_Patterns_intersect(const moq_Patterns *self, const moq_Patterns *other, moq_Patterns **out, moq_IntersectionError *err, moq_status *status); -moq_Patterns *moq_Patterns_rebase(const moq_Patterns *self, moq_buf root, moq_status *status); -bool moq_Patterns_rooted(const moq_Patterns *self, moq_buf root, moq_Patterns **out, moq_InvalidPattern *err, moq_status *status); -moq_vec_Pattern moq_Patterns_iter(const moq_Patterns *self, moq_status *status); +MOQ_MUST_USE bool moq_Patterns_intersect(const moq_Patterns *self, const moq_Patterns *other, moq_Patterns **out, moq_IntersectionError *err, moq_status *status); +MOQ_MUST_USE moq_Patterns *moq_Patterns_rebase(const moq_Patterns *self, moq_buf root, moq_status *status); +MOQ_MUST_USE bool moq_Patterns_rooted(const moq_Patterns *self, moq_buf root, moq_Patterns **out, moq_InvalidPattern *err, moq_status *status); +MOQ_MUST_USE moq_vec_Pattern moq_Patterns_iter(const moq_Patterns *self, moq_status *status); size_t moq_Patterns_len(const moq_Patterns *self, moq_status *status); bool moq_Patterns_is_empty(const moq_Patterns *self, moq_status *status); void moq_Server_free(moq_Server *self); void moq_Server_drop(moq_Server *self, moq_status *status); -moq_Server *moq_Server_clone(const moq_Server *self, moq_status *status); -moq_Server *moq_Server_default(void); -moq_Server *moq_Server_new(void); -moq_Server *moq_Server_with_publisher_Producer(moq_Server *self, const moq_origin_Producer *publish, moq_status *status); -moq_Server *moq_Server_with_publisher_Consumer(moq_Server *self, const moq_origin_Consumer *publish, moq_status *status); -moq_Server *moq_Server_with_subscriber(moq_Server *self, moq_origin_Producer *subscribe, moq_status *status); -moq_Server *moq_Server_with_allocator(moq_Server *self, moq_bandwidth_Allocator *allocator, moq_status *status); -moq_Server *moq_Server_with_stats(moq_Server *self, moq_stats_Session *stats, moq_status *status); -moq_Server *moq_Server_with_limits(moq_Server *self, moq_session_Limits limits, moq_status *status); -moq_Server *moq_Server_with_versions(moq_Server *self, moq_Versions *versions, moq_status *status); -moq_Server *moq_Server_with_implementation(moq_Server *self, moq_buf implementation, moq_status *status); -moq_Server *moq_Server_with_timeout(moq_Server *self, moq_option_duration timeout, moq_status *status); +MOQ_MUST_USE moq_Server *moq_Server_clone(const moq_Server *self, moq_status *status); +MOQ_MUST_USE moq_Server *moq_Server_default(void); +MOQ_MUST_USE moq_Server *moq_Server_new(void); +MOQ_MUST_USE moq_Server *moq_Server_with_publisher_Producer(moq_Server *self, const moq_origin_Producer *publish, moq_status *status); +MOQ_MUST_USE moq_Server *moq_Server_with_publisher_Consumer(moq_Server *self, const moq_origin_Consumer *publish, moq_status *status); +MOQ_MUST_USE moq_Server *moq_Server_with_subscriber(moq_Server *self, moq_origin_Producer *subscribe, moq_status *status); +MOQ_MUST_USE moq_Server *moq_Server_with_allocator(moq_Server *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_Server *moq_Server_with_stats(moq_Server *self, moq_stats_Session *stats, moq_status *status); +MOQ_MUST_USE moq_Server *moq_Server_with_limits(moq_Server *self, moq_session_Limits limits, moq_status *status); +MOQ_MUST_USE moq_Server *moq_Server_with_versions(moq_Server *self, moq_Versions *versions, moq_status *status); +MOQ_MUST_USE moq_Server *moq_Server_with_implementation(moq_Server *self, moq_buf implementation, moq_status *status); +MOQ_MUST_USE moq_Server *moq_Server_with_timeout(moq_Server *self, moq_option_duration timeout, moq_status *status); moq_option_clock_Instant moq_Server_deadline(const moq_Server *self, moq_clock_Instant arrived, moq_status *status); -moq_Server *moq_Server_with_receive_window(moq_Server *self, uint64_t window, moq_status *status); +MOQ_MUST_USE moq_Server *moq_Server_with_receive_window(moq_Server *self, uint64_t window, moq_status *status); typedef struct moq_Server_accept_memory_Session_future moq_Server_accept_memory_Session_future; -moq_Server_accept_memory_Session_future *moq_Server_accept_memory_Session(const moq_Server *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_status *status); -moq_poll moq_Server_accept_memory_Session_start(const moq_Server *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_Session **out0, moq_Driver **out1, moq_Error **err, moq_Server_accept_memory_Session_future **future, moq_status *status); -moq_poll moq_Server_accept_memory_Session_poll(moq_Server_accept_memory_Session_future *future, moq_waker waker, moq_Session **out0, moq_Driver **out1, moq_Error **err); +MOQ_MUST_USE moq_Server_accept_memory_Session_future *moq_Server_accept_memory_Session(const moq_Server *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_status *status); +MOQ_MUST_USE moq_poll moq_Server_accept_memory_Session_start(const moq_Server *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_Session **out0, moq_Driver **out1, moq_Error **err, moq_Server_accept_memory_Session_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_Server_accept_memory_Session_poll(moq_Server_accept_memory_Session_future *future, moq_waker waker, moq_Session **out0, moq_Driver **out1, moq_Error **err); void moq_Server_accept_memory_Session_future_free(moq_Server_accept_memory_Session_future *future); typedef struct moq_Server_accept_qmux_Session_future moq_Server_accept_qmux_Session_future; -moq_Server_accept_qmux_Session_future *moq_Server_accept_qmux_Session(const moq_Server *self, moq_clock_Instant now, moq_qmux_Session *session, moq_status *status); -moq_poll moq_Server_accept_qmux_Session_start(const moq_Server *self, moq_clock_Instant now, moq_qmux_Session *session, moq_Session **out0, moq_Driver **out1, moq_Error **err, moq_Server_accept_qmux_Session_future **future, moq_status *status); -moq_poll moq_Server_accept_qmux_Session_poll(moq_Server_accept_qmux_Session_future *future, moq_waker waker, moq_Session **out0, moq_Driver **out1, moq_Error **err); +MOQ_MUST_USE moq_Server_accept_qmux_Session_future *moq_Server_accept_qmux_Session(const moq_Server *self, moq_clock_Instant now, moq_qmux_Session *session, moq_status *status); +MOQ_MUST_USE moq_poll moq_Server_accept_qmux_Session_start(const moq_Server *self, moq_clock_Instant now, moq_qmux_Session *session, moq_Session **out0, moq_Driver **out1, moq_Error **err, moq_Server_accept_qmux_Session_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_Server_accept_qmux_Session_poll(moq_Server_accept_qmux_Session_future *future, moq_waker waker, moq_Session **out0, moq_Driver **out1, moq_Error **err); void moq_Server_accept_qmux_Session_future_free(moq_Server_accept_qmux_Session_future *future); typedef struct moq_Server_handshake_memory_Session_future moq_Server_handshake_memory_Session_future; -moq_Server_handshake_memory_Session_future *moq_Server_handshake_memory_Session(const moq_Server *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_status *status); -moq_poll moq_Server_handshake_memory_Session_start(const moq_Server *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_server_Handshake **out, moq_Error **err, moq_Server_handshake_memory_Session_future **future, moq_status *status); -moq_poll moq_Server_handshake_memory_Session_poll(moq_Server_handshake_memory_Session_future *future, moq_waker waker, moq_server_Handshake **out, moq_Error **err); +MOQ_MUST_USE moq_Server_handshake_memory_Session_future *moq_Server_handshake_memory_Session(const moq_Server *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_status *status); +MOQ_MUST_USE moq_poll moq_Server_handshake_memory_Session_start(const moq_Server *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_server_Handshake **out, moq_Error **err, moq_Server_handshake_memory_Session_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_Server_handshake_memory_Session_poll(moq_Server_handshake_memory_Session_future *future, moq_waker waker, moq_server_Handshake **out, moq_Error **err); void moq_Server_handshake_memory_Session_future_free(moq_Server_handshake_memory_Session_future *future); typedef struct moq_Server_handshake_qmux_Session_future moq_Server_handshake_qmux_Session_future; -moq_Server_handshake_qmux_Session_future *moq_Server_handshake_qmux_Session(const moq_Server *self, moq_clock_Instant now, moq_qmux_Session *session, moq_status *status); -moq_poll moq_Server_handshake_qmux_Session_start(const moq_Server *self, moq_clock_Instant now, moq_qmux_Session *session, moq_server_Handshake **out, moq_Error **err, moq_Server_handshake_qmux_Session_future **future, moq_status *status); -moq_poll moq_Server_handshake_qmux_Session_poll(moq_Server_handshake_qmux_Session_future *future, moq_waker waker, moq_server_Handshake **out, moq_Error **err); +MOQ_MUST_USE moq_Server_handshake_qmux_Session_future *moq_Server_handshake_qmux_Session(const moq_Server *self, moq_clock_Instant now, moq_qmux_Session *session, moq_status *status); +MOQ_MUST_USE moq_poll moq_Server_handshake_qmux_Session_start(const moq_Server *self, moq_clock_Instant now, moq_qmux_Session *session, moq_server_Handshake **out, moq_Error **err, moq_Server_handshake_qmux_Session_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_Server_handshake_qmux_Session_poll(moq_Server_handshake_qmux_Session_future *future, moq_waker waker, moq_server_Handshake **out, moq_Error **err); void moq_Server_handshake_qmux_Session_future_free(moq_Server_handshake_qmux_Session_future *future); void moq_Session_free(moq_Session *self); void moq_Session_drop(moq_Session *self, moq_status *status); -moq_Session *moq_Session_clone(const moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_Session *moq_Session_clone(const moq_Session *self, moq_status *status); bool moq_Session_eq(const moq_Session *a, const moq_Session *b, moq_status *status); -moq_buf moq_Session_debug(const moq_Session *self, moq_status *status); -moq_Version *moq_Session_version(const moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Session_debug(const moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_Version *moq_Session_version(const moq_Session *self, moq_status *status); typedef struct moq_Session_peer_implementation_future moq_Session_peer_implementation_future; -moq_Session_peer_implementation_future *moq_Session_peer_implementation(const moq_Session *self, moq_status *status); -moq_poll moq_Session_peer_implementation_start(const moq_Session *self, moq_buf *out, moq_Session_peer_implementation_future **future, moq_status *status); -moq_poll moq_Session_peer_implementation_poll(moq_Session_peer_implementation_future *future, moq_waker waker, moq_buf *out); +MOQ_MUST_USE moq_Session_peer_implementation_future *moq_Session_peer_implementation(const moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_Session_peer_implementation_start(const moq_Session *self, moq_buf *out, moq_Session_peer_implementation_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_Session_peer_implementation_poll(moq_Session_peer_implementation_future *future, moq_waker waker, moq_buf *out); void moq_Session_peer_implementation_future_free(moq_Session_peer_implementation_future *future); -moq_bandwidth_Consumer *moq_Session_send_bandwidth(const moq_Session *self, moq_status *status); -moq_bandwidth_Allocator *moq_Session_allocator(const moq_Session *self, moq_status *status); -moq_bandwidth_Consumer *moq_Session_recv_bandwidth(const moq_Session *self, moq_status *status); -moq_bandwidth_Viewers *moq_Session_viewers(const moq_Session *self, moq_status *status); -moq_session_Stats *moq_Session_stats(const moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Consumer *moq_Session_send_bandwidth(const moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Allocator *moq_Session_allocator(const moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Consumer *moq_Session_recv_bandwidth(const moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Viewers *moq_Session_viewers(const moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_session_Stats *moq_Session_stats(const moq_Session *self, moq_status *status); void moq_Session_abort(const moq_Session *self, moq_Error *err_, moq_status *status); typedef struct moq_Session_close_future moq_Session_close_future; -moq_Session_close_future *moq_Session_close(moq_Session *self, moq_status *status); -moq_poll moq_Session_close_start(moq_Session *self, moq_Error **err, moq_Session_close_future **future, moq_status *status); -moq_poll moq_Session_close_poll(moq_Session_close_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_Session_close_future *moq_Session_close(moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_Session_close_start(moq_Session *self, moq_Error **err, moq_Session_close_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_Session_close_poll(moq_Session_close_future *future, moq_waker waker, moq_Error **err); void moq_Session_close_future_free(moq_Session_close_future *future); typedef struct moq_Session_closed_future moq_Session_closed_future; -moq_Session_closed_future *moq_Session_closed(const moq_Session *self, moq_status *status); -moq_poll moq_Session_closed_start(const moq_Session *self, moq_Error **out, moq_Session_closed_future **future, moq_status *status); -moq_poll moq_Session_closed_poll(moq_Session_closed_future *future, moq_waker waker, moq_Error **out); +MOQ_MUST_USE moq_Session_closed_future *moq_Session_closed(const moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_Session_closed_start(const moq_Session *self, moq_Error **out, moq_Session_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_Session_closed_poll(moq_Session_closed_future *future, moq_waker waker, moq_Error **out); void moq_Session_closed_future_free(moq_Session_closed_future *future); -bool moq_Session_goaway(const moq_Session *self, moq_goaway_Goaway *goaway, moq_Error **err, moq_status *status); -moq_goaway_Consumer *moq_Session_draining(const moq_Session *self, moq_status *status); -moq_auth_Handle *moq_Session_auth(const moq_Session *self, moq_status *status); +MOQ_MUST_USE bool moq_Session_goaway(const moq_Session *self, moq_goaway_Goaway *goaway, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_goaway_Consumer *moq_Session_draining(const moq_Session *self, moq_status *status); +MOQ_MUST_USE moq_auth_Handle *moq_Session_auth(const moq_Session *self, moq_status *status); void moq_Client_free(moq_Client *self); void moq_Client_drop(moq_Client *self, moq_status *status); -moq_Client *moq_Client_clone(const moq_Client *self, moq_status *status); -moq_Client *moq_Client_default(void); -moq_Client *moq_Client_new(void); -moq_Client *moq_Client_with_publisher_Producer(moq_Client *self, const moq_origin_Producer *publish, moq_status *status); -moq_Client *moq_Client_with_publisher_Consumer(moq_Client *self, const moq_origin_Consumer *publish, moq_status *status); -moq_Client *moq_Client_with_subscriber(moq_Client *self, moq_origin_Producer *subscribe, moq_status *status); -moq_Client *moq_Client_with_stats(moq_Client *self, moq_stats_Session *stats, moq_status *status); -moq_Client *moq_Client_with_limits(moq_Client *self, moq_session_Limits limits, moq_status *status); -moq_Client *moq_Client_with_allocator(moq_Client *self, moq_bandwidth_Allocator *allocator, moq_status *status); -moq_Client *moq_Client_with_viewers(moq_Client *self, moq_bandwidth_Viewers *viewers, moq_status *status); -moq_Client *moq_Client_with_versions(moq_Client *self, moq_Versions *versions, moq_status *status); -moq_Client *moq_Client_with_url(moq_Client *self, moq_Url *url, moq_status *status); -moq_Url *moq_Client_url(const moq_Client *self, moq_status *status); -moq_Client *moq_Client_with_token(moq_Client *self, moq_setup_Token token, moq_status *status); -moq_Client *moq_Client_with_auth(moq_Client *self, moq_auth_Handle *auth, moq_status *status); -moq_Client *moq_Client_with_implementation(moq_Client *self, moq_buf implementation, moq_status *status); -moq_Client *moq_Client_with_cost(moq_Client *self, moq_origin_Cost cost, moq_status *status); -moq_Client *moq_Client_with_peer_node(moq_Client *self, uint64_t node, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_clone(const moq_Client *self, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_default(void); +MOQ_MUST_USE moq_Client *moq_Client_new(void); +MOQ_MUST_USE moq_Client *moq_Client_with_publisher_Producer(moq_Client *self, const moq_origin_Producer *publish, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_publisher_Consumer(moq_Client *self, const moq_origin_Consumer *publish, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_subscriber(moq_Client *self, moq_origin_Producer *subscribe, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_stats(moq_Client *self, moq_stats_Session *stats, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_limits(moq_Client *self, moq_session_Limits limits, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_allocator(moq_Client *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_viewers(moq_Client *self, moq_bandwidth_Viewers *viewers, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_versions(moq_Client *self, moq_Versions *versions, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_url(moq_Client *self, moq_Url *url, moq_status *status); +MOQ_MUST_USE moq_Url *moq_Client_url(const moq_Client *self, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_token(moq_Client *self, moq_setup_Token token, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_auth(moq_Client *self, moq_auth_Handle *auth, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_implementation(moq_Client *self, moq_buf implementation, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_cost(moq_Client *self, moq_origin_Cost cost, moq_status *status); +MOQ_MUST_USE moq_Client *moq_Client_with_peer_node(moq_Client *self, uint64_t node, moq_status *status); typedef struct moq_Client_connect_memory_Session_future moq_Client_connect_memory_Session_future; -moq_Client_connect_memory_Session_future *moq_Client_connect_memory_Session(const moq_Client *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_status *status); -moq_poll moq_Client_connect_memory_Session_start(const moq_Client *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_Session **out0, moq_Driver **out1, moq_Error **err, moq_Client_connect_memory_Session_future **future, moq_status *status); -moq_poll moq_Client_connect_memory_Session_poll(moq_Client_connect_memory_Session_future *future, moq_waker waker, moq_Session **out0, moq_Driver **out1, moq_Error **err); +MOQ_MUST_USE moq_Client_connect_memory_Session_future *moq_Client_connect_memory_Session(const moq_Client *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_status *status); +MOQ_MUST_USE moq_poll moq_Client_connect_memory_Session_start(const moq_Client *self, moq_clock_Instant now, moq_transport_memory_Session *session, moq_Session **out0, moq_Driver **out1, moq_Error **err, moq_Client_connect_memory_Session_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_Client_connect_memory_Session_poll(moq_Client_connect_memory_Session_future *future, moq_waker waker, moq_Session **out0, moq_Driver **out1, moq_Error **err); void moq_Client_connect_memory_Session_future_free(moq_Client_connect_memory_Session_future *future); typedef struct moq_Client_connect_qmux_Session_future moq_Client_connect_qmux_Session_future; -moq_Client_connect_qmux_Session_future *moq_Client_connect_qmux_Session(const moq_Client *self, moq_clock_Instant now, moq_qmux_Session *session, moq_status *status); -moq_poll moq_Client_connect_qmux_Session_start(const moq_Client *self, moq_clock_Instant now, moq_qmux_Session *session, moq_Session **out0, moq_Driver **out1, moq_Error **err, moq_Client_connect_qmux_Session_future **future, moq_status *status); -moq_poll moq_Client_connect_qmux_Session_poll(moq_Client_connect_qmux_Session_future *future, moq_waker waker, moq_Session **out0, moq_Driver **out1, moq_Error **err); +MOQ_MUST_USE moq_Client_connect_qmux_Session_future *moq_Client_connect_qmux_Session(const moq_Client *self, moq_clock_Instant now, moq_qmux_Session *session, moq_status *status); +MOQ_MUST_USE moq_poll moq_Client_connect_qmux_Session_start(const moq_Client *self, moq_clock_Instant now, moq_qmux_Session *session, moq_Session **out0, moq_Driver **out1, moq_Error **err, moq_Client_connect_qmux_Session_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_Client_connect_qmux_Session_poll(moq_Client_connect_qmux_Session_future *future, moq_waker waker, moq_Session **out0, moq_Driver **out1, moq_Error **err); void moq_Client_connect_qmux_Session_future_free(moq_Client_connect_qmux_Session_future *future); void moq_Error_free(moq_Error *self); void moq_Error_drop(moq_Error *self, moq_status *status); bool moq_Error_borrowed(const moq_Error *self); -moq_Error *moq_Error_clone(const moq_Error *self, moq_status *status); -moq_buf moq_Error_to_string(const moq_Error *self, moq_status *status); -moq_buf moq_Error_debug(const moq_Error *self, moq_status *status); +MOQ_MUST_USE moq_Error *moq_Error_clone(const moq_Error *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Error_to_string(const moq_Error *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Error_debug(const moq_Error *self, moq_status *status); moq_option_SessionError moq_Error_session(const moq_Error *self, moq_status *status); moq_option_StreamError moq_Error_stream(const moq_Error *self, moq_status *status); -moq_Error *moq_Error_from_transport_Error(moq_Error *err_, moq_status *status); -moq_Error *moq_Error_from_transport_memory_Error(moq_transport_memory_Error err_); +MOQ_MUST_USE moq_Error *moq_Error_from_transport_Error(moq_Error *err_, moq_status *status); +MOQ_MUST_USE moq_Error *moq_Error_from_transport_memory_Error(moq_transport_memory_Error err_); moq_Retry moq_Error_retry(const moq_Error *self, moq_status *status); void moq_Version_free(moq_Version *self); bool moq_Version_borrowed(const moq_Version *self); -moq_Version *moq_Version_clone(const moq_Version *self); +MOQ_MUST_USE moq_Version *moq_Version_clone(const moq_Version *self); bool moq_Version_eq(const moq_Version *a, const moq_Version *b); uint64_t moq_Version_hash(const moq_Version *self); -moq_buf moq_Version_to_string(const moq_Version *self); -moq_buf moq_Version_debug(const moq_Version *self); -moq_vec_Version moq_Version_ALL(void); +MOQ_MUST_USE moq_buf moq_Version_to_string(const moq_Version *self); +MOQ_MUST_USE moq_buf moq_Version_debug(const moq_Version *self); +MOQ_MUST_USE moq_vec_Version moq_Version_ALL(void); bool moq_Version_has_request_path(const moq_Version *self); -moq_buf moq_Version_as_str(const moq_Version *self); -moq_buf moq_Version_alpn(const moq_Version *self); +MOQ_MUST_USE moq_buf moq_Version_as_str(const moq_Version *self); +MOQ_MUST_USE moq_buf moq_Version_alpn(const moq_Version *self); bool moq_Version_is_lite(const moq_Version *self); void moq_Versions_free(moq_Versions *self); void moq_Versions_drop(moq_Versions *self, moq_status *status); bool moq_Versions_borrowed(const moq_Versions *self); -moq_Versions *moq_Versions_clone(const moq_Versions *self, moq_status *status); -moq_buf moq_Versions_debug(const moq_Versions *self, moq_status *status); -moq_Versions *moq_Versions_default(void); -moq_Versions *moq_Versions_all(void); -moq_vec_string moq_Versions_alpns(const moq_Versions *self, moq_status *status); -moq_Versions *moq_Versions_filter(const moq_Versions *self, const moq_Versions *other, moq_status *status); -moq_Version *moq_Versions_select(const moq_Versions *self, const moq_Version *version, moq_status *status); +MOQ_MUST_USE moq_Versions *moq_Versions_clone(const moq_Versions *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Versions_debug(const moq_Versions *self, moq_status *status); +MOQ_MUST_USE moq_Versions *moq_Versions_default(void); +MOQ_MUST_USE moq_Versions *moq_Versions_all(void); +MOQ_MUST_USE moq_vec_string moq_Versions_alpns(const moq_Versions *self, moq_status *status); +MOQ_MUST_USE moq_Versions *moq_Versions_filter(const moq_Versions *self, const moq_Versions *other, moq_status *status); +MOQ_MUST_USE moq_Version *moq_Versions_select(const moq_Versions *self, const moq_Version *version, moq_status *status); bool moq_Versions_contains(const moq_Versions *self, const moq_Version *version, moq_status *status); -moq_vec_Version moq_Versions_iter(const moq_Versions *self, moq_status *status); +MOQ_MUST_USE moq_vec_Version moq_Versions_iter(const moq_Versions *self, moq_status *status); void moq_Specificity_free(moq_Specificity *self); bool moq_Specificity_borrowed(const moq_Specificity *self); -moq_Specificity *moq_Specificity_clone(const moq_Specificity *self); +MOQ_MUST_USE moq_Specificity *moq_Specificity_clone(const moq_Specificity *self); bool moq_Specificity_eq(const moq_Specificity *a, const moq_Specificity *b); uint64_t moq_Specificity_hash(const moq_Specificity *self); -moq_buf moq_Specificity_debug(const moq_Specificity *self); +MOQ_MUST_USE moq_buf moq_Specificity_debug(const moq_Specificity *self); void moq_clock_Clock_free(moq_clock_Clock *self); bool moq_clock_Clock_borrowed(const moq_clock_Clock *self); -moq_clock_Clock *moq_clock_Clock_clone(const moq_clock_Clock *self); +MOQ_MUST_USE moq_clock_Clock *moq_clock_Clock_clone(const moq_clock_Clock *self); bool moq_clock_Clock_eq(const moq_clock_Clock *a, const moq_clock_Clock *b); -moq_buf moq_clock_Clock_debug(const moq_clock_Clock *self); -moq_clock_Clock *moq_clock_Clock_current(void); +MOQ_MUST_USE moq_buf moq_clock_Clock_debug(const moq_clock_Clock *self); +MOQ_MUST_USE moq_clock_Clock *moq_clock_Clock_current(void); moq_clock_Instant moq_clock_Clock_now(const moq_clock_Clock *self); moq_clock_Wall moq_clock_Clock_wall(const moq_clock_Clock *self); void moq_clock_Deadline_free(moq_clock_Deadline *self); void moq_clock_Deadline_drop(moq_clock_Deadline *self, moq_status *status); -moq_buf moq_clock_Deadline_debug(const moq_clock_Deadline *self, moq_status *status); -moq_clock_Deadline *moq_clock_Deadline_new(const moq_clock_Deadlines *deadlines); -moq_clock_Deadline *moq_clock_Deadline_after(const moq_clock_Deadlines *deadlines, moq_duration duration); +MOQ_MUST_USE moq_buf moq_clock_Deadline_debug(const moq_clock_Deadline *self, moq_status *status); +MOQ_MUST_USE moq_clock_Deadline *moq_clock_Deadline_new(const moq_clock_Deadlines *deadlines); +MOQ_MUST_USE moq_clock_Deadline *moq_clock_Deadline_after(const moq_clock_Deadlines *deadlines, moq_duration duration); void moq_clock_Deadline_set(moq_clock_Deadline *self, moq_option_clock_Instant at, moq_status *status); moq_option_clock_Instant moq_clock_Deadline_deadline(const moq_clock_Deadline *self, moq_status *status); typedef struct moq_clock_Deadline_poll_future moq_clock_Deadline_poll_future; -moq_clock_Deadline_poll_future *moq_clock_Deadline_poll(moq_clock_Deadline *self, moq_status *status); -moq_poll moq_clock_Deadline_poll_start(moq_clock_Deadline *self, moq_clock_Deadline_poll_future **future, moq_status *status); -moq_poll moq_clock_Deadline_poll_poll(moq_clock_Deadline_poll_future *future, moq_waker waker); +MOQ_MUST_USE moq_clock_Deadline_poll_future *moq_clock_Deadline_poll(moq_clock_Deadline *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_clock_Deadline_poll_start(moq_clock_Deadline *self, moq_clock_Deadline_poll_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_clock_Deadline_poll_poll(moq_clock_Deadline_poll_future *future, moq_waker waker); void moq_clock_Deadline_poll_future_free(moq_clock_Deadline_poll_future *future); void moq_clock_Deadlines_free(moq_clock_Deadlines *self); bool moq_clock_Deadlines_borrowed(const moq_clock_Deadlines *self); -moq_clock_Deadlines *moq_clock_Deadlines_clone(const moq_clock_Deadlines *self); -moq_clock_Deadlines *moq_clock_Deadlines_new(moq_clock_Instant now); +MOQ_MUST_USE moq_clock_Deadlines *moq_clock_Deadlines_clone(const moq_clock_Deadlines *self); +MOQ_MUST_USE moq_clock_Deadlines *moq_clock_Deadlines_new(moq_clock_Instant now); void moq_clock_Deadlines_advance(const moq_clock_Deadlines *self, moq_clock_Instant now); moq_option_clock_Instant moq_clock_Deadlines_park(const moq_clock_Deadlines *self, const moq_Waiter *waiter, moq_status *status); moq_option_clock_Instant moq_clock_Deadlines_next(const moq_clock_Deadlines *self); moq_clock_Instant moq_clock_Deadlines_now(const moq_clock_Deadlines *self); -moq_clock_Entered *moq_clock_Deadlines_enter(const moq_clock_Deadlines *self); -moq_clock_Entered *moq_clock_Deadlines_enter_homed(const moq_clock_Deadlines *self); +MOQ_MUST_USE moq_clock_Entered *moq_clock_Deadlines_enter(const moq_clock_Deadlines *self); +MOQ_MUST_USE moq_clock_Entered *moq_clock_Deadlines_enter_homed(const moq_clock_Deadlines *self); void moq_clock_Entered_free(moq_clock_Entered *self); void moq_clock_Entered_drop(moq_clock_Entered *self, moq_status *status); -moq_buf moq_clock_Entered_debug(const moq_clock_Entered *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_clock_Entered_debug(const moq_clock_Entered *self, moq_status *status); void moq_clock_Manual_free(moq_clock_Manual *self); void moq_clock_Manual_drop(moq_clock_Manual *self, moq_status *status); -moq_clock_Manual *moq_clock_Manual_clone(const moq_clock_Manual *self, moq_status *status); -moq_buf moq_clock_Manual_debug(const moq_clock_Manual *self, moq_status *status); -moq_clock_Manual *moq_clock_Manual_default(void); +MOQ_MUST_USE moq_clock_Manual *moq_clock_Manual_clone(const moq_clock_Manual *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_clock_Manual_debug(const moq_clock_Manual *self, moq_status *status); +MOQ_MUST_USE moq_clock_Manual *moq_clock_Manual_default(void); moq_clock_Wall moq_clock_Manual_WALL_START(void); -moq_clock_Manual *moq_clock_Manual_new(void); +MOQ_MUST_USE moq_clock_Manual *moq_clock_Manual_new(void); moq_clock_Instant moq_clock_Manual_now(const moq_clock_Manual *self, moq_status *status); moq_clock_Wall moq_clock_Manual_wall(const moq_clock_Manual *self, moq_status *status); void moq_clock_Manual_advance(moq_clock_Manual *self, moq_duration duration, moq_status *status); @@ -3354,488 +3364,488 @@ void moq_clock_Rng_drop(moq_clock_Rng *self, moq_status *status); void moq_clock_Interval_free(moq_clock_Interval *self); void moq_clock_Interval_drop(moq_clock_Interval *self, moq_status *status); typedef struct moq_clock_Interval_tick_future moq_clock_Interval_tick_future; -moq_clock_Interval_tick_future *moq_clock_Interval_tick(moq_clock_Interval *self, moq_status *status); -moq_poll moq_clock_Interval_tick_start(moq_clock_Interval *self, moq_clock_Instant *out, moq_clock_Interval_tick_future **future, moq_status *status); -moq_poll moq_clock_Interval_tick_poll(moq_clock_Interval_tick_future *future, moq_waker waker, moq_clock_Instant *out); +MOQ_MUST_USE moq_clock_Interval_tick_future *moq_clock_Interval_tick(moq_clock_Interval *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_clock_Interval_tick_start(moq_clock_Interval *self, moq_clock_Instant *out, moq_clock_Interval_tick_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_clock_Interval_tick_poll(moq_clock_Interval_tick_future *future, moq_waker waker, moq_clock_Instant *out); void moq_clock_Interval_tick_future_free(moq_clock_Interval_tick_future *future); void moq_clock_Interval_set_missed_tick_behavior(moq_clock_Interval *self, moq_clock_MissedTickBehavior missed, moq_status *status); moq_duration moq_clock_Interval_period(const moq_clock_Interval *self, moq_status *status); void moq_clock_WallMap_free(moq_clock_WallMap *self); void moq_clock_WallMap_drop(moq_clock_WallMap *self, moq_status *status); -moq_clock_WallMap *moq_clock_WallMap_clone(const moq_clock_WallMap *self, moq_status *status); -moq_buf moq_clock_WallMap_debug(const moq_clock_WallMap *self, moq_status *status); -moq_clock_WallMap *moq_clock_WallMap_default(void); +MOQ_MUST_USE moq_clock_WallMap *moq_clock_WallMap_clone(const moq_clock_WallMap *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_clock_WallMap_debug(const moq_clock_WallMap *self, moq_status *status); +MOQ_MUST_USE moq_clock_WallMap *moq_clock_WallMap_default(void); moq_duration moq_clock_WallMap_TOLERANCE(void); void moq_clock_WallMap_sample(moq_clock_WallMap *self, moq_clock_Instant now, moq_clock_Wall wall, moq_status *status); moq_option_clock_Instant moq_clock_WallMap_map(const moq_clock_WallMap *self, moq_clock_Wall at, moq_status *status); void moq_coop_Budget_free(moq_coop_Budget *self); void moq_coop_Budget_drop(moq_coop_Budget *self, moq_status *status); -moq_coop_Budget *moq_coop_Budget_clone(const moq_coop_Budget *self, moq_status *status); -moq_buf moq_coop_Budget_debug(const moq_coop_Budget *self, moq_status *status); -moq_coop_Budget *moq_coop_Budget_new(uint32_t passes); +MOQ_MUST_USE moq_coop_Budget *moq_coop_Budget_clone(const moq_coop_Budget *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_coop_Budget_debug(const moq_coop_Budget *self, moq_status *status); +MOQ_MUST_USE moq_coop_Budget *moq_coop_Budget_new(uint32_t passes); typedef struct moq_coop_Budget_poll_yield_future moq_coop_Budget_poll_yield_future; -moq_coop_Budget_poll_yield_future *moq_coop_Budget_poll_yield(moq_coop_Budget *self, moq_status *status); -moq_poll moq_coop_Budget_poll_yield_start(moq_coop_Budget *self, moq_coop_Budget_poll_yield_future **future, moq_status *status); -moq_poll moq_coop_Budget_poll_yield_poll(moq_coop_Budget_poll_yield_future *future, moq_waker waker); +MOQ_MUST_USE moq_coop_Budget_poll_yield_future *moq_coop_Budget_poll_yield(moq_coop_Budget *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_coop_Budget_poll_yield_start(moq_coop_Budget *self, moq_coop_Budget_poll_yield_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_coop_Budget_poll_yield_poll(moq_coop_Budget_poll_yield_future *future, moq_waker waker); void moq_coop_Budget_poll_yield_future_free(moq_coop_Budget_poll_yield_future *future); void moq_hang_Catalog_free(moq_hang_Catalog *self); void moq_hang_Catalog_drop(moq_hang_Catalog *self, moq_status *status); -moq_hang_Catalog *moq_hang_Catalog_clone(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog *moq_hang_Catalog_clone(const moq_hang_Catalog *self, moq_status *status); bool moq_hang_Catalog_eq(const moq_hang_Catalog *a, const moq_hang_Catalog *b, moq_status *status); -moq_buf moq_hang_Catalog_debug(const moq_hang_Catalog *self, moq_status *status); -moq_hang_Catalog *moq_hang_Catalog_default(void); -moq_hang_catalog_Video *moq_hang_Catalog_video_get(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_Catalog_debug(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog *moq_hang_Catalog_default(void); +MOQ_MUST_USE moq_hang_catalog_Video *moq_hang_Catalog_video_get(const moq_hang_Catalog *self, moq_status *status); void moq_hang_Catalog_video_set(moq_hang_Catalog *self, moq_hang_catalog_Video *value, moq_status *status); -moq_hang_catalog_Audio *moq_hang_Catalog_audio_get(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Audio *moq_hang_Catalog_audio_get(const moq_hang_Catalog *self, moq_status *status); void moq_hang_Catalog_audio_set(moq_hang_Catalog *self, moq_hang_catalog_Audio *value, moq_status *status); -moq_hang_catalog_Timeline *moq_hang_Catalog_sync_get(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Timeline *moq_hang_Catalog_sync_get(const moq_hang_Catalog *self, moq_status *status); void moq_hang_Catalog_sync_set(moq_hang_Catalog *self, const moq_hang_catalog_Timeline *value, moq_status *status); -moq_hang_catalog_Text *moq_hang_Catalog_text_get(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Text *moq_hang_Catalog_text_get(const moq_hang_Catalog *self, moq_status *status); void moq_hang_Catalog_text_set(moq_hang_Catalog *self, moq_hang_catalog_Text *value, moq_status *status); -moq_hang_catalog_Json *moq_hang_Catalog_json_get(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Json *moq_hang_Catalog_json_get(const moq_hang_Catalog *self, moq_status *status); void moq_hang_Catalog_json_set(moq_hang_Catalog *self, moq_hang_catalog_Json *value, moq_status *status); -moq_hang_catalog_Binary *moq_hang_Catalog_binary_get(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Binary *moq_hang_Catalog_binary_get(const moq_hang_Catalog *self, moq_status *status); void moq_hang_Catalog_binary_set(moq_hang_Catalog *self, moq_hang_catalog_Binary *value, moq_status *status); -moq_hang_catalog_Stats *moq_hang_Catalog_stats_get(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Stats *moq_hang_Catalog_stats_get(const moq_hang_Catalog *self, moq_status *status); void moq_hang_Catalog_stats_set(moq_hang_Catalog *self, moq_hang_catalog_Stats *value, moq_status *status); -moq_hang_catalog_Echo *moq_hang_Catalog_echo_get(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Echo *moq_hang_Catalog_echo_get(const moq_hang_Catalog *self, moq_status *status); void moq_hang_Catalog_echo_set(moq_hang_Catalog *self, moq_hang_catalog_Echo *value, moq_status *status); -moq_vec_tuple_string_hang_catalog_Include moq_hang_Catalog_include_get(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_Include moq_hang_Catalog_include_get(const moq_hang_Catalog *self, moq_status *status); void moq_hang_Catalog_include_set(moq_hang_Catalog *self, moq_vec_tuple_string_hang_catalog_Include value, moq_status *status); -moq_hang_catalog_Skipped *moq_hang_Catalog_skipped_get(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Skipped *moq_hang_Catalog_skipped_get(const moq_hang_Catalog *self, moq_status *status); void moq_hang_Catalog_skipped_set(moq_hang_Catalog *self, moq_hang_catalog_Skipped *value, moq_status *status); -moq_buf moq_hang_Catalog_DEFAULT_NAME(void); -moq_track_Info *moq_hang_Catalog_default_track_info(void); -moq_track_Subscription *moq_hang_Catalog_default_subscription(void); -bool moq_hang_Catalog_check_renditions(const moq_hang_Catalog *self, moq_hang_Error **err, moq_status *status); -moq_hang_Catalog *moq_hang_Catalog_without_ext(const moq_hang_Catalog *self, moq_status *status); -bool moq_hang_Catalog_from_slice(moq_buf v, moq_hang_Catalog **out, moq_hang_Error **err); -bool moq_hang_Catalog_from_reader(moq_buf reader, moq_hang_Catalog **out, moq_hang_Error **err); -bool moq_hang_Catalog_to_json(const moq_hang_Catalog *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_hang_Catalog_to_vec(const moq_hang_Catalog *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_hang_Catalog_to_writer(const moq_hang_Catalog *self, moq_buf writer, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_Catalog_DEFAULT_NAME(void); +MOQ_MUST_USE moq_track_Info *moq_hang_Catalog_default_track_info(void); +MOQ_MUST_USE moq_track_Subscription *moq_hang_Catalog_default_subscription(void); +MOQ_MUST_USE bool moq_hang_Catalog_check_renditions(const moq_hang_Catalog *self, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog *moq_hang_Catalog_without_ext(const moq_hang_Catalog *self, moq_status *status); +MOQ_MUST_USE bool moq_hang_Catalog_from_slice(moq_buf v, moq_hang_Catalog **out, moq_hang_Error **err); +MOQ_MUST_USE bool moq_hang_Catalog_from_reader(moq_buf reader, moq_hang_Catalog **out, moq_hang_Error **err); +MOQ_MUST_USE bool moq_hang_Catalog_to_json(const moq_hang_Catalog *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_hang_Catalog_to_vec(const moq_hang_Catalog *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_hang_Catalog_to_writer(const moq_hang_Catalog *self, moq_buf writer, moq_hang_Error **err, moq_status *status); void moq_hang_Catalog_Extra_free(moq_hang_Catalog_Extra *self); void moq_hang_Catalog_Extra_drop(moq_hang_Catalog_Extra *self, moq_status *status); -moq_hang_Catalog_Extra *moq_hang_Catalog_Extra_clone(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog_Extra *moq_hang_Catalog_Extra_clone(const moq_hang_Catalog_Extra *self, moq_status *status); bool moq_hang_Catalog_Extra_eq(const moq_hang_Catalog_Extra *a, const moq_hang_Catalog_Extra *b, moq_status *status); -moq_buf moq_hang_Catalog_Extra_debug(const moq_hang_Catalog_Extra *self, moq_status *status); -moq_hang_Catalog_Extra *moq_hang_Catalog_Extra_default(void); -moq_hang_catalog_Video *moq_hang_Catalog_Extra_video_get(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_Catalog_Extra_debug(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog_Extra *moq_hang_Catalog_Extra_default(void); +MOQ_MUST_USE moq_hang_catalog_Video *moq_hang_Catalog_Extra_video_get(const moq_hang_Catalog_Extra *self, moq_status *status); void moq_hang_Catalog_Extra_video_set(moq_hang_Catalog_Extra *self, moq_hang_catalog_Video *value, moq_status *status); -moq_hang_catalog_Audio *moq_hang_Catalog_Extra_audio_get(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Audio *moq_hang_Catalog_Extra_audio_get(const moq_hang_Catalog_Extra *self, moq_status *status); void moq_hang_Catalog_Extra_audio_set(moq_hang_Catalog_Extra *self, moq_hang_catalog_Audio *value, moq_status *status); -moq_hang_catalog_Timeline *moq_hang_Catalog_Extra_sync_get(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Timeline *moq_hang_Catalog_Extra_sync_get(const moq_hang_Catalog_Extra *self, moq_status *status); void moq_hang_Catalog_Extra_sync_set(moq_hang_Catalog_Extra *self, const moq_hang_catalog_Timeline *value, moq_status *status); -moq_hang_catalog_Text *moq_hang_Catalog_Extra_text_get(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Text *moq_hang_Catalog_Extra_text_get(const moq_hang_Catalog_Extra *self, moq_status *status); void moq_hang_Catalog_Extra_text_set(moq_hang_Catalog_Extra *self, moq_hang_catalog_Text *value, moq_status *status); -moq_hang_catalog_Json *moq_hang_Catalog_Extra_json_get(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Json *moq_hang_Catalog_Extra_json_get(const moq_hang_Catalog_Extra *self, moq_status *status); void moq_hang_Catalog_Extra_json_set(moq_hang_Catalog_Extra *self, moq_hang_catalog_Json *value, moq_status *status); -moq_hang_catalog_Binary *moq_hang_Catalog_Extra_binary_get(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Binary *moq_hang_Catalog_Extra_binary_get(const moq_hang_Catalog_Extra *self, moq_status *status); void moq_hang_Catalog_Extra_binary_set(moq_hang_Catalog_Extra *self, moq_hang_catalog_Binary *value, moq_status *status); -moq_hang_catalog_Stats *moq_hang_Catalog_Extra_stats_get(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Stats *moq_hang_Catalog_Extra_stats_get(const moq_hang_Catalog_Extra *self, moq_status *status); void moq_hang_Catalog_Extra_stats_set(moq_hang_Catalog_Extra *self, moq_hang_catalog_Stats *value, moq_status *status); -moq_hang_catalog_Echo *moq_hang_Catalog_Extra_echo_get(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Echo *moq_hang_Catalog_Extra_echo_get(const moq_hang_Catalog_Extra *self, moq_status *status); void moq_hang_Catalog_Extra_echo_set(moq_hang_Catalog_Extra *self, moq_hang_catalog_Echo *value, moq_status *status); -moq_vec_tuple_string_hang_catalog_Include moq_hang_Catalog_Extra_include_get(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_Include moq_hang_Catalog_Extra_include_get(const moq_hang_Catalog_Extra *self, moq_status *status); void moq_hang_Catalog_Extra_include_set(moq_hang_Catalog_Extra *self, moq_vec_tuple_string_hang_catalog_Include value, moq_status *status); -moq_mux_catalog_hang_Extra *moq_hang_Catalog_Extra_ext_get(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_hang_Extra *moq_hang_Catalog_Extra_ext_get(const moq_hang_Catalog_Extra *self, moq_status *status); void moq_hang_Catalog_Extra_ext_set(moq_hang_Catalog_Extra *self, moq_mux_catalog_hang_Extra *value, moq_status *status); -moq_hang_catalog_Skipped *moq_hang_Catalog_Extra_skipped_get(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Skipped *moq_hang_Catalog_Extra_skipped_get(const moq_hang_Catalog_Extra *self, moq_status *status); void moq_hang_Catalog_Extra_skipped_set(moq_hang_Catalog_Extra *self, moq_hang_catalog_Skipped *value, moq_status *status); -bool moq_hang_Catalog_Extra_check_renditions(const moq_hang_Catalog_Extra *self, moq_hang_Error **err, moq_status *status); -moq_hang_Catalog *moq_hang_Catalog_Extra_without_ext(const moq_hang_Catalog_Extra *self, moq_status *status); -bool moq_hang_Catalog_Extra_from_slice(moq_buf v, moq_hang_Catalog_Extra **out, moq_hang_Error **err); -bool moq_hang_Catalog_Extra_from_reader(moq_buf reader, moq_hang_Catalog_Extra **out, moq_hang_Error **err); -bool moq_hang_Catalog_Extra_to_json(const moq_hang_Catalog_Extra *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_hang_Catalog_Extra_to_vec(const moq_hang_Catalog_Extra *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_hang_Catalog_Extra_to_writer(const moq_hang_Catalog_Extra *self, moq_buf writer, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_hang_Catalog_Extra_check_renditions(const moq_hang_Catalog_Extra *self, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog *moq_hang_Catalog_Extra_without_ext(const moq_hang_Catalog_Extra *self, moq_status *status); +MOQ_MUST_USE bool moq_hang_Catalog_Extra_from_slice(moq_buf v, moq_hang_Catalog_Extra **out, moq_hang_Error **err); +MOQ_MUST_USE bool moq_hang_Catalog_Extra_from_reader(moq_buf reader, moq_hang_Catalog_Extra **out, moq_hang_Error **err); +MOQ_MUST_USE bool moq_hang_Catalog_Extra_to_json(const moq_hang_Catalog_Extra *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_hang_Catalog_Extra_to_vec(const moq_hang_Catalog_Extra *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_hang_Catalog_Extra_to_writer(const moq_hang_Catalog_Extra *self, moq_buf writer, moq_hang_Error **err, moq_status *status); void moq_hang_Catalog_Ext_free(moq_hang_Catalog_Ext *self); void moq_hang_Catalog_Ext_drop(moq_hang_Catalog_Ext *self, moq_status *status); -moq_hang_Catalog_Ext *moq_hang_Catalog_Ext_clone(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog_Ext *moq_hang_Catalog_Ext_clone(const moq_hang_Catalog_Ext *self, moq_status *status); bool moq_hang_Catalog_Ext_eq(const moq_hang_Catalog_Ext *a, const moq_hang_Catalog_Ext *b, moq_status *status); -moq_buf moq_hang_Catalog_Ext_debug(const moq_hang_Catalog_Ext *self, moq_status *status); -moq_hang_Catalog_Ext *moq_hang_Catalog_Ext_default(void); -moq_hang_catalog_Video *moq_hang_Catalog_Ext_video_get(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_Catalog_Ext_debug(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog_Ext *moq_hang_Catalog_Ext_default(void); +MOQ_MUST_USE moq_hang_catalog_Video *moq_hang_Catalog_Ext_video_get(const moq_hang_Catalog_Ext *self, moq_status *status); void moq_hang_Catalog_Ext_video_set(moq_hang_Catalog_Ext *self, moq_hang_catalog_Video *value, moq_status *status); -moq_hang_catalog_Audio *moq_hang_Catalog_Ext_audio_get(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Audio *moq_hang_Catalog_Ext_audio_get(const moq_hang_Catalog_Ext *self, moq_status *status); void moq_hang_Catalog_Ext_audio_set(moq_hang_Catalog_Ext *self, moq_hang_catalog_Audio *value, moq_status *status); -moq_hang_catalog_Timeline *moq_hang_Catalog_Ext_sync_get(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Timeline *moq_hang_Catalog_Ext_sync_get(const moq_hang_Catalog_Ext *self, moq_status *status); void moq_hang_Catalog_Ext_sync_set(moq_hang_Catalog_Ext *self, const moq_hang_catalog_Timeline *value, moq_status *status); -moq_hang_catalog_Text *moq_hang_Catalog_Ext_text_get(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Text *moq_hang_Catalog_Ext_text_get(const moq_hang_Catalog_Ext *self, moq_status *status); void moq_hang_Catalog_Ext_text_set(moq_hang_Catalog_Ext *self, moq_hang_catalog_Text *value, moq_status *status); -moq_hang_catalog_Json *moq_hang_Catalog_Ext_json_get(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Json *moq_hang_Catalog_Ext_json_get(const moq_hang_Catalog_Ext *self, moq_status *status); void moq_hang_Catalog_Ext_json_set(moq_hang_Catalog_Ext *self, moq_hang_catalog_Json *value, moq_status *status); -moq_hang_catalog_Binary *moq_hang_Catalog_Ext_binary_get(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Binary *moq_hang_Catalog_Ext_binary_get(const moq_hang_Catalog_Ext *self, moq_status *status); void moq_hang_Catalog_Ext_binary_set(moq_hang_Catalog_Ext *self, moq_hang_catalog_Binary *value, moq_status *status); -moq_hang_catalog_Stats *moq_hang_Catalog_Ext_stats_get(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Stats *moq_hang_Catalog_Ext_stats_get(const moq_hang_Catalog_Ext *self, moq_status *status); void moq_hang_Catalog_Ext_stats_set(moq_hang_Catalog_Ext *self, moq_hang_catalog_Stats *value, moq_status *status); -moq_hang_catalog_Echo *moq_hang_Catalog_Ext_echo_get(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Echo *moq_hang_Catalog_Ext_echo_get(const moq_hang_Catalog_Ext *self, moq_status *status); void moq_hang_Catalog_Ext_echo_set(moq_hang_Catalog_Ext *self, moq_hang_catalog_Echo *value, moq_status *status); -moq_vec_tuple_string_hang_catalog_Include moq_hang_Catalog_Ext_include_get(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_Include moq_hang_Catalog_Ext_include_get(const moq_hang_Catalog_Ext *self, moq_status *status); void moq_hang_Catalog_Ext_include_set(moq_hang_Catalog_Ext *self, moq_vec_tuple_string_hang_catalog_Include value, moq_status *status); -moq_mux_container_ts_Ext *moq_hang_Catalog_Ext_ext_get(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Ext *moq_hang_Catalog_Ext_ext_get(const moq_hang_Catalog_Ext *self, moq_status *status); void moq_hang_Catalog_Ext_ext_set(moq_hang_Catalog_Ext *self, moq_mux_container_ts_Ext *value, moq_status *status); -moq_hang_catalog_Skipped *moq_hang_Catalog_Ext_skipped_get(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Skipped *moq_hang_Catalog_Ext_skipped_get(const moq_hang_Catalog_Ext *self, moq_status *status); void moq_hang_Catalog_Ext_skipped_set(moq_hang_Catalog_Ext *self, moq_hang_catalog_Skipped *value, moq_status *status); -bool moq_hang_Catalog_Ext_check_renditions(const moq_hang_Catalog_Ext *self, moq_hang_Error **err, moq_status *status); -moq_hang_Catalog *moq_hang_Catalog_Ext_without_ext(const moq_hang_Catalog_Ext *self, moq_status *status); -bool moq_hang_Catalog_Ext_from_slice(moq_buf v, moq_hang_Catalog_Ext **out, moq_hang_Error **err); -bool moq_hang_Catalog_Ext_from_reader(moq_buf reader, moq_hang_Catalog_Ext **out, moq_hang_Error **err); -bool moq_hang_Catalog_Ext_to_json(const moq_hang_Catalog_Ext *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_hang_Catalog_Ext_to_vec(const moq_hang_Catalog_Ext *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_hang_Catalog_Ext_to_writer(const moq_hang_Catalog_Ext *self, moq_buf writer, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_hang_Catalog_Ext_check_renditions(const moq_hang_Catalog_Ext *self, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog *moq_hang_Catalog_Ext_without_ext(const moq_hang_Catalog_Ext *self, moq_status *status); +MOQ_MUST_USE bool moq_hang_Catalog_Ext_from_slice(moq_buf v, moq_hang_Catalog_Ext **out, moq_hang_Error **err); +MOQ_MUST_USE bool moq_hang_Catalog_Ext_from_reader(moq_buf reader, moq_hang_Catalog_Ext **out, moq_hang_Error **err); +MOQ_MUST_USE bool moq_hang_Catalog_Ext_to_json(const moq_hang_Catalog_Ext *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_hang_Catalog_Ext_to_vec(const moq_hang_Catalog_Ext *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_hang_Catalog_Ext_to_writer(const moq_hang_Catalog_Ext *self, moq_buf writer, moq_hang_Error **err, moq_status *status); void moq_hang_Error_free(moq_hang_Error *self); bool moq_hang_Error_borrowed(const moq_hang_Error *self); -moq_hang_Error *moq_hang_Error_clone(const moq_hang_Error *self); -moq_buf moq_hang_Error_to_string(const moq_hang_Error *self); -moq_buf moq_hang_Error_debug(const moq_hang_Error *self); +MOQ_MUST_USE moq_hang_Error *moq_hang_Error_clone(const moq_hang_Error *self); +MOQ_MUST_USE moq_buf moq_hang_Error_to_string(const moq_hang_Error *self); +MOQ_MUST_USE moq_buf moq_hang_Error_debug(const moq_hang_Error *self); void moq_mux_Clock_free(moq_mux_Clock *self); void moq_mux_Clock_drop(moq_mux_Clock *self, moq_status *status); bool moq_mux_Clock_borrowed(const moq_mux_Clock *self); -moq_mux_Clock *moq_mux_Clock_clone(const moq_mux_Clock *self, moq_status *status); +MOQ_MUST_USE moq_mux_Clock *moq_mux_Clock_clone(const moq_mux_Clock *self, moq_status *status); bool moq_mux_Clock_eq(const moq_mux_Clock *a, const moq_mux_Clock *b, moq_status *status); -moq_buf moq_mux_Clock_debug(const moq_mux_Clock *self, moq_status *status); -moq_mux_Clock *moq_mux_Clock_default(void); +MOQ_MUST_USE moq_buf moq_mux_Clock_debug(const moq_mux_Clock *self, moq_status *status); +MOQ_MUST_USE moq_mux_Clock *moq_mux_Clock_default(void); moq_Timescale moq_mux_Clock_TIMESCALE(void); -moq_mux_Clock *moq_mux_Clock_new(void); -bool moq_mux_Clock_at(moq_clock_Instant epoch, moq_clock_Wall wall, moq_mux_Clock **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_Clock *moq_mux_Clock_new(void); +MOQ_MUST_USE bool moq_mux_Clock_at(moq_clock_Instant epoch, moq_clock_Wall wall, moq_mux_Clock **out, moq_mux_Error **err); moq_Timestamp moq_mux_Clock_now(const moq_mux_Clock *self, moq_status *status); -bool moq_mux_Clock_capture(const moq_mux_Clock *self, moq_clock_Instant at, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_Clock_capture(const moq_mux_Clock *self, moq_clock_Instant at, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); moq_Timescale moq_mux_Clock_timescale(const moq_mux_Clock *self, moq_status *status); moq_option_hang_catalog_Clock moq_mux_Clock_wall(const moq_mux_Clock *self, moq_status *status); -bool moq_mux_Clock_wall_clock(const moq_mux_Clock *self, moq_Timestamp pts, moq_clock_Wall *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_Clock_wall_clock(const moq_mux_Clock *self, moq_Timestamp pts, moq_clock_Wall *out, moq_mux_Error **err, moq_status *status); void moq_mux_Ingest_free(moq_mux_Ingest *self); void moq_mux_Ingest_drop(moq_mux_Ingest *self, moq_status *status); -moq_mux_Ingest *moq_mux_Ingest_clone(const moq_mux_Ingest *self, moq_status *status); -moq_buf moq_mux_Ingest_debug(const moq_mux_Ingest *self, moq_status *status); -moq_mux_Ingest *moq_mux_Ingest_default(void); +MOQ_MUST_USE moq_mux_Ingest *moq_mux_Ingest_clone(const moq_mux_Ingest *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_Ingest_debug(const moq_mux_Ingest *self, moq_status *status); +MOQ_MUST_USE moq_mux_Ingest *moq_mux_Ingest_default(void); moq_option_duration moq_mux_Ingest_max_age_get(const moq_mux_Ingest *self, moq_status *status); void moq_mux_Ingest_max_age_set(moq_mux_Ingest *self, moq_option_duration value, moq_status *status); -moq_bandwidth_Allocator *moq_mux_Ingest_bandwidth_get(const moq_mux_Ingest *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Allocator *moq_mux_Ingest_bandwidth_get(const moq_mux_Ingest *self, moq_status *status); void moq_mux_Ingest_bandwidth_set(moq_mux_Ingest *self, moq_bandwidth_Allocator *value, moq_status *status); moq_duration moq_mux_Ingest_linger_get(const moq_mux_Ingest *self, moq_status *status); void moq_mux_Ingest_linger_set(moq_mux_Ingest *self, moq_duration value, moq_status *status); -moq_bandwidth_Limit *moq_mux_Ingest_rate_get(const moq_mux_Ingest *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Limit *moq_mux_Ingest_rate_get(const moq_mux_Ingest *self, moq_status *status); void moq_mux_Ingest_rate_set(moq_mux_Ingest *self, moq_bandwidth_Limit *value, moq_status *status); -moq_mux_catalog_Config *moq_mux_Ingest_catalog(const moq_mux_Ingest *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config *moq_mux_Ingest_catalog(const moq_mux_Ingest *self, moq_status *status); void moq_mux_Linger_unit_free(moq_mux_Linger_unit *self); void moq_mux_Linger_unit_drop(moq_mux_Linger_unit *self, moq_status *status); moq_duration moq_mux_Linger_unit_DEFAULT(void); -moq_mux_Linger_unit *moq_mux_Linger_unit_new(moq_vec_broadcast_Producer broadcasts, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_Linger_unit *moq_mux_Linger_unit_new(moq_vec_broadcast_Producer broadcasts, moq_duration duration, moq_status *status); typedef struct moq_mux_Linger_unit_wait_future moq_mux_Linger_unit_wait_future; -moq_mux_Linger_unit_wait_future *moq_mux_Linger_unit_wait(moq_mux_Linger_unit *self, moq_status *status); -moq_poll moq_mux_Linger_unit_wait_start(moq_mux_Linger_unit *self, moq_mux_Linger_unit_wait_future **future, moq_status *status); -moq_poll moq_mux_Linger_unit_wait_poll(moq_mux_Linger_unit_wait_future *future, moq_waker waker); +MOQ_MUST_USE moq_mux_Linger_unit_wait_future *moq_mux_Linger_unit_wait(moq_mux_Linger_unit *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Linger_unit_wait_start(moq_mux_Linger_unit *self, moq_mux_Linger_unit_wait_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Linger_unit_wait_poll(moq_mux_Linger_unit_wait_future *future, moq_waker waker); void moq_mux_Linger_unit_wait_future_free(moq_mux_Linger_unit_wait_future *future); void moq_mux_Pacer_free(moq_mux_Pacer *self); void moq_mux_Pacer_drop(moq_mux_Pacer *self, moq_status *status); -moq_mux_Pacer *moq_mux_Pacer_default(void); -moq_mux_Pacer *moq_mux_Pacer_with_lead(moq_mux_Pacer *self, moq_duration lead, moq_status *status); -moq_mux_Pacer *moq_mux_Pacer_with_delay(moq_mux_Pacer *self, moq_duration delay, moq_status *status); +MOQ_MUST_USE moq_mux_Pacer *moq_mux_Pacer_default(void); +MOQ_MUST_USE moq_mux_Pacer *moq_mux_Pacer_with_lead(moq_mux_Pacer *self, moq_duration lead, moq_status *status); +MOQ_MUST_USE moq_mux_Pacer *moq_mux_Pacer_with_delay(moq_mux_Pacer *self, moq_duration delay, moq_status *status); moq_clock_Instant moq_mux_Pacer_pace(moq_mux_Pacer *self, moq_Timestamp ts, moq_clock_Instant now, moq_status *status); moq_option_clock_Instant moq_mux_Pacer_due(const moq_mux_Pacer *self, moq_Timestamp ts, moq_status *status); moq_duration moq_mux_Pacer_slack(const moq_mux_Pacer *self, moq_status *status); moq_clock_Instant moq_mux_Pacer_hurry(moq_mux_Pacer *self, moq_Timestamp ts, moq_clock_Instant now, moq_status *status); void moq_mux_Binding_free(moq_mux_Binding *self); -moq_mux_Binding *moq_mux_Binding_new(moq_broadcast_Consumer *broadcast, moq_status *status); +MOQ_MUST_USE moq_mux_Binding *moq_mux_Binding_new(moq_broadcast_Consumer *broadcast, moq_status *status); typedef struct moq_mux_Binding_broadcast_future moq_mux_Binding_broadcast_future; -moq_mux_Binding_broadcast_future *moq_mux_Binding_broadcast(const moq_mux_Binding *self); -moq_poll moq_mux_Binding_broadcast_start(const moq_mux_Binding *self, moq_broadcast_Consumer **out, moq_mux_Error **err, moq_mux_Binding_broadcast_future **future); -moq_poll moq_mux_Binding_broadcast_poll(moq_mux_Binding_broadcast_future *future, moq_waker waker, moq_broadcast_Consumer **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_Binding_broadcast_future *moq_mux_Binding_broadcast(const moq_mux_Binding *self); +MOQ_MUST_USE moq_poll moq_mux_Binding_broadcast_start(const moq_mux_Binding *self, moq_broadcast_Consumer **out, moq_mux_Error **err, moq_mux_Binding_broadcast_future **future); +MOQ_MUST_USE moq_poll moq_mux_Binding_broadcast_poll(moq_mux_Binding_broadcast_future *future, moq_waker waker, moq_broadcast_Consumer **out, moq_mux_Error **err); void moq_mux_Binding_broadcast_future_free(moq_mux_Binding_broadcast_future *future); void moq_mux_Source_free(moq_mux_Source *self); void moq_mux_Source_drop(moq_mux_Source *self, moq_status *status); -moq_mux_Source *moq_mux_Source_clone(const moq_mux_Source *self, moq_status *status); -moq_mux_Source *moq_mux_Source_new(moq_origin_Consumer *origin, moq_broadcast_Consumer *broadcast, moq_status *status); -moq_vec_tuple_string_hang_echo_Rendition moq_mux_Source_stats(const moq_mux_Source *self, moq_status *status); -moq_broadcast_Consumer *moq_mux_Source_broadcast(const moq_mux_Source *self, moq_status *status); +MOQ_MUST_USE moq_mux_Source *moq_mux_Source_clone(const moq_mux_Source *self, moq_status *status); +MOQ_MUST_USE moq_mux_Source *moq_mux_Source_new(moq_origin_Consumer *origin, moq_broadcast_Consumer *broadcast, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_echo_Rendition moq_mux_Source_stats(const moq_mux_Source *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Consumer *moq_mux_Source_broadcast(const moq_mux_Source *self, moq_status *status); typedef struct moq_mux_Source_catalog_Extra_future moq_mux_Source_catalog_Extra_future; -moq_mux_Source_catalog_Extra_future *moq_mux_Source_catalog_Extra(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_status *status); -moq_poll moq_mux_Source_catalog_Extra_start(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer_Extra **out, moq_mux_Error **err, moq_mux_Source_catalog_Extra_future **future, moq_status *status); -moq_poll moq_mux_Source_catalog_Extra_poll(moq_mux_Source_catalog_Extra_future *future, moq_waker waker, moq_mux_catalog_Consumer_Extra **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_Source_catalog_Extra_future *moq_mux_Source_catalog_Extra(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Source_catalog_Extra_start(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer_Extra **out, moq_mux_Error **err, moq_mux_Source_catalog_Extra_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Source_catalog_Extra_poll(moq_mux_Source_catalog_Extra_future *future, moq_waker waker, moq_mux_catalog_Consumer_Extra **out, moq_mux_Error **err); void moq_mux_Source_catalog_Extra_future_free(moq_mux_Source_catalog_Extra_future *future); typedef struct moq_mux_Source_catalog_Ext_future moq_mux_Source_catalog_Ext_future; -moq_mux_Source_catalog_Ext_future *moq_mux_Source_catalog_Ext(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_status *status); -moq_poll moq_mux_Source_catalog_Ext_start(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer_Ext **out, moq_mux_Error **err, moq_mux_Source_catalog_Ext_future **future, moq_status *status); -moq_poll moq_mux_Source_catalog_Ext_poll(moq_mux_Source_catalog_Ext_future *future, moq_waker waker, moq_mux_catalog_Consumer_Ext **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_Source_catalog_Ext_future *moq_mux_Source_catalog_Ext(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Source_catalog_Ext_start(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer_Ext **out, moq_mux_Error **err, moq_mux_Source_catalog_Ext_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Source_catalog_Ext_poll(moq_mux_Source_catalog_Ext_future *future, moq_waker waker, moq_mux_catalog_Consumer_Ext **out, moq_mux_Error **err); void moq_mux_Source_catalog_Ext_future_free(moq_mux_Source_catalog_Ext_future *future); typedef struct moq_mux_Source_catalog_unit_future moq_mux_Source_catalog_unit_future; -moq_mux_Source_catalog_unit_future *moq_mux_Source_catalog_unit(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_status *status); -moq_poll moq_mux_Source_catalog_unit_start(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer **out, moq_mux_Error **err, moq_mux_Source_catalog_unit_future **future, moq_status *status); -moq_poll moq_mux_Source_catalog_unit_poll(moq_mux_Source_catalog_unit_future *future, moq_waker waker, moq_mux_catalog_Consumer **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_Source_catalog_unit_future *moq_mux_Source_catalog_unit(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Source_catalog_unit_start(const moq_mux_Source *self, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer **out, moq_mux_Error **err, moq_mux_Source_catalog_unit_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Source_catalog_unit_poll(moq_mux_Source_catalog_unit_future *future, moq_waker waker, moq_mux_catalog_Consumer **out, moq_mux_Error **err); void moq_mux_Source_catalog_unit_future_free(moq_mux_Source_catalog_unit_future *future); -moq_Path *moq_mux_Source_resolve_reference(const moq_mux_Source *self, const moq_path_Relative *rel, moq_status *status); +MOQ_MUST_USE moq_Path *moq_mux_Source_resolve_reference(const moq_mux_Source *self, const moq_path_Relative *rel, moq_status *status); typedef struct moq_mux_Source_resolve_future moq_mux_Source_resolve_future; -moq_mux_Source_resolve_future *moq_mux_Source_resolve(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_status *status); -moq_poll moq_mux_Source_resolve_start(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_broadcast_Consumer **out, moq_mux_Error **err, moq_mux_Source_resolve_future **future, moq_status *status); -moq_poll moq_mux_Source_resolve_poll(moq_mux_Source_resolve_future *future, moq_waker waker, moq_broadcast_Consumer **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_Source_resolve_future *moq_mux_Source_resolve(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Source_resolve_start(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_broadcast_Consumer **out, moq_mux_Error **err, moq_mux_Source_resolve_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Source_resolve_poll(moq_mux_Source_resolve_future *future, moq_waker waker, moq_broadcast_Consumer **out, moq_mux_Error **err); void moq_mux_Source_resolve_future_free(moq_mux_Source_resolve_future *future); -bool moq_mux_Source_bind(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_mux_Binding **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_Source_bind(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_mux_Binding **out, moq_mux_Error **err, moq_status *status); typedef struct moq_mux_Source_subscribe_track_future moq_mux_Source_subscribe_track_future; -moq_mux_Source_subscribe_track_future *moq_mux_Source_subscribe_track(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_buf name, moq_status *status); -moq_poll moq_mux_Source_subscribe_track_start(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_buf name, moq_track_Subscriber **out, moq_mux_Error **err, moq_mux_Source_subscribe_track_future **future, moq_status *status); -moq_poll moq_mux_Source_subscribe_track_poll(moq_mux_Source_subscribe_track_future *future, moq_waker waker, moq_track_Subscriber **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_Source_subscribe_track_future *moq_mux_Source_subscribe_track(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_buf name, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Source_subscribe_track_start(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_buf name, moq_track_Subscriber **out, moq_mux_Error **err, moq_mux_Source_subscribe_track_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_Source_subscribe_track_poll(moq_mux_Source_subscribe_track_future *future, moq_waker waker, moq_track_Subscriber **out, moq_mux_Error **err); void moq_mux_Source_subscribe_track_future_free(moq_mux_Source_subscribe_track_future *future); -bool moq_mux_Source_follow(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_mux_follow_Instances **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_Source_follow(const moq_mux_Source *self, const moq_path_Relative *rel, const moq_Instance *instance, moq_mux_follow_Instances **out, moq_mux_Error **err, moq_status *status); void moq_mux_Error_free(moq_mux_Error *self); bool moq_mux_Error_borrowed(const moq_mux_Error *self); -moq_mux_Error *moq_mux_Error_clone(const moq_mux_Error *self); -moq_buf moq_mux_Error_to_string(const moq_mux_Error *self); -moq_buf moq_mux_Error_debug(const moq_mux_Error *self); +MOQ_MUST_USE moq_mux_Error *moq_mux_Error_clone(const moq_mux_Error *self); +MOQ_MUST_USE moq_buf moq_mux_Error_to_string(const moq_mux_Error *self); +MOQ_MUST_USE moq_buf moq_mux_Error_debug(const moq_mux_Error *self); void moq_tokio_Duration_free(moq_tokio_Duration *self); bool moq_tokio_Duration_borrowed(const moq_tokio_Duration *self); -moq_tokio_Duration *moq_tokio_Duration_clone(const moq_tokio_Duration *self); +MOQ_MUST_USE moq_tokio_Duration *moq_tokio_Duration_clone(const moq_tokio_Duration *self); bool moq_tokio_Duration_eq(const moq_tokio_Duration *a, const moq_tokio_Duration *b); uint64_t moq_tokio_Duration_hash(const moq_tokio_Duration *self); -moq_buf moq_tokio_Duration_to_string(const moq_tokio_Duration *self); -moq_buf moq_tokio_Duration_debug(const moq_tokio_Duration *self); -moq_tokio_Duration *moq_tokio_Duration_default(void); +MOQ_MUST_USE moq_buf moq_tokio_Duration_to_string(const moq_tokio_Duration *self); +MOQ_MUST_USE moq_buf moq_tokio_Duration_debug(const moq_tokio_Duration *self); +MOQ_MUST_USE moq_tokio_Duration *moq_tokio_Duration_default(void); void moq_tokio_Backoff_free(moq_tokio_Backoff *self); void moq_tokio_Backoff_drop(moq_tokio_Backoff *self, moq_status *status); -moq_tokio_Backoff *moq_tokio_Backoff_clone(const moq_tokio_Backoff *self, moq_status *status); -moq_buf moq_tokio_Backoff_debug(const moq_tokio_Backoff *self, moq_status *status); -moq_tokio_Backoff *moq_tokio_Backoff_default(void); -moq_tokio_Duration *moq_tokio_Backoff_initial_get(const moq_tokio_Backoff *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Backoff *moq_tokio_Backoff_clone(const moq_tokio_Backoff *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_Backoff_debug(const moq_tokio_Backoff *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Backoff *moq_tokio_Backoff_default(void); +MOQ_MUST_USE moq_tokio_Duration *moq_tokio_Backoff_initial_get(const moq_tokio_Backoff *self, moq_status *status); void moq_tokio_Backoff_initial_set(moq_tokio_Backoff *self, const moq_tokio_Duration *value, moq_status *status); uint32_t moq_tokio_Backoff_multiplier_get(const moq_tokio_Backoff *self, moq_status *status); void moq_tokio_Backoff_multiplier_set(moq_tokio_Backoff *self, uint32_t value, moq_status *status); -moq_moq_tokio_cli_Bound *moq_tokio_Backoff_max_get(const moq_tokio_Backoff *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_cli_Bound *moq_tokio_Backoff_max_get(const moq_tokio_Backoff *self, moq_status *status); void moq_tokio_Backoff_max_set(moq_tokio_Backoff *self, const moq_moq_tokio_cli_Bound *value, moq_status *status); -moq_tokio_Duration *moq_tokio_Backoff_healthy_get(const moq_tokio_Backoff *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Duration *moq_tokio_Backoff_healthy_get(const moq_tokio_Backoff *self, moq_status *status); void moq_tokio_Backoff_healthy_set(moq_tokio_Backoff *self, const moq_tokio_Duration *value, moq_status *status); -moq_moq_tokio_cli_Bound *moq_tokio_Backoff_timeout_get(const moq_tokio_Backoff *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_cli_Bound *moq_tokio_Backoff_timeout_get(const moq_tokio_Backoff *self, moq_status *status); void moq_tokio_Backoff_timeout_set(moq_tokio_Backoff *self, const moq_moq_tokio_cli_Bound *value, moq_status *status); moq_duration moq_tokio_Backoff_initial(const moq_tokio_Backoff *self, moq_status *status); moq_option_duration moq_tokio_Backoff_max(const moq_tokio_Backoff *self, moq_status *status); moq_option_duration moq_tokio_Backoff_timeout(const moq_tokio_Backoff *self, moq_status *status); void moq_tokio_Client_free(moq_tokio_Client *self); void moq_tokio_Client_drop(moq_tokio_Client *self, moq_status *status); -moq_tokio_Client *moq_tokio_Client_clone(const moq_tokio_Client *self, moq_status *status); -bool moq_tokio_Client_new(moq_tokio_client_Config *config, moq_tokio_Client **out, moq_tokio_Error **err, moq_status *status); -moq_tokio_Client *moq_tokio_Client_with_publisher_Producer(moq_tokio_Client *self, const moq_origin_Producer *publish, moq_status *status); -moq_tokio_Client *moq_tokio_Client_with_publisher_Consumer(moq_tokio_Client *self, const moq_origin_Consumer *publish, moq_status *status); -moq_tokio_Client *moq_tokio_Client_with_subscriber(moq_tokio_Client *self, moq_origin_Producer *subscribe, moq_status *status); -moq_tokio_Client *moq_tokio_Client_with_limits(moq_tokio_Client *self, moq_session_Limits limits, moq_status *status); -moq_tokio_Client *moq_tokio_Client_with_stats(moq_tokio_Client *self, moq_stats_Session *stats, moq_status *status); -moq_tokio_Client *moq_tokio_Client_with_cost(moq_tokio_Client *self, uint64_t cost, moq_status *status); -moq_tokio_Client *moq_tokio_Client_with_peer_node(moq_tokio_Client *self, uint64_t node, moq_status *status); -moq_tokio_Client *moq_tokio_Client_with_token(moq_tokio_Client *self, moq_setup_Token token, moq_status *status); -moq_tokio_Client *moq_tokio_Client_with_reconnect(moq_tokio_Client *self, bool reconnect, moq_status *status); -moq_tokio_Client *moq_tokio_Client_with_restart(moq_tokio_Client *self, moq_tokio_Restart restart, moq_status *status); -moq_tokio_Connection *moq_tokio_Client_connect(const moq_tokio_Client *self, moq_moq_tokio_Addrs *addrs, moq_status *status); +MOQ_MUST_USE moq_tokio_Client *moq_tokio_Client_clone(const moq_tokio_Client *self, moq_status *status); +MOQ_MUST_USE bool moq_tokio_Client_new(moq_tokio_client_Config *config, moq_tokio_Client **out, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE moq_tokio_Client *moq_tokio_Client_with_publisher_Producer(moq_tokio_Client *self, const moq_origin_Producer *publish, moq_status *status); +MOQ_MUST_USE moq_tokio_Client *moq_tokio_Client_with_publisher_Consumer(moq_tokio_Client *self, const moq_origin_Consumer *publish, moq_status *status); +MOQ_MUST_USE moq_tokio_Client *moq_tokio_Client_with_subscriber(moq_tokio_Client *self, moq_origin_Producer *subscribe, moq_status *status); +MOQ_MUST_USE moq_tokio_Client *moq_tokio_Client_with_limits(moq_tokio_Client *self, moq_session_Limits limits, moq_status *status); +MOQ_MUST_USE moq_tokio_Client *moq_tokio_Client_with_stats(moq_tokio_Client *self, moq_stats_Session *stats, moq_status *status); +MOQ_MUST_USE moq_tokio_Client *moq_tokio_Client_with_cost(moq_tokio_Client *self, uint64_t cost, moq_status *status); +MOQ_MUST_USE moq_tokio_Client *moq_tokio_Client_with_peer_node(moq_tokio_Client *self, uint64_t node, moq_status *status); +MOQ_MUST_USE moq_tokio_Client *moq_tokio_Client_with_token(moq_tokio_Client *self, moq_setup_Token token, moq_status *status); +MOQ_MUST_USE moq_tokio_Client *moq_tokio_Client_with_reconnect(moq_tokio_Client *self, bool reconnect, moq_status *status); +MOQ_MUST_USE moq_tokio_Client *moq_tokio_Client_with_restart(moq_tokio_Client *self, moq_tokio_Restart restart, moq_status *status); +MOQ_MUST_USE moq_tokio_Connection *moq_tokio_Client_connect(const moq_tokio_Client *self, moq_moq_tokio_Addrs *addrs, moq_status *status); typedef struct moq_tokio_Client_close_future moq_tokio_Client_close_future; -moq_tokio_Client_close_future *moq_tokio_Client_close(moq_tokio_Client *self, moq_status *status); -moq_poll moq_tokio_Client_close_start(moq_tokio_Client *self, moq_tokio_Client_close_future **future, moq_status *status); -moq_poll moq_tokio_Client_close_poll(moq_tokio_Client_close_future *future, moq_waker waker); +MOQ_MUST_USE moq_tokio_Client_close_future *moq_tokio_Client_close(moq_tokio_Client *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Client_close_start(moq_tokio_Client *self, moq_tokio_Client_close_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Client_close_poll(moq_tokio_Client_close_future *future, moq_waker waker); void moq_tokio_Client_close_future_free(moq_tokio_Client_close_future *future); -moq_tokio_Connection *moq_tokio_Client_publish(moq_tokio_Client *self, moq_origin_Consumer *origin, moq_status *status); -moq_tokio_Connection *moq_tokio_Client_consume(moq_tokio_Client *self, moq_origin_Producer *origin, moq_status *status); +MOQ_MUST_USE moq_tokio_Connection *moq_tokio_Client_publish(moq_tokio_Client *self, moq_origin_Consumer *origin, moq_status *status); +MOQ_MUST_USE moq_tokio_Connection *moq_tokio_Client_consume(moq_tokio_Client *self, moq_origin_Producer *origin, moq_status *status); void moq_tokio_Connection_free(moq_tokio_Connection *self); void moq_tokio_Connection_drop(moq_tokio_Connection *self, moq_status *status); -moq_tokio_Connection *moq_tokio_Connection_clone(const moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Connection *moq_tokio_Connection_clone(const moq_tokio_Connection *self, moq_status *status); void moq_tokio_Connection_abort(const moq_tokio_Connection *self, moq_Error *err_, moq_status *status); typedef struct moq_tokio_Connection_close_future moq_tokio_Connection_close_future; -moq_tokio_Connection_close_future *moq_tokio_Connection_close(moq_tokio_Connection *self, moq_status *status); -moq_poll moq_tokio_Connection_close_start(moq_tokio_Connection *self, moq_tokio_Error **err, moq_tokio_Connection_close_future **future, moq_status *status); -moq_poll moq_tokio_Connection_close_poll(moq_tokio_Connection_close_future *future, moq_waker waker, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_Connection_close_future *moq_tokio_Connection_close(moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Connection_close_start(moq_tokio_Connection *self, moq_tokio_Error **err, moq_tokio_Connection_close_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Connection_close_poll(moq_tokio_Connection_close_future *future, moq_waker waker, moq_tokio_Error **err); void moq_tokio_Connection_close_future_free(moq_tokio_Connection_close_future *future); typedef struct moq_tokio_Connection_established_future moq_tokio_Connection_established_future; -moq_tokio_Connection_established_future *moq_tokio_Connection_established(moq_tokio_Connection *self, moq_status *status); -moq_poll moq_tokio_Connection_established_start(moq_tokio_Connection *self, moq_tokio_Connection **out, moq_tokio_Error **err, moq_tokio_Connection_established_future **future, moq_status *status); -moq_poll moq_tokio_Connection_established_poll(moq_tokio_Connection_established_future *future, moq_waker waker, moq_tokio_Connection **out, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_Connection_established_future *moq_tokio_Connection_established(moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Connection_established_start(moq_tokio_Connection *self, moq_tokio_Connection **out, moq_tokio_Error **err, moq_tokio_Connection_established_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Connection_established_poll(moq_tokio_Connection_established_future *future, moq_waker waker, moq_tokio_Connection **out, moq_tokio_Error **err); void moq_tokio_Connection_established_future_free(moq_tokio_Connection_established_future *future); typedef struct moq_tokio_Connection_status_future moq_tokio_Connection_status_future; -moq_tokio_Connection_status_future *moq_tokio_Connection_status(moq_tokio_Connection *self, moq_status *status); -moq_poll moq_tokio_Connection_status_start(moq_tokio_Connection *self, moq_tokio_Status *out, moq_tokio_Error **err, moq_tokio_Connection_status_future **future, moq_status *status); -moq_poll moq_tokio_Connection_status_poll(moq_tokio_Connection_status_future *future, moq_waker waker, moq_tokio_Status *out, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_Connection_status_future *moq_tokio_Connection_status(moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Connection_status_start(moq_tokio_Connection *self, moq_tokio_Status *out, moq_tokio_Error **err, moq_tokio_Connection_status_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Connection_status_poll(moq_tokio_Connection_status_future *future, moq_waker waker, moq_tokio_Status *out, moq_tokio_Error **err); void moq_tokio_Connection_status_future_free(moq_tokio_Connection_status_future *future); bool moq_tokio_Connection_connected(const moq_tokio_Connection *self, moq_status *status); uint64_t moq_tokio_Connection_connects(const moq_tokio_Connection *self, moq_status *status); -moq_Version *moq_tokio_Connection_version(const moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_Version *moq_tokio_Connection_version(const moq_tokio_Connection *self, moq_status *status); moq_option_tokio_Transport moq_tokio_Connection_transport(const moq_tokio_Connection *self, moq_status *status); -moq_goaway_Consumer *moq_tokio_Connection_draining(const moq_tokio_Connection *self, moq_status *status); -moq_bandwidth_Consumer *moq_tokio_Connection_send_bandwidth(const moq_tokio_Connection *self, moq_status *status); -moq_bandwidth_Allocator *moq_tokio_Connection_allocator(const moq_tokio_Connection *self, moq_status *status); -moq_bandwidth_Consumer *moq_tokio_Connection_recv_bandwidth(const moq_tokio_Connection *self, moq_status *status); -moq_bandwidth_Viewers *moq_tokio_Connection_viewers(const moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_goaway_Consumer *moq_tokio_Connection_draining(const moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Consumer *moq_tokio_Connection_send_bandwidth(const moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Allocator *moq_tokio_Connection_allocator(const moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Consumer *moq_tokio_Connection_recv_bandwidth(const moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Viewers *moq_tokio_Connection_viewers(const moq_tokio_Connection *self, moq_status *status); typedef struct moq_tokio_Connection_closed_future moq_tokio_Connection_closed_future; -moq_tokio_Connection_closed_future *moq_tokio_Connection_closed(const moq_tokio_Connection *self, moq_status *status); -moq_poll moq_tokio_Connection_closed_start(const moq_tokio_Connection *self, moq_tokio_Error **err, moq_tokio_Connection_closed_future **future, moq_status *status); -moq_poll moq_tokio_Connection_closed_poll(moq_tokio_Connection_closed_future *future, moq_waker waker, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_Connection_closed_future *moq_tokio_Connection_closed(const moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Connection_closed_start(const moq_tokio_Connection *self, moq_tokio_Error **err, moq_tokio_Connection_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Connection_closed_poll(moq_tokio_Connection_closed_future *future, moq_waker waker, moq_tokio_Error **err); void moq_tokio_Connection_closed_future_free(moq_tokio_Connection_closed_future *future); -moq_auth_Handle *moq_tokio_Connection_auth(const moq_tokio_Connection *self, moq_status *status); -moq_auth_Tokens *moq_tokio_Connection_tokens(const moq_tokio_Connection *self, moq_status *status); -moq_tokio_connection_Monitor *moq_tokio_Connection_monitor(const moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_auth_Handle *moq_tokio_Connection_auth(const moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_auth_Tokens *moq_tokio_Connection_tokens(const moq_tokio_Connection *self, moq_status *status); +MOQ_MUST_USE moq_tokio_connection_Monitor *moq_tokio_Connection_monitor(const moq_tokio_Connection *self, moq_status *status); void moq_tokio_Error_free(moq_tokio_Error *self); bool moq_tokio_Error_borrowed(const moq_tokio_Error *self); -moq_tokio_Error *moq_tokio_Error_clone(const moq_tokio_Error *self); -moq_buf moq_tokio_Error_to_string(const moq_tokio_Error *self); -moq_buf moq_tokio_Error_debug(const moq_tokio_Error *self); +MOQ_MUST_USE moq_tokio_Error *moq_tokio_Error_clone(const moq_tokio_Error *self); +MOQ_MUST_USE moq_buf moq_tokio_Error_to_string(const moq_tokio_Error *self); +MOQ_MUST_USE moq_buf moq_tokio_Error_debug(const moq_tokio_Error *self); moq_option_tokio_ConnectError moq_tokio_Error_connect_error(const moq_tokio_Error *self); bool moq_tokio_Error_is_auth(const moq_tokio_Error *self); moq_option_u16 moq_tokio_Error_status(const moq_tokio_Error *self); void moq_tokio_Log_free(moq_tokio_Log *self); void moq_tokio_Log_drop(moq_tokio_Log *self, moq_status *status); -moq_tokio_Log *moq_tokio_Log_clone(const moq_tokio_Log *self, moq_status *status); -moq_buf moq_tokio_Log_debug(const moq_tokio_Log *self, moq_status *status); -moq_tokio_Log *moq_tokio_Log_default(void); +MOQ_MUST_USE moq_tokio_Log *moq_tokio_Log_clone(const moq_tokio_Log *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_Log_debug(const moq_tokio_Log *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Log *moq_tokio_Log_default(void); moq_Level moq_tokio_Log_level_get(const moq_tokio_Log *self, moq_status *status); void moq_tokio_Log_level_set(moq_tokio_Log *self, moq_Level value, moq_status *status); -moq_tokio_Log *moq_tokio_Log_new(moq_Level level); +MOQ_MUST_USE moq_tokio_Log *moq_tokio_Log_new(moq_Level level); moq_option_Level moq_tokio_Log_level(const moq_tokio_Log *self, moq_status *status); -bool moq_tokio_Log_init(const moq_tokio_Log *self, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_tokio_Log_init(const moq_tokio_Log *self, moq_tokio_Error **err, moq_status *status); void moq_tokio_Server_free(moq_tokio_Server *self); void moq_tokio_Server_drop(moq_tokio_Server *self, moq_status *status); -bool moq_tokio_Server_new(moq_tokio_server_Config *config, moq_tokio_Server **out, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_tokio_Server_new(moq_tokio_server_Config *config, moq_tokio_Server **out, moq_tokio_Error **err, moq_status *status); typedef struct moq_tokio_Server_serve_publish_future moq_tokio_Server_serve_publish_future; -moq_tokio_Server_serve_publish_future *moq_tokio_Server_serve_publish(moq_tokio_Server *self, moq_origin_Consumer *origin, moq_status *status); -moq_poll moq_tokio_Server_serve_publish_start(moq_tokio_Server *self, moq_origin_Consumer *origin, moq_tokio_Error **err, moq_tokio_Server_serve_publish_future **future, moq_status *status); -moq_poll moq_tokio_Server_serve_publish_poll(moq_tokio_Server_serve_publish_future *future, moq_waker waker, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_Server_serve_publish_future *moq_tokio_Server_serve_publish(moq_tokio_Server *self, moq_origin_Consumer *origin, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Server_serve_publish_start(moq_tokio_Server *self, moq_origin_Consumer *origin, moq_tokio_Error **err, moq_tokio_Server_serve_publish_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Server_serve_publish_poll(moq_tokio_Server_serve_publish_future *future, moq_waker waker, moq_tokio_Error **err); void moq_tokio_Server_serve_publish_future_free(moq_tokio_Server_serve_publish_future *future); -moq_moq_tokio_tcp_TlsAcceptor *moq_tokio_Server_tls_acceptor(const moq_tokio_Server *self, moq_status *status); -moq_tokio_tls_Certificates *moq_tokio_Server_certificates(const moq_tokio_Server *self, moq_status *status); -moq_vec_moq_tokio_accept_Health moq_tokio_Server_accept_health(const moq_tokio_Server *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_tcp_TlsAcceptor *moq_tokio_Server_tls_acceptor(const moq_tokio_Server *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Certificates *moq_tokio_Server_certificates(const moq_tokio_Server *self, moq_status *status); +MOQ_MUST_USE moq_vec_moq_tokio_accept_Health moq_tokio_Server_accept_health(const moq_tokio_Server *self, moq_status *status); typedef struct moq_tokio_Server_bind_future moq_tokio_Server_bind_future; -moq_tokio_Server_bind_future *moq_tokio_Server_bind(moq_tokio_Server *self, moq_status *status); -moq_poll moq_tokio_Server_bind_start(moq_tokio_Server *self, moq_tokio_server_Listener **out, moq_tokio_Error **err, moq_tokio_Server_bind_future **future, moq_status *status); -moq_poll moq_tokio_Server_bind_poll(moq_tokio_Server_bind_future *future, moq_waker waker, moq_tokio_server_Listener **out, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_Server_bind_future *moq_tokio_Server_bind(moq_tokio_Server *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Server_bind_start(moq_tokio_Server *self, moq_tokio_server_Listener **out, moq_tokio_Error **err, moq_tokio_Server_bind_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Server_bind_poll(moq_tokio_Server_bind_future *future, moq_waker waker, moq_tokio_server_Listener **out, moq_tokio_Error **err); void moq_tokio_Server_bind_future_free(moq_tokio_Server_bind_future *future); typedef struct moq_tokio_Server_listen_future moq_tokio_Server_listen_future; -moq_tokio_Server_listen_future *moq_tokio_Server_listen(moq_tokio_Server *self, moq_status *status); -moq_poll moq_tokio_Server_listen_start(moq_tokio_Server *self, moq_tokio_server_Listener **out, moq_tokio_Error **err, moq_tokio_Server_listen_future **future, moq_status *status); -moq_poll moq_tokio_Server_listen_poll(moq_tokio_Server_listen_future *future, moq_waker waker, moq_tokio_server_Listener **out, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_Server_listen_future *moq_tokio_Server_listen(moq_tokio_Server *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Server_listen_start(moq_tokio_Server *self, moq_tokio_server_Listener **out, moq_tokio_Error **err, moq_tokio_Server_listen_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_Server_listen_poll(moq_tokio_Server_listen_future *future, moq_waker waker, moq_tokio_server_Listener **out, moq_tokio_Error **err); void moq_tokio_Server_listen_future_free(moq_tokio_Server_listen_future *future); -bool moq_tokio_Server_local_addr(const moq_tokio_Server *self, moq_socket_addr *out, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_tokio_Server_local_addr(const moq_tokio_Server *self, moq_socket_addr *out, moq_tokio_Error **err, moq_status *status); moq_option_socket_addr moq_tokio_Server_websocket_local_addr(const moq_tokio_Server *self, moq_status *status); void moq_auth_Watch_free(moq_auth_Watch *self); void moq_auth_Watch_drop(moq_auth_Watch *self, moq_status *status); -moq_auth_Grant *moq_auth_Watch_peek(const moq_auth_Watch *self, moq_status *status); +MOQ_MUST_USE moq_auth_Grant *moq_auth_Watch_peek(const moq_auth_Watch *self, moq_status *status); typedef struct moq_auth_Watch_changed_future moq_auth_Watch_changed_future; -moq_auth_Watch_changed_future *moq_auth_Watch_changed(moq_auth_Watch *self, moq_status *status); -moq_poll moq_auth_Watch_changed_start(moq_auth_Watch *self, moq_auth_Grant **out, moq_Error **err, moq_auth_Watch_changed_future **future, moq_status *status); -moq_poll moq_auth_Watch_changed_poll(moq_auth_Watch_changed_future *future, moq_waker waker, moq_auth_Grant **out, moq_Error **err); +MOQ_MUST_USE moq_auth_Watch_changed_future *moq_auth_Watch_changed(moq_auth_Watch *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Watch_changed_start(moq_auth_Watch *self, moq_auth_Grant **out, moq_Error **err, moq_auth_Watch_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Watch_changed_poll(moq_auth_Watch_changed_future *future, moq_waker waker, moq_auth_Grant **out, moq_Error **err); void moq_auth_Watch_changed_future_free(moq_auth_Watch_changed_future *future); void moq_auth_Requests_free(moq_auth_Requests *self); void moq_auth_Requests_drop(moq_auth_Requests *self, moq_status *status); typedef struct moq_auth_Requests_next_future moq_auth_Requests_next_future; -moq_auth_Requests_next_future *moq_auth_Requests_next(moq_auth_Requests *self, moq_status *status); -moq_poll moq_auth_Requests_next_start(moq_auth_Requests *self, moq_auth_Request **out, moq_auth_Requests_next_future **future, moq_status *status); -moq_poll moq_auth_Requests_next_poll(moq_auth_Requests_next_future *future, moq_waker waker, moq_auth_Request **out); +MOQ_MUST_USE moq_auth_Requests_next_future *moq_auth_Requests_next(moq_auth_Requests *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Requests_next_start(moq_auth_Requests *self, moq_auth_Request **out, moq_auth_Requests_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Requests_next_poll(moq_auth_Requests_next_future *future, moq_waker waker, moq_auth_Request **out); void moq_auth_Requests_next_future_free(moq_auth_Requests_next_future *future); void moq_auth_Request_free(moq_auth_Request *self); void moq_auth_Request_drop(moq_auth_Request *self, moq_status *status); -moq_buf moq_auth_Request_token(const moq_auth_Request *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_auth_Request_token(const moq_auth_Request *self, moq_status *status); typedef struct moq_auth_Request_closed_future moq_auth_Request_closed_future; -moq_auth_Request_closed_future *moq_auth_Request_closed(const moq_auth_Request *self, moq_status *status); -moq_poll moq_auth_Request_closed_start(const moq_auth_Request *self, moq_Error **out, moq_auth_Request_closed_future **future, moq_status *status); -moq_poll moq_auth_Request_closed_poll(moq_auth_Request_closed_future *future, moq_waker waker, moq_Error **out); +MOQ_MUST_USE moq_auth_Request_closed_future *moq_auth_Request_closed(const moq_auth_Request *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Request_closed_start(const moq_auth_Request *self, moq_Error **out, moq_auth_Request_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Request_closed_poll(moq_auth_Request_closed_future *future, moq_waker waker, moq_Error **out); void moq_auth_Request_closed_future_free(moq_auth_Request_closed_future *future); -moq_auth_Issued *moq_auth_Request_accept(moq_auth_Request *self, moq_auth_Grant *grant, moq_status *status); +MOQ_MUST_USE moq_auth_Issued *moq_auth_Request_accept(moq_auth_Request *self, moq_auth_Grant *grant, moq_status *status); void moq_auth_Request_reject(moq_auth_Request *self, moq_SessionError code, moq_buf reason, moq_status *status); void moq_auth_Issued_free(moq_auth_Issued *self); void moq_auth_Issued_drop(moq_auth_Issued *self, moq_status *status); void moq_auth_Issued_update(const moq_auth_Issued *self, moq_auth_Grant *grant, moq_status *status); void moq_auth_Issued_revoke(moq_auth_Issued *self, moq_SessionError code, moq_buf reason, moq_status *status); typedef struct moq_auth_Issued_closed_future moq_auth_Issued_closed_future; -moq_auth_Issued_closed_future *moq_auth_Issued_closed(const moq_auth_Issued *self, moq_status *status); -moq_poll moq_auth_Issued_closed_start(const moq_auth_Issued *self, moq_Error **out, moq_auth_Issued_closed_future **future, moq_status *status); -moq_poll moq_auth_Issued_closed_poll(moq_auth_Issued_closed_future *future, moq_waker waker, moq_Error **out); +MOQ_MUST_USE moq_auth_Issued_closed_future *moq_auth_Issued_closed(const moq_auth_Issued *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Issued_closed_start(const moq_auth_Issued *self, moq_Error **out, moq_auth_Issued_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Issued_closed_poll(moq_auth_Issued_closed_future *future, moq_waker waker, moq_Error **out); void moq_auth_Issued_closed_future_free(moq_auth_Issued_closed_future *future); void moq_auth_Grant_free(moq_auth_Grant *self); void moq_auth_Grant_drop(moq_auth_Grant *self, moq_status *status); -moq_auth_Grant *moq_auth_Grant_clone(const moq_auth_Grant *self, moq_status *status); +MOQ_MUST_USE moq_auth_Grant *moq_auth_Grant_clone(const moq_auth_Grant *self, moq_status *status); bool moq_auth_Grant_eq(const moq_auth_Grant *a, const moq_auth_Grant *b, moq_status *status); -moq_buf moq_auth_Grant_debug(const moq_auth_Grant *self, moq_status *status); -moq_auth_Grant *moq_auth_Grant_default(void); -moq_Patterns *moq_auth_Grant_publish_get(const moq_auth_Grant *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_auth_Grant_debug(const moq_auth_Grant *self, moq_status *status); +MOQ_MUST_USE moq_auth_Grant *moq_auth_Grant_default(void); +MOQ_MUST_USE moq_Patterns *moq_auth_Grant_publish_get(const moq_auth_Grant *self, moq_status *status); void moq_auth_Grant_publish_set(moq_auth_Grant *self, moq_Patterns *value, moq_status *status); -moq_Patterns *moq_auth_Grant_subscribe_get(const moq_auth_Grant *self, moq_status *status); +MOQ_MUST_USE moq_Patterns *moq_auth_Grant_subscribe_get(const moq_auth_Grant *self, moq_status *status); void moq_auth_Grant_subscribe_set(moq_auth_Grant *self, moq_Patterns *value, moq_status *status); moq_option_clock_Instant moq_auth_Grant_expires_get(const moq_auth_Grant *self, moq_status *status); void moq_auth_Grant_expires_set(moq_auth_Grant *self, moq_option_clock_Instant value, moq_status *status); -moq_auth_Grant *moq_auth_Grant_all(void); +MOQ_MUST_USE moq_auth_Grant *moq_auth_Grant_all(void); void moq_auth_Handle_free(moq_auth_Handle *self); void moq_auth_Handle_drop(moq_auth_Handle *self, moq_status *status); -moq_auth_Handle *moq_auth_Handle_clone(const moq_auth_Handle *self, moq_status *status); -moq_auth_Handle *moq_auth_Handle_default(void); -moq_auth_Handle *moq_auth_Handle_new(void); -moq_auth_Watch *moq_auth_Handle_grant(const moq_auth_Handle *self, moq_status *status); -bool moq_auth_Handle_add(const moq_auth_Handle *self, moq_buf token, moq_auth_Credential **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_auth_Handle *moq_auth_Handle_clone(const moq_auth_Handle *self, moq_status *status); +MOQ_MUST_USE moq_auth_Handle *moq_auth_Handle_default(void); +MOQ_MUST_USE moq_auth_Handle *moq_auth_Handle_new(void); +MOQ_MUST_USE moq_auth_Watch *moq_auth_Handle_grant(const moq_auth_Handle *self, moq_status *status); +MOQ_MUST_USE bool moq_auth_Handle_add(const moq_auth_Handle *self, moq_buf token, moq_auth_Credential **out, moq_Error **err, moq_status *status); void moq_auth_Handle_authorize(const moq_auth_Handle *self, const moq_auth_Grant *grant, moq_status *status); void moq_auth_Handle_abort(const moq_auth_Handle *self, moq_Error *err_, moq_status *status); void moq_auth_Credential_free(moq_auth_Credential *self); void moq_auth_Credential_drop(moq_auth_Credential *self, moq_status *status); bool moq_auth_Credential_borrowed(const moq_auth_Credential *self); -moq_auth_Credential *moq_auth_Credential_clone(const moq_auth_Credential *self, moq_status *status); +MOQ_MUST_USE moq_auth_Credential *moq_auth_Credential_clone(const moq_auth_Credential *self, moq_status *status); bool moq_auth_Credential_eq(const moq_auth_Credential *a, const moq_auth_Credential *b, moq_status *status); -moq_buf moq_auth_Credential_debug(const moq_auth_Credential *self, moq_status *status); -moq_auth_Watch *moq_auth_Credential_grant(const moq_auth_Credential *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_auth_Credential_debug(const moq_auth_Credential *self, moq_status *status); +MOQ_MUST_USE moq_auth_Watch *moq_auth_Credential_grant(const moq_auth_Credential *self, moq_status *status); typedef struct moq_auth_Credential_closed_future moq_auth_Credential_closed_future; -moq_auth_Credential_closed_future *moq_auth_Credential_closed(const moq_auth_Credential *self, moq_status *status); -moq_poll moq_auth_Credential_closed_start(const moq_auth_Credential *self, moq_Error **out, moq_auth_Credential_closed_future **future, moq_status *status); -moq_poll moq_auth_Credential_closed_poll(moq_auth_Credential_closed_future *future, moq_waker waker, moq_Error **out); +MOQ_MUST_USE moq_auth_Credential_closed_future *moq_auth_Credential_closed(const moq_auth_Credential *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Credential_closed_start(const moq_auth_Credential *self, moq_Error **out, moq_auth_Credential_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Credential_closed_poll(moq_auth_Credential_closed_future *future, moq_waker waker, moq_Error **out); void moq_auth_Credential_closed_future_free(moq_auth_Credential_closed_future *future); typedef struct moq_auth_Credential_answered_future moq_auth_Credential_answered_future; -moq_auth_Credential_answered_future *moq_auth_Credential_answered(const moq_auth_Credential *self, moq_status *status); -moq_poll moq_auth_Credential_answered_start(const moq_auth_Credential *self, moq_Error **err, moq_auth_Credential_answered_future **future, moq_status *status); -moq_poll moq_auth_Credential_answered_poll(moq_auth_Credential_answered_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_auth_Credential_answered_future *moq_auth_Credential_answered(const moq_auth_Credential *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Credential_answered_start(const moq_auth_Credential *self, moq_Error **err, moq_auth_Credential_answered_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_auth_Credential_answered_poll(moq_auth_Credential_answered_future *future, moq_waker waker, moq_Error **err); void moq_auth_Credential_answered_future_free(moq_auth_Credential_answered_future *future); void moq_auth_Token_free(moq_auth_Token *self); void moq_auth_Token_drop(moq_auth_Token *self, moq_status *status); bool moq_auth_Token_borrowed(const moq_auth_Token *self); -moq_auth_Token *moq_auth_Token_clone(const moq_auth_Token *self, moq_status *status); +MOQ_MUST_USE moq_auth_Token *moq_auth_Token_clone(const moq_auth_Token *self, moq_status *status); bool moq_auth_Token_eq(const moq_auth_Token *a, const moq_auth_Token *b, moq_status *status); -moq_buf moq_auth_Token_debug(const moq_auth_Token *self, moq_status *status); -moq_buf moq_auth_Token_as_str(const moq_auth_Token *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_auth_Token_debug(const moq_auth_Token *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_auth_Token_as_str(const moq_auth_Token *self, moq_status *status); void moq_auth_Tokens_free(moq_auth_Tokens *self); -moq_auth_Tokens *moq_auth_Tokens_clone(const moq_auth_Tokens *self); -moq_auth_Tokens *moq_auth_Tokens_new(moq_vec_auth_Token tokens, moq_status *status); -moq_auth_Handle *moq_auth_Tokens_handle(const moq_auth_Tokens *self); +MOQ_MUST_USE moq_auth_Tokens *moq_auth_Tokens_clone(const moq_auth_Tokens *self); +MOQ_MUST_USE moq_auth_Tokens *moq_auth_Tokens_new(moq_vec_auth_Token tokens, moq_status *status); +MOQ_MUST_USE moq_auth_Handle *moq_auth_Tokens_handle(const moq_auth_Tokens *self); void moq_auth_Tokens_set(const moq_auth_Tokens *self, moq_vec_auth_Token tokens, moq_status *status); typedef struct moq_auth_Tokens_answered_future moq_auth_Tokens_answered_future; -moq_auth_Tokens_answered_future *moq_auth_Tokens_answered(const moq_auth_Tokens *self); -moq_poll moq_auth_Tokens_answered_start(const moq_auth_Tokens *self, moq_Error **err, moq_auth_Tokens_answered_future **future); -moq_poll moq_auth_Tokens_answered_poll(moq_auth_Tokens_answered_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_auth_Tokens_answered_future *moq_auth_Tokens_answered(const moq_auth_Tokens *self); +MOQ_MUST_USE moq_poll moq_auth_Tokens_answered_start(const moq_auth_Tokens *self, moq_Error **err, moq_auth_Tokens_answered_future **future); +MOQ_MUST_USE moq_poll moq_auth_Tokens_answered_poll(moq_auth_Tokens_answered_future *future, moq_waker waker, moq_Error **err); void moq_auth_Tokens_answered_future_free(moq_auth_Tokens_answered_future *future); void moq_goaway_Goaway_free(moq_goaway_Goaway *self); void moq_goaway_Goaway_drop(moq_goaway_Goaway *self, moq_status *status); bool moq_goaway_Goaway_borrowed(const moq_goaway_Goaway *self); -moq_goaway_Goaway *moq_goaway_Goaway_clone(const moq_goaway_Goaway *self, moq_status *status); +MOQ_MUST_USE moq_goaway_Goaway *moq_goaway_Goaway_clone(const moq_goaway_Goaway *self, moq_status *status); bool moq_goaway_Goaway_eq(const moq_goaway_Goaway *a, const moq_goaway_Goaway *b, moq_status *status); -moq_buf moq_goaway_Goaway_debug(const moq_goaway_Goaway *self, moq_status *status); -moq_goaway_Goaway *moq_goaway_Goaway_default(void); -moq_goaway_Goaway *moq_goaway_Goaway_new(void); -moq_goaway_Goaway *moq_goaway_Goaway_redirect(moq_buf uri); -moq_goaway_Goaway *moq_goaway_Goaway_with_timeout(moq_goaway_Goaway *self, moq_option_duration timeout, moq_status *status); -moq_buf moq_goaway_Goaway_uri(const moq_goaway_Goaway *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_goaway_Goaway_debug(const moq_goaway_Goaway *self, moq_status *status); +MOQ_MUST_USE moq_goaway_Goaway *moq_goaway_Goaway_default(void); +MOQ_MUST_USE moq_goaway_Goaway *moq_goaway_Goaway_new(void); +MOQ_MUST_USE moq_goaway_Goaway *moq_goaway_Goaway_redirect(moq_buf uri); +MOQ_MUST_USE moq_goaway_Goaway *moq_goaway_Goaway_with_timeout(moq_goaway_Goaway *self, moq_option_duration timeout, moq_status *status); +MOQ_MUST_USE moq_buf moq_goaway_Goaway_uri(const moq_goaway_Goaway *self, moq_status *status); moq_option_duration moq_goaway_Goaway_timeout(const moq_goaway_Goaway *self, moq_status *status); void moq_goaway_Consumer_free(moq_goaway_Consumer *self); -moq_goaway_Consumer *moq_goaway_Consumer_clone(const moq_goaway_Consumer *self); +MOQ_MUST_USE moq_goaway_Consumer *moq_goaway_Consumer_clone(const moq_goaway_Consumer *self); typedef struct moq_goaway_Consumer_poll_future moq_goaway_Consumer_poll_future; -moq_goaway_Consumer_poll_future *moq_goaway_Consumer_poll(const moq_goaway_Consumer *self); -moq_poll moq_goaway_Consumer_poll_start(const moq_goaway_Consumer *self, moq_goaway_Goaway **out, moq_Error **err, moq_goaway_Consumer_poll_future **future); -moq_poll moq_goaway_Consumer_poll_poll(moq_goaway_Consumer_poll_future *future, moq_waker waker, moq_goaway_Goaway **out, moq_Error **err); +MOQ_MUST_USE moq_goaway_Consumer_poll_future *moq_goaway_Consumer_poll(const moq_goaway_Consumer *self); +MOQ_MUST_USE moq_poll moq_goaway_Consumer_poll_start(const moq_goaway_Consumer *self, moq_goaway_Goaway **out, moq_Error **err, moq_goaway_Consumer_poll_future **future); +MOQ_MUST_USE moq_poll moq_goaway_Consumer_poll_poll(moq_goaway_Consumer_poll_future *future, moq_waker waker, moq_goaway_Goaway **out, moq_Error **err); void moq_goaway_Consumer_poll_future_free(moq_goaway_Consumer_poll_future *future); void moq_path_Relative_free(moq_path_Relative *self); void moq_path_Relative_drop(moq_path_Relative *self, moq_status *status); bool moq_path_Relative_borrowed(const moq_path_Relative *self); -moq_path_Relative *moq_path_Relative_clone(const moq_path_Relative *self, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_path_Relative_clone(const moq_path_Relative *self, moq_status *status); bool moq_path_Relative_eq(const moq_path_Relative *a, const moq_path_Relative *b, moq_status *status); uint64_t moq_path_Relative_hash(const moq_path_Relative *self, moq_status *status); -moq_buf moq_path_Relative_to_string(const moq_path_Relative *self, moq_status *status); -moq_buf moq_path_Relative_debug(const moq_path_Relative *self, moq_status *status); -moq_path_Relative *moq_path_Relative_default(void); -bool moq_path_Relative_new(moq_buf s, moq_path_Relative **out, moq_path_Error *err); -moq_buf moq_path_Relative_as_str(const moq_path_Relative *self, moq_status *status); -moq_path_Relative *moq_path_Relative_empty(void); +MOQ_MUST_USE moq_buf moq_path_Relative_to_string(const moq_path_Relative *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_path_Relative_debug(const moq_path_Relative *self, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_path_Relative_default(void); +MOQ_MUST_USE bool moq_path_Relative_new(moq_buf s, moq_path_Relative **out, moq_path_Error *err); +MOQ_MUST_USE moq_buf moq_path_Relative_as_str(const moq_path_Relative *self, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_path_Relative_empty(void); bool moq_path_Relative_is_empty(const moq_path_Relative *self, moq_status *status); size_t moq_path_Relative_len(const moq_path_Relative *self, moq_status *status); void moq_reconnect_Backoff_free(moq_reconnect_Backoff *self); void moq_reconnect_Backoff_drop(moq_reconnect_Backoff *self, moq_status *status); -moq_reconnect_Backoff *moq_reconnect_Backoff_clone(const moq_reconnect_Backoff *self, moq_status *status); +MOQ_MUST_USE moq_reconnect_Backoff *moq_reconnect_Backoff_clone(const moq_reconnect_Backoff *self, moq_status *status); bool moq_reconnect_Backoff_eq(const moq_reconnect_Backoff *a, const moq_reconnect_Backoff *b, moq_status *status); -moq_buf moq_reconnect_Backoff_debug(const moq_reconnect_Backoff *self, moq_status *status); -moq_reconnect_Backoff *moq_reconnect_Backoff_default(void); +MOQ_MUST_USE moq_buf moq_reconnect_Backoff_debug(const moq_reconnect_Backoff *self, moq_status *status); +MOQ_MUST_USE moq_reconnect_Backoff *moq_reconnect_Backoff_default(void); moq_duration moq_reconnect_Backoff_initial_get(const moq_reconnect_Backoff *self, moq_status *status); void moq_reconnect_Backoff_initial_set(moq_reconnect_Backoff *self, moq_duration value, moq_status *status); uint32_t moq_reconnect_Backoff_multiplier_get(const moq_reconnect_Backoff *self, moq_status *status); @@ -3848,23 +3858,23 @@ moq_option_duration moq_reconnect_Backoff_timeout_get(const moq_reconnect_Backof void moq_reconnect_Backoff_timeout_set(moq_reconnect_Backoff *self, moq_option_duration value, moq_status *status); void moq_reconnect_Handover_free(moq_reconnect_Handover *self); void moq_reconnect_Handover_drop(moq_reconnect_Handover *self, moq_status *status); -moq_reconnect_Handover *moq_reconnect_Handover_clone(const moq_reconnect_Handover *self, moq_status *status); +MOQ_MUST_USE moq_reconnect_Handover *moq_reconnect_Handover_clone(const moq_reconnect_Handover *self, moq_status *status); bool moq_reconnect_Handover_eq(const moq_reconnect_Handover *a, const moq_reconnect_Handover *b, moq_status *status); -moq_buf moq_reconnect_Handover_debug(const moq_reconnect_Handover *self, moq_status *status); -moq_reconnect_Handover *moq_reconnect_Handover_default(void); +MOQ_MUST_USE moq_buf moq_reconnect_Handover_debug(const moq_reconnect_Handover *self, moq_status *status); +MOQ_MUST_USE moq_reconnect_Handover *moq_reconnect_Handover_default(void); moq_reconnect_Redirect moq_reconnect_Handover_redirect_get(const moq_reconnect_Handover *self, moq_status *status); void moq_reconnect_Handover_redirect_set(moq_reconnect_Handover *self, moq_reconnect_Redirect value, moq_status *status); moq_duration moq_reconnect_Handover_handover_get(const moq_reconnect_Handover *self, moq_status *status); void moq_reconnect_Handover_handover_set(moq_reconnect_Handover *self, moq_duration value, moq_status *status); void moq_reconnect_Config_free(moq_reconnect_Config *self); void moq_reconnect_Config_drop(moq_reconnect_Config *self, moq_status *status); -moq_reconnect_Config *moq_reconnect_Config_clone(const moq_reconnect_Config *self, moq_status *status); +MOQ_MUST_USE moq_reconnect_Config *moq_reconnect_Config_clone(const moq_reconnect_Config *self, moq_status *status); bool moq_reconnect_Config_eq(const moq_reconnect_Config *a, const moq_reconnect_Config *b, moq_status *status); -moq_buf moq_reconnect_Config_debug(const moq_reconnect_Config *self, moq_status *status); -moq_reconnect_Config *moq_reconnect_Config_default(void); -moq_reconnect_Backoff *moq_reconnect_Config_backoff_get(const moq_reconnect_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_reconnect_Config_debug(const moq_reconnect_Config *self, moq_status *status); +MOQ_MUST_USE moq_reconnect_Config *moq_reconnect_Config_default(void); +MOQ_MUST_USE moq_reconnect_Backoff *moq_reconnect_Config_backoff_get(const moq_reconnect_Config *self, moq_status *status); void moq_reconnect_Config_backoff_set(moq_reconnect_Config *self, const moq_reconnect_Backoff *value, moq_status *status); -moq_reconnect_Handover *moq_reconnect_Config_goaway_get(const moq_reconnect_Config *self, moq_status *status); +MOQ_MUST_USE moq_reconnect_Handover *moq_reconnect_Config_goaway_get(const moq_reconnect_Config *self, moq_status *status); void moq_reconnect_Config_goaway_set(moq_reconnect_Config *self, const moq_reconnect_Handover *value, moq_status *status); moq_tokio_Restart moq_reconnect_Config_restart_get(const moq_reconnect_Config *self, moq_status *status); void moq_reconnect_Config_restart_set(moq_reconnect_Config *self, moq_tokio_Restart value, moq_status *status); @@ -3876,52 +3886,52 @@ bool moq_reconnect_Config_pinned_get(const moq_reconnect_Config *self, moq_statu void moq_reconnect_Config_pinned_set(moq_reconnect_Config *self, bool value, moq_status *status); void moq_server_Handshake_free(moq_server_Handshake *self); void moq_server_Handshake_drop(moq_server_Handshake *self, moq_status *status); -moq_buf moq_server_Handshake_path(const moq_server_Handshake *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_server_Handshake_path(const moq_server_Handshake *self, moq_status *status); moq_option_setup_Role moq_server_Handshake_role(const moq_server_Handshake *self, moq_status *status); moq_option_non_zero_u64 moq_server_Handshake_peer_node(const moq_server_Handshake *self, moq_status *status); -moq_buf moq_server_Handshake_peer_implementation(const moq_server_Handshake *self, moq_status *status); -moq_auth_Handle *moq_server_Handshake_auth(const moq_server_Handshake *self, moq_status *status); -moq_auth_Requests *moq_server_Handshake_requests(moq_server_Handshake *self, moq_status *status); -moq_option_setup_Token moq_server_Handshake_token(const moq_server_Handshake *self, moq_status *status); -moq_server_Handshake *moq_server_Handshake_with_publisher_Producer(moq_server_Handshake *self, const moq_origin_Producer *publish, moq_status *status); -moq_server_Handshake *moq_server_Handshake_with_publisher_Consumer(moq_server_Handshake *self, const moq_origin_Consumer *publish, moq_status *status); -moq_server_Handshake *moq_server_Handshake_with_subscriber(moq_server_Handshake *self, moq_origin_Producer *subscribe, moq_status *status); -moq_server_Handshake *moq_server_Handshake_with_peer_node(moq_server_Handshake *self, uint64_t node, moq_status *status); -moq_server_Handshake *moq_server_Handshake_with_stats(moq_server_Handshake *self, moq_stats_Session *stats, moq_status *status); -moq_server_Handshake *moq_server_Handshake_with_limits(moq_server_Handshake *self, moq_session_Limits limits, moq_status *status); -moq_server_Handshake *moq_server_Handshake_with_receive_window(moq_server_Handshake *self, uint64_t window, moq_status *status); +MOQ_MUST_USE moq_buf moq_server_Handshake_peer_implementation(const moq_server_Handshake *self, moq_status *status); +MOQ_MUST_USE moq_auth_Handle *moq_server_Handshake_auth(const moq_server_Handshake *self, moq_status *status); +MOQ_MUST_USE moq_auth_Requests *moq_server_Handshake_requests(moq_server_Handshake *self, moq_status *status); +MOQ_MUST_USE moq_option_setup_Token moq_server_Handshake_token(const moq_server_Handshake *self, moq_status *status); +MOQ_MUST_USE moq_server_Handshake *moq_server_Handshake_with_publisher_Producer(moq_server_Handshake *self, const moq_origin_Producer *publish, moq_status *status); +MOQ_MUST_USE moq_server_Handshake *moq_server_Handshake_with_publisher_Consumer(moq_server_Handshake *self, const moq_origin_Consumer *publish, moq_status *status); +MOQ_MUST_USE moq_server_Handshake *moq_server_Handshake_with_subscriber(moq_server_Handshake *self, moq_origin_Producer *subscribe, moq_status *status); +MOQ_MUST_USE moq_server_Handshake *moq_server_Handshake_with_peer_node(moq_server_Handshake *self, uint64_t node, moq_status *status); +MOQ_MUST_USE moq_server_Handshake *moq_server_Handshake_with_stats(moq_server_Handshake *self, moq_stats_Session *stats, moq_status *status); +MOQ_MUST_USE moq_server_Handshake *moq_server_Handshake_with_limits(moq_server_Handshake *self, moq_session_Limits limits, moq_status *status); +MOQ_MUST_USE moq_server_Handshake *moq_server_Handshake_with_receive_window(moq_server_Handshake *self, uint64_t window, moq_status *status); typedef struct moq_server_Handshake_expired_future moq_server_Handshake_expired_future; -moq_server_Handshake_expired_future *moq_server_Handshake_expired(moq_server_Handshake *self, moq_status *status); -moq_poll moq_server_Handshake_expired_start(moq_server_Handshake *self, moq_server_Handshake_expired_future **future, moq_status *status); -moq_poll moq_server_Handshake_expired_poll(moq_server_Handshake_expired_future *future, moq_waker waker); +MOQ_MUST_USE moq_server_Handshake_expired_future *moq_server_Handshake_expired(moq_server_Handshake *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_server_Handshake_expired_start(moq_server_Handshake *self, moq_server_Handshake_expired_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_server_Handshake_expired_poll(moq_server_Handshake_expired_future *future, moq_waker waker); void moq_server_Handshake_expired_future_free(moq_server_Handshake_expired_future *future); typedef struct moq_server_Handshake_ok_future moq_server_Handshake_ok_future; -moq_server_Handshake_ok_future *moq_server_Handshake_ok(moq_server_Handshake *self, moq_status *status); -moq_poll moq_server_Handshake_ok_start(moq_server_Handshake *self, moq_Session **out0, moq_Driver **out1, moq_Error **err, moq_server_Handshake_ok_future **future, moq_status *status); -moq_poll moq_server_Handshake_ok_poll(moq_server_Handshake_ok_future *future, moq_waker waker, moq_Session **out0, moq_Driver **out1, moq_Error **err); +MOQ_MUST_USE moq_server_Handshake_ok_future *moq_server_Handshake_ok(moq_server_Handshake *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_server_Handshake_ok_start(moq_server_Handshake *self, moq_Session **out0, moq_Driver **out1, moq_Error **err, moq_server_Handshake_ok_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_server_Handshake_ok_poll(moq_server_Handshake_ok_future *future, moq_waker waker, moq_Session **out0, moq_Driver **out1, moq_Error **err); void moq_server_Handshake_ok_future_free(moq_server_Handshake_ok_future *future); void moq_server_Handshake_close(moq_server_Handshake *self, moq_Error *err_, moq_status *status); void moq_server_Admission_free(moq_server_Admission *self); void moq_server_Admission_drop(moq_server_Admission *self, moq_status *status); bool moq_server_Admission_borrowed(const moq_server_Admission *self); -moq_server_Admission *moq_server_Admission_clone(const moq_server_Admission *self, moq_status *status); -moq_buf moq_server_Admission_debug(const moq_server_Admission *self, moq_status *status); -moq_server_Admission *moq_server_Admission_default(void); -moq_server_Admitted *moq_server_Admission_enter(const moq_server_Admission *self, moq_status *status); +MOQ_MUST_USE moq_server_Admission *moq_server_Admission_clone(const moq_server_Admission *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_server_Admission_debug(const moq_server_Admission *self, moq_status *status); +MOQ_MUST_USE moq_server_Admission *moq_server_Admission_default(void); +MOQ_MUST_USE moq_server_Admitted *moq_server_Admission_enter(const moq_server_Admission *self, moq_status *status); void moq_server_Admission_drain(const moq_server_Admission *self, moq_status *status); typedef struct moq_server_Admission_close_future moq_server_Admission_close_future; -moq_server_Admission_close_future *moq_server_Admission_close(const moq_server_Admission *self, moq_status *status); -moq_poll moq_server_Admission_close_start(const moq_server_Admission *self, moq_clock_Instant *out, moq_server_Admission_close_future **future, moq_status *status); -moq_poll moq_server_Admission_close_poll(moq_server_Admission_close_future *future, moq_waker waker, moq_clock_Instant *out); +MOQ_MUST_USE moq_server_Admission_close_future *moq_server_Admission_close(const moq_server_Admission *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_server_Admission_close_start(const moq_server_Admission *self, moq_clock_Instant *out, moq_server_Admission_close_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_server_Admission_close_poll(moq_server_Admission_close_future *future, moq_waker waker, moq_clock_Instant *out); void moq_server_Admission_close_future_free(moq_server_Admission_close_future *future); void moq_server_Admitted_free(moq_server_Admitted *self); -moq_buf moq_server_Admitted_debug(const moq_server_Admitted *self); +MOQ_MUST_USE moq_buf moq_server_Admitted_debug(const moq_server_Admitted *self); void moq_session_Stats_free(moq_session_Stats *self); void moq_session_Stats_drop(moq_session_Stats *self, moq_status *status); -moq_session_Stats *moq_session_Stats_clone(const moq_session_Stats *self, moq_status *status); +MOQ_MUST_USE moq_session_Stats *moq_session_Stats_clone(const moq_session_Stats *self, moq_status *status); bool moq_session_Stats_eq(const moq_session_Stats *a, const moq_session_Stats *b, moq_status *status); -moq_buf moq_session_Stats_debug(const moq_session_Stats *self, moq_status *status); -moq_session_Stats *moq_session_Stats_default(void); +MOQ_MUST_USE moq_buf moq_session_Stats_debug(const moq_session_Stats *self, moq_status *status); +MOQ_MUST_USE moq_session_Stats *moq_session_Stats_default(void); moq_option_duration moq_session_Stats_rtt_get(const moq_session_Stats *self, moq_status *status); void moq_session_Stats_rtt_set(moq_session_Stats *self, moq_option_duration value, moq_status *status); moq_option_bandwidth_Rate moq_session_Stats_estimated_send_rate_get(const moq_session_Stats *self, moq_status *status); @@ -3945,41 +3955,41 @@ void moq_session_Stats_datagrams_unrouted_set(moq_session_Stats *self, moq_optio void moq_stats_Tier_free(moq_stats_Tier *self); void moq_stats_Tier_drop(moq_stats_Tier *self, moq_status *status); bool moq_stats_Tier_borrowed(const moq_stats_Tier *self); -moq_stats_Tier *moq_stats_Tier_clone(const moq_stats_Tier *self, moq_status *status); +MOQ_MUST_USE moq_stats_Tier *moq_stats_Tier_clone(const moq_stats_Tier *self, moq_status *status); bool moq_stats_Tier_eq(const moq_stats_Tier *a, const moq_stats_Tier *b, moq_status *status); uint64_t moq_stats_Tier_hash(const moq_stats_Tier *self, moq_status *status); -moq_buf moq_stats_Tier_to_string(const moq_stats_Tier *self, moq_status *status); -moq_buf moq_stats_Tier_debug(const moq_stats_Tier *self, moq_status *status); -moq_stats_Tier *moq_stats_Tier_default(void); -moq_stats_Tier *moq_stats_Tier_new(moq_Path *label, moq_status *status); -moq_Path *moq_stats_Tier_label(const moq_stats_Tier *self, moq_status *status); -moq_buf moq_stats_Tier_as_str(const moq_stats_Tier *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_stats_Tier_to_string(const moq_stats_Tier *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_stats_Tier_debug(const moq_stats_Tier *self, moq_status *status); +MOQ_MUST_USE moq_stats_Tier *moq_stats_Tier_default(void); +MOQ_MUST_USE moq_stats_Tier *moq_stats_Tier_new(moq_Path *label, moq_status *status); +MOQ_MUST_USE moq_Path *moq_stats_Tier_label(const moq_stats_Tier *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_stats_Tier_as_str(const moq_stats_Tier *self, moq_status *status); void moq_stats_Snapshot_free(moq_stats_Snapshot *self); bool moq_stats_Snapshot_borrowed(const moq_stats_Snapshot *self); -moq_stats_Snapshot *moq_stats_Snapshot_clone(const moq_stats_Snapshot *self); +MOQ_MUST_USE moq_stats_Snapshot *moq_stats_Snapshot_clone(const moq_stats_Snapshot *self); bool moq_stats_Snapshot_eq(const moq_stats_Snapshot *a, const moq_stats_Snapshot *b); -moq_buf moq_stats_Snapshot_debug(const moq_stats_Snapshot *self); -moq_stats_Snapshot *moq_stats_Snapshot_default(void); -moq_vec_tuple_stats_Tier_stats_Message_stats_Totals moq_stats_Snapshot_control(const moq_stats_Snapshot *self); -moq_vec_tuple_stats_Tier_stats_Role_stats_Traffic moq_stats_Snapshot_traffic(const moq_stats_Snapshot *self); -moq_vec_tuple_stats_Tier_stats_Presence moq_stats_Snapshot_sessions(const moq_stats_Snapshot *self); -moq_vec_tuple_stats_Tier_stats_Activity moq_stats_Snapshot_activity(const moq_stats_Snapshot *self); +MOQ_MUST_USE moq_buf moq_stats_Snapshot_debug(const moq_stats_Snapshot *self); +MOQ_MUST_USE moq_stats_Snapshot *moq_stats_Snapshot_default(void); +MOQ_MUST_USE moq_vec_tuple_stats_Tier_stats_Message_stats_Totals moq_stats_Snapshot_control(const moq_stats_Snapshot *self); +MOQ_MUST_USE moq_vec_tuple_stats_Tier_stats_Role_stats_Traffic moq_stats_Snapshot_traffic(const moq_stats_Snapshot *self); +MOQ_MUST_USE moq_vec_tuple_stats_Tier_stats_Presence moq_stats_Snapshot_sessions(const moq_stats_Snapshot *self); +MOQ_MUST_USE moq_vec_tuple_stats_Tier_stats_Activity moq_stats_Snapshot_activity(const moq_stats_Snapshot *self); void moq_stats_Report_free(moq_stats_Report *self); void moq_stats_Report_drop(moq_stats_Report *self, moq_status *status); -moq_stats_Report *moq_stats_Report_clone(const moq_stats_Report *self, moq_status *status); -moq_buf moq_stats_Report_debug(const moq_stats_Report *self, moq_status *status); -moq_stats_Report *moq_stats_Report_default(void); -moq_vec_stats_TrafficEntry moq_stats_Report_traffic_get(const moq_stats_Report *self, moq_status *status); +MOQ_MUST_USE moq_stats_Report *moq_stats_Report_clone(const moq_stats_Report *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_stats_Report_debug(const moq_stats_Report *self, moq_status *status); +MOQ_MUST_USE moq_stats_Report *moq_stats_Report_default(void); +MOQ_MUST_USE moq_vec_stats_TrafficEntry moq_stats_Report_traffic_get(const moq_stats_Report *self, moq_status *status); void moq_stats_Report_traffic_set(moq_stats_Report *self, moq_vec_stats_TrafficEntry value, moq_status *status); -moq_vec_stats_SessionEntry moq_stats_Report_sessions_get(const moq_stats_Report *self, moq_status *status); +MOQ_MUST_USE moq_vec_stats_SessionEntry moq_stats_Report_sessions_get(const moq_stats_Report *self, moq_status *status); void moq_stats_Report_sessions_set(moq_stats_Report *self, moq_vec_stats_SessionEntry value, moq_status *status); void moq_stats_TrafficEntry_free(moq_stats_TrafficEntry *self); void moq_stats_TrafficEntry_drop(moq_stats_TrafficEntry *self, moq_status *status); -moq_stats_TrafficEntry *moq_stats_TrafficEntry_clone(const moq_stats_TrafficEntry *self, moq_status *status); -moq_buf moq_stats_TrafficEntry_debug(const moq_stats_TrafficEntry *self, moq_status *status); -moq_Path *moq_stats_TrafficEntry_path_get(const moq_stats_TrafficEntry *self, moq_status *status); +MOQ_MUST_USE moq_stats_TrafficEntry *moq_stats_TrafficEntry_clone(const moq_stats_TrafficEntry *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_stats_TrafficEntry_debug(const moq_stats_TrafficEntry *self, moq_status *status); +MOQ_MUST_USE moq_Path *moq_stats_TrafficEntry_path_get(const moq_stats_TrafficEntry *self, moq_status *status); void moq_stats_TrafficEntry_path_set(moq_stats_TrafficEntry *self, moq_Path *value, moq_status *status); -moq_stats_Tier *moq_stats_TrafficEntry_tier_get(const moq_stats_TrafficEntry *self, moq_status *status); +MOQ_MUST_USE moq_stats_Tier *moq_stats_TrafficEntry_tier_get(const moq_stats_TrafficEntry *self, moq_status *status); void moq_stats_TrafficEntry_tier_set(moq_stats_TrafficEntry *self, moq_stats_Tier *value, moq_status *status); moq_stats_Traffic moq_stats_TrafficEntry_publisher_get(const moq_stats_TrafficEntry *self, moq_status *status); void moq_stats_TrafficEntry_publisher_set(moq_stats_TrafficEntry *self, moq_stats_Traffic value, moq_status *status); @@ -3989,11 +3999,11 @@ bool moq_stats_TrafficEntry_closed_get(const moq_stats_TrafficEntry *self, moq_s void moq_stats_TrafficEntry_closed_set(moq_stats_TrafficEntry *self, bool value, moq_status *status); void moq_stats_SessionEntry_free(moq_stats_SessionEntry *self); void moq_stats_SessionEntry_drop(moq_stats_SessionEntry *self, moq_status *status); -moq_stats_SessionEntry *moq_stats_SessionEntry_clone(const moq_stats_SessionEntry *self, moq_status *status); -moq_buf moq_stats_SessionEntry_debug(const moq_stats_SessionEntry *self, moq_status *status); -moq_stats_Tier *moq_stats_SessionEntry_tier_get(const moq_stats_SessionEntry *self, moq_status *status); +MOQ_MUST_USE moq_stats_SessionEntry *moq_stats_SessionEntry_clone(const moq_stats_SessionEntry *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_stats_SessionEntry_debug(const moq_stats_SessionEntry *self, moq_status *status); +MOQ_MUST_USE moq_stats_Tier *moq_stats_SessionEntry_tier_get(const moq_stats_SessionEntry *self, moq_status *status); void moq_stats_SessionEntry_tier_set(moq_stats_SessionEntry *self, moq_stats_Tier *value, moq_status *status); -moq_Path *moq_stats_SessionEntry_label_get(const moq_stats_SessionEntry *self, moq_status *status); +MOQ_MUST_USE moq_Path *moq_stats_SessionEntry_label_get(const moq_stats_SessionEntry *self, moq_status *status); void moq_stats_SessionEntry_label_set(moq_stats_SessionEntry *self, moq_Path *value, moq_status *status); moq_stats_Presence moq_stats_SessionEntry_presence_get(const moq_stats_SessionEntry *self, moq_status *status); void moq_stats_SessionEntry_presence_set(moq_stats_SessionEntry *self, moq_stats_Presence value, moq_status *status); @@ -4001,256 +4011,256 @@ bool moq_stats_SessionEntry_closed_get(const moq_stats_SessionEntry *self, moq_s void moq_stats_SessionEntry_closed_set(moq_stats_SessionEntry *self, bool value, moq_status *status); void moq_stats_Config_free(moq_stats_Config *self); void moq_stats_Config_drop(moq_stats_Config *self, moq_status *status); -moq_stats_Config *moq_stats_Config_clone(const moq_stats_Config *self, moq_status *status); -moq_buf moq_stats_Config_debug(const moq_stats_Config *self, moq_status *status); -moq_stats_Config *moq_stats_Config_default(void); -moq_Patterns *moq_stats_Config_exclude_get(const moq_stats_Config *self, moq_status *status); +MOQ_MUST_USE moq_stats_Config *moq_stats_Config_clone(const moq_stats_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_stats_Config_debug(const moq_stats_Config *self, moq_status *status); +MOQ_MUST_USE moq_stats_Config *moq_stats_Config_default(void); +MOQ_MUST_USE moq_Patterns *moq_stats_Config_exclude_get(const moq_stats_Config *self, moq_status *status); void moq_stats_Config_exclude_set(moq_stats_Config *self, moq_Patterns *value, moq_status *status); -moq_stats_Config *moq_stats_Config_new(void); -moq_stats_Config *moq_stats_Config_with_exclude(moq_stats_Config *self, moq_Pattern *pattern, moq_status *status); +MOQ_MUST_USE moq_stats_Config *moq_stats_Config_new(void); +MOQ_MUST_USE moq_stats_Config *moq_stats_Config_with_exclude(moq_stats_Config *self, moq_Pattern *pattern, moq_status *status); void moq_stats_Registry_free(moq_stats_Registry *self); bool moq_stats_Registry_borrowed(const moq_stats_Registry *self); -moq_stats_Registry *moq_stats_Registry_clone(const moq_stats_Registry *self); -moq_stats_Registry *moq_stats_Registry_default(void); -moq_stats_Registry *moq_stats_Registry_new(moq_stats_Config *config, moq_status *status); -moq_stats_Registry *moq_stats_Registry_disabled(void); +MOQ_MUST_USE moq_stats_Registry *moq_stats_Registry_clone(const moq_stats_Registry *self); +MOQ_MUST_USE moq_stats_Registry *moq_stats_Registry_default(void); +MOQ_MUST_USE moq_stats_Registry *moq_stats_Registry_new(moq_stats_Config *config, moq_status *status); +MOQ_MUST_USE moq_stats_Registry *moq_stats_Registry_disabled(void); bool moq_stats_Registry_is_enabled(const moq_stats_Registry *self); -moq_stats_Handle *moq_stats_Registry_tier(const moq_stats_Registry *self, moq_stats_Tier *tier, moq_status *status); -moq_stats_Snapshot *moq_stats_Registry_snapshot(const moq_stats_Registry *self); +MOQ_MUST_USE moq_stats_Handle *moq_stats_Registry_tier(const moq_stats_Registry *self, moq_stats_Tier *tier, moq_status *status); +MOQ_MUST_USE moq_stats_Snapshot *moq_stats_Registry_snapshot(const moq_stats_Registry *self); void moq_stats_Registry_report(const moq_stats_Registry *self, moq_stats_Report *report, moq_clock_Instant now, moq_status *status); void moq_stats_Handle_free(moq_stats_Handle *self); bool moq_stats_Handle_borrowed(const moq_stats_Handle *self); -moq_stats_Handle *moq_stats_Handle_clone(const moq_stats_Handle *self); -moq_stats_Handle *moq_stats_Handle_default(void); +MOQ_MUST_USE moq_stats_Handle *moq_stats_Handle_clone(const moq_stats_Handle *self); +MOQ_MUST_USE moq_stats_Handle *moq_stats_Handle_default(void); void moq_stats_Handle_refuse(const moq_stats_Handle *self, moq_stats_Refusal *refusal, moq_status *status); -moq_stats_Session *moq_stats_Handle_session(const moq_stats_Handle *self, moq_stats_SessionInfo *session, moq_status *status); -moq_stats_Session *moq_stats_Handle_request(const moq_stats_Handle *self, moq_Path *label, moq_status *status); +MOQ_MUST_USE moq_stats_Session *moq_stats_Handle_session(const moq_stats_Handle *self, moq_stats_SessionInfo *session, moq_status *status); +MOQ_MUST_USE moq_stats_Session *moq_stats_Handle_request(const moq_stats_Handle *self, moq_Path *label, moq_status *status); void moq_stats_Refusal_free(moq_stats_Refusal *self); void moq_stats_Refusal_drop(moq_stats_Refusal *self, moq_status *status); -moq_stats_Refusal *moq_stats_Refusal_clone(const moq_stats_Refusal *self, moq_status *status); -moq_buf moq_stats_Refusal_debug(const moq_stats_Refusal *self, moq_status *status); -moq_Path *moq_stats_Refusal_label_get(const moq_stats_Refusal *self, moq_status *status); +MOQ_MUST_USE moq_stats_Refusal *moq_stats_Refusal_clone(const moq_stats_Refusal *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_stats_Refusal_debug(const moq_stats_Refusal *self, moq_status *status); +MOQ_MUST_USE moq_Path *moq_stats_Refusal_label_get(const moq_stats_Refusal *self, moq_status *status); void moq_stats_Refusal_label_set(moq_stats_Refusal *self, moq_Path *value, moq_status *status); moq_stats_RefusalKind moq_stats_Refusal_reason_get(const moq_stats_Refusal *self, moq_status *status); void moq_stats_Refusal_reason_set(moq_stats_Refusal *self, moq_stats_RefusalKind value, moq_status *status); -moq_stats_Refusal *moq_stats_Refusal_new(moq_Path *label, moq_stats_RefusalKind reason, moq_status *status); +MOQ_MUST_USE moq_stats_Refusal *moq_stats_Refusal_new(moq_Path *label, moq_stats_RefusalKind reason, moq_status *status); void moq_stats_SessionInfo_free(moq_stats_SessionInfo *self); void moq_stats_SessionInfo_drop(moq_stats_SessionInfo *self, moq_status *status); -moq_stats_SessionInfo *moq_stats_SessionInfo_clone(const moq_stats_SessionInfo *self, moq_status *status); -moq_buf moq_stats_SessionInfo_debug(const moq_stats_SessionInfo *self, moq_status *status); -moq_Path *moq_stats_SessionInfo_label_get(const moq_stats_SessionInfo *self, moq_status *status); +MOQ_MUST_USE moq_stats_SessionInfo *moq_stats_SessionInfo_clone(const moq_stats_SessionInfo *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_stats_SessionInfo_debug(const moq_stats_SessionInfo *self, moq_status *status); +MOQ_MUST_USE moq_Path *moq_stats_SessionInfo_label_get(const moq_stats_SessionInfo *self, moq_status *status); void moq_stats_SessionInfo_label_set(moq_stats_SessionInfo *self, moq_Path *value, moq_status *status); -moq_stats_SessionInfo *moq_stats_SessionInfo_new(moq_Path *label, moq_status *status); +MOQ_MUST_USE moq_stats_SessionInfo *moq_stats_SessionInfo_new(moq_Path *label, moq_status *status); void moq_stats_Wire_free(moq_stats_Wire *self); -moq_stats_Wire *moq_stats_Wire_default(void); +MOQ_MUST_USE moq_stats_Wire *moq_stats_Wire_default(void); void moq_stats_Session_free(moq_stats_Session *self); void moq_stats_Session_drop(moq_stats_Session *self, moq_status *status); bool moq_stats_Session_borrowed(const moq_stats_Session *self); -moq_stats_Session *moq_stats_Session_clone(const moq_stats_Session *self, moq_status *status); -moq_stats_Session *moq_stats_Session_default(void); -moq_stats_Wire *moq_stats_Session_wire(const moq_stats_Session *self, moq_transport_Wire *counters, moq_status *status); +MOQ_MUST_USE moq_stats_Session *moq_stats_Session_clone(const moq_stats_Session *self, moq_status *status); +MOQ_MUST_USE moq_stats_Session *moq_stats_Session_default(void); +MOQ_MUST_USE moq_stats_Wire *moq_stats_Session_wire(const moq_stats_Session *self, moq_transport_Wire *counters, moq_status *status); void moq_stats_Session_retag(const moq_stats_Session *self, moq_stats_Tier *tier, moq_Path *label, moq_status *status); void moq_stats_Bill_free(moq_stats_Bill *self); bool moq_stats_Bill_borrowed(const moq_stats_Bill *self); -moq_stats_Bill *moq_stats_Bill_clone(const moq_stats_Bill *self); -moq_buf moq_stats_Bill_debug(const moq_stats_Bill *self); -moq_stats_Bill *moq_stats_Bill_default(void); +MOQ_MUST_USE moq_stats_Bill *moq_stats_Bill_clone(const moq_stats_Bill *self); +MOQ_MUST_USE moq_buf moq_stats_Bill_debug(const moq_stats_Bill *self); +MOQ_MUST_USE moq_stats_Bill *moq_stats_Bill_default(void); void moq_stats_Bill_deliver(const moq_stats_Bill *self, uint64_t bytes); void moq_transport_Wire_free(moq_transport_Wire *self); void moq_transport_Wire_drop(moq_transport_Wire *self, moq_status *status); bool moq_transport_Wire_borrowed(const moq_transport_Wire *self); -moq_transport_Wire *moq_transport_Wire_clone(const moq_transport_Wire *self, moq_status *status); -moq_buf moq_transport_Wire_debug(const moq_transport_Wire *self, moq_status *status); -moq_transport_Wire *moq_transport_Wire_default(void); -moq_transport_Wire *moq_transport_Wire_new(void); +MOQ_MUST_USE moq_transport_Wire *moq_transport_Wire_clone(const moq_transport_Wire *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_transport_Wire_debug(const moq_transport_Wire *self, moq_status *status); +MOQ_MUST_USE moq_transport_Wire *moq_transport_Wire_default(void); +MOQ_MUST_USE moq_transport_Wire *moq_transport_Wire_new(void); uint64_t moq_transport_Wire_sent_bytes(const moq_transport_Wire *self, moq_status *status); uint64_t moq_transport_Wire_received_bytes(const moq_transport_Wire *self, moq_status *status); void moq_transport_Wire_set_sent_bytes(const moq_transport_Wire *self, uint64_t total, moq_status *status); void moq_transport_Wire_set_received_bytes(const moq_transport_Wire *self, uint64_t total, moq_status *status); void moq_transport_Probe_free(moq_transport_Probe *self); bool moq_transport_Probe_borrowed(const moq_transport_Probe *self); -moq_transport_Probe *moq_transport_Probe_clone(const moq_transport_Probe *self); -moq_buf moq_transport_Probe_debug(const moq_transport_Probe *self); -moq_transport_Probe *moq_transport_Probe_default(void); -moq_transport_Probe *moq_transport_Probe_new(void); +MOQ_MUST_USE moq_transport_Probe *moq_transport_Probe_clone(const moq_transport_Probe *self); +MOQ_MUST_USE moq_buf moq_transport_Probe_debug(const moq_transport_Probe *self); +MOQ_MUST_USE moq_transport_Probe *moq_transport_Probe_default(void); +MOQ_MUST_USE moq_transport_Probe *moq_transport_Probe_new(void); moq_bandwidth_Rate moq_transport_Probe_target(const moq_transport_Probe *self); void moq_transport_Probe_set_target(const moq_transport_Probe *self, moq_bandwidth_Rate rate); void moq_bandwidth_Limit_free(moq_bandwidth_Limit *self); void moq_bandwidth_Limit_drop(moq_bandwidth_Limit *self, moq_status *status); -moq_bandwidth_Limit *moq_bandwidth_Limit_clone(const moq_bandwidth_Limit *self, moq_status *status); -moq_buf moq_bandwidth_Limit_debug(const moq_bandwidth_Limit *self, moq_status *status); -moq_bandwidth_Limit *moq_bandwidth_Limit_default(void); -moq_bandwidth_Limit *moq_bandwidth_Limit_new(const moq_bandwidth_Cap *cap, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Limit *moq_bandwidth_Limit_clone(const moq_bandwidth_Limit *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_bandwidth_Limit_debug(const moq_bandwidth_Limit *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Limit *moq_bandwidth_Limit_default(void); +MOQ_MUST_USE moq_bandwidth_Limit *moq_bandwidth_Limit_new(const moq_bandwidth_Cap *cap, moq_status *status); void moq_bandwidth_Limit_set(const moq_bandwidth_Limit *self, const moq_bandwidth_Cap *cap, moq_status *status); -moq_bandwidth_Cap *moq_bandwidth_Limit_get(moq_bandwidth_Limit *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Cap *moq_bandwidth_Limit_get(moq_bandwidth_Limit *self, moq_status *status); typedef struct moq_bandwidth_Limit_changed_future moq_bandwidth_Limit_changed_future; -moq_bandwidth_Limit_changed_future *moq_bandwidth_Limit_changed(moq_bandwidth_Limit *self, moq_status *status); -moq_poll moq_bandwidth_Limit_changed_start(moq_bandwidth_Limit *self, moq_bandwidth_Cap **out, moq_bandwidth_Limit_changed_future **future, moq_status *status); -moq_poll moq_bandwidth_Limit_changed_poll(moq_bandwidth_Limit_changed_future *future, moq_waker waker, moq_bandwidth_Cap **out); +MOQ_MUST_USE moq_bandwidth_Limit_changed_future *moq_bandwidth_Limit_changed(moq_bandwidth_Limit *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_bandwidth_Limit_changed_start(moq_bandwidth_Limit *self, moq_bandwidth_Cap **out, moq_bandwidth_Limit_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_bandwidth_Limit_changed_poll(moq_bandwidth_Limit_changed_future *future, moq_waker waker, moq_bandwidth_Cap **out); void moq_bandwidth_Limit_changed_future_free(moq_bandwidth_Limit_changed_future *future); void moq_bandwidth_Demand_free(moq_bandwidth_Demand *self); void moq_bandwidth_Demand_drop(moq_bandwidth_Demand *self, moq_status *status); -moq_bandwidth_Demand *moq_bandwidth_Demand_clone(const moq_bandwidth_Demand *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Demand *moq_bandwidth_Demand_clone(const moq_bandwidth_Demand *self, moq_status *status); bool moq_bandwidth_Demand_wanted(const moq_bandwidth_Demand *self, moq_status *status); typedef struct moq_bandwidth_Demand_wanted_changed_future moq_bandwidth_Demand_wanted_changed_future; -moq_bandwidth_Demand_wanted_changed_future *moq_bandwidth_Demand_wanted_changed(moq_bandwidth_Demand *self, moq_status *status); -moq_poll moq_bandwidth_Demand_wanted_changed_start(moq_bandwidth_Demand *self, bool *out, moq_Error **err, moq_bandwidth_Demand_wanted_changed_future **future, moq_status *status); -moq_poll moq_bandwidth_Demand_wanted_changed_poll(moq_bandwidth_Demand_wanted_changed_future *future, moq_waker waker, bool *out, moq_Error **err); +MOQ_MUST_USE moq_bandwidth_Demand_wanted_changed_future *moq_bandwidth_Demand_wanted_changed(moq_bandwidth_Demand *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_bandwidth_Demand_wanted_changed_start(moq_bandwidth_Demand *self, bool *out, moq_Error **err, moq_bandwidth_Demand_wanted_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_bandwidth_Demand_wanted_changed_poll(moq_bandwidth_Demand_wanted_changed_future *future, moq_waker waker, bool *out, moq_Error **err); void moq_bandwidth_Demand_wanted_changed_future_free(moq_bandwidth_Demand_wanted_changed_future *future); void moq_bandwidth_Reservation_free(moq_bandwidth_Reservation *self); moq_option_bandwidth_Rate moq_bandwidth_Reservation_rate(const moq_bandwidth_Reservation *self); -moq_bandwidth_Consumer *moq_bandwidth_Reservation_consume(const moq_bandwidth_Reservation *self); +MOQ_MUST_USE moq_bandwidth_Consumer *moq_bandwidth_Reservation_consume(const moq_bandwidth_Reservation *self); void moq_bandwidth_Reservation_update(const moq_bandwidth_Reservation *self, moq_bandwidth_Rate max); void moq_bandwidth_Viewer_free(moq_bandwidth_Viewer *self); moq_option_bandwidth_Rate moq_bandwidth_Viewer_rate(const moq_bandwidth_Viewer *self); -moq_bandwidth_Consumer *moq_bandwidth_Viewer_consume(const moq_bandwidth_Viewer *self); -bool moq_bandwidth_Viewer_update(const moq_bandwidth_Viewer *self, moq_bandwidth_Rate max, moq_Error **err); +MOQ_MUST_USE moq_bandwidth_Consumer *moq_bandwidth_Viewer_consume(const moq_bandwidth_Viewer *self); +MOQ_MUST_USE bool moq_bandwidth_Viewer_update(const moq_bandwidth_Viewer *self, moq_bandwidth_Rate max, moq_Error **err); void moq_bandwidth_Cap_free(moq_bandwidth_Cap *self); void moq_bandwidth_Cap_drop(moq_bandwidth_Cap *self, moq_status *status); -moq_bandwidth_Cap *moq_bandwidth_Cap_clone(const moq_bandwidth_Cap *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Cap *moq_bandwidth_Cap_clone(const moq_bandwidth_Cap *self, moq_status *status); bool moq_bandwidth_Cap_eq(const moq_bandwidth_Cap *a, const moq_bandwidth_Cap *b, moq_status *status); -moq_buf moq_bandwidth_Cap_debug(const moq_bandwidth_Cap *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_bandwidth_Cap_debug(const moq_bandwidth_Cap *self, moq_status *status); moq_bandwidth_Rate moq_bandwidth_Cap_rate_get(const moq_bandwidth_Cap *self, moq_status *status); void moq_bandwidth_Cap_rate_set(moq_bandwidth_Cap *self, moq_bandwidth_Rate value, moq_status *status); moq_duration moq_bandwidth_Cap_burst_get(const moq_bandwidth_Cap *self, moq_status *status); void moq_bandwidth_Cap_burst_set(moq_bandwidth_Cap *self, moq_duration value, moq_status *status); moq_duration moq_bandwidth_Cap_DEFAULT_BURST(void); -moq_bandwidth_Cap *moq_bandwidth_Cap_new(moq_bandwidth_Rate rate); -moq_bandwidth_Cap *moq_bandwidth_Cap_with_burst(const moq_bandwidth_Cap *self, moq_duration burst, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Cap *moq_bandwidth_Cap_new(moq_bandwidth_Rate rate); +MOQ_MUST_USE moq_bandwidth_Cap *moq_bandwidth_Cap_with_burst(const moq_bandwidth_Cap *self, moq_duration burst, moq_status *status); void moq_bandwidth_Producer_free(moq_bandwidth_Producer *self); -moq_bandwidth_Producer *moq_bandwidth_Producer_clone(const moq_bandwidth_Producer *self); -moq_bandwidth_Producer *moq_bandwidth_Producer_default(void); -moq_bandwidth_Producer *moq_bandwidth_Producer_new(void); -bool moq_bandwidth_Producer_set(const moq_bandwidth_Producer *self, moq_option_bandwidth_Rate bitrate, moq_Error **err); -moq_bandwidth_Consumer *moq_bandwidth_Producer_consume(const moq_bandwidth_Producer *self); -moq_bandwidth_Weak *moq_bandwidth_Producer_weak(const moq_bandwidth_Producer *self); -moq_bandwidth_Demand *moq_bandwidth_Producer_demand(const moq_bandwidth_Producer *self); +MOQ_MUST_USE moq_bandwidth_Producer *moq_bandwidth_Producer_clone(const moq_bandwidth_Producer *self); +MOQ_MUST_USE moq_bandwidth_Producer *moq_bandwidth_Producer_default(void); +MOQ_MUST_USE moq_bandwidth_Producer *moq_bandwidth_Producer_new(void); +MOQ_MUST_USE bool moq_bandwidth_Producer_set(const moq_bandwidth_Producer *self, moq_option_bandwidth_Rate bitrate, moq_Error **err); +MOQ_MUST_USE moq_bandwidth_Consumer *moq_bandwidth_Producer_consume(const moq_bandwidth_Producer *self); +MOQ_MUST_USE moq_bandwidth_Weak *moq_bandwidth_Producer_weak(const moq_bandwidth_Producer *self); +MOQ_MUST_USE moq_bandwidth_Demand *moq_bandwidth_Producer_demand(const moq_bandwidth_Producer *self); void moq_bandwidth_Weak_free(moq_bandwidth_Weak *self); void moq_bandwidth_Weak_drop(moq_bandwidth_Weak *self, moq_status *status); -moq_bandwidth_Weak *moq_bandwidth_Weak_clone(const moq_bandwidth_Weak *self, moq_status *status); -moq_bandwidth_Consumer *moq_bandwidth_Weak_consume(const moq_bandwidth_Weak *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Weak *moq_bandwidth_Weak_clone(const moq_bandwidth_Weak *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Consumer *moq_bandwidth_Weak_consume(const moq_bandwidth_Weak *self, moq_status *status); void moq_bandwidth_Allocator_free(moq_bandwidth_Allocator *self); void moq_bandwidth_Allocator_drop(moq_bandwidth_Allocator *self, moq_status *status); -moq_bandwidth_Allocator *moq_bandwidth_Allocator_clone(const moq_bandwidth_Allocator *self, moq_status *status); -moq_buf moq_bandwidth_Allocator_debug(const moq_bandwidth_Allocator *self, moq_status *status); -moq_bandwidth_Allocator *moq_bandwidth_Allocator_default(void); -moq_bandwidth_Allocator *moq_bandwidth_Allocator_new(moq_bandwidth_Consumer *estimate, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Allocator *moq_bandwidth_Allocator_clone(const moq_bandwidth_Allocator *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_bandwidth_Allocator_debug(const moq_bandwidth_Allocator *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Allocator *moq_bandwidth_Allocator_default(void); +MOQ_MUST_USE moq_bandwidth_Allocator *moq_bandwidth_Allocator_new(moq_bandwidth_Consumer *estimate, moq_status *status); void moq_bandwidth_Allocator_set_target(const moq_bandwidth_Allocator *self, moq_option_bandwidth_Rate target, moq_status *status); -moq_bandwidth_Allocator *moq_bandwidth_Allocator_unlimited(void); -moq_bandwidth_Reservation *moq_bandwidth_Allocator_reserve(const moq_bandwidth_Allocator *self, const moq_track_Demand *track, moq_bandwidth_Rate max, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Allocator *moq_bandwidth_Allocator_unlimited(void); +MOQ_MUST_USE moq_bandwidth_Reservation *moq_bandwidth_Allocator_reserve(const moq_bandwidth_Allocator *self, const moq_track_Demand *track, moq_bandwidth_Rate max, moq_status *status); void moq_bandwidth_Viewers_free(moq_bandwidth_Viewers *self); void moq_bandwidth_Viewers_drop(moq_bandwidth_Viewers *self, moq_status *status); -moq_bandwidth_Viewers *moq_bandwidth_Viewers_clone(const moq_bandwidth_Viewers *self, moq_status *status); -moq_buf moq_bandwidth_Viewers_debug(const moq_bandwidth_Viewers *self, moq_status *status); -moq_bandwidth_Viewers *moq_bandwidth_Viewers_default(void); +MOQ_MUST_USE moq_bandwidth_Viewers *moq_bandwidth_Viewers_clone(const moq_bandwidth_Viewers *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_bandwidth_Viewers_debug(const moq_bandwidth_Viewers *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Viewers *moq_bandwidth_Viewers_default(void); moq_bandwidth_Rate moq_bandwidth_Viewers_MAX_TARGET(void); -moq_bandwidth_Viewers *moq_bandwidth_Viewers_new(moq_bandwidth_Weak *estimate, moq_status *status); -bool moq_bandwidth_Viewers_watch(const moq_bandwidth_Viewers *self, moq_bandwidth_Rate max, moq_bandwidth_Viewer **out, moq_Error **err, moq_status *status); -bool moq_bandwidth_Viewers_set_target(const moq_bandwidth_Viewers *self, moq_option_bandwidth_Rate target, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Viewers *moq_bandwidth_Viewers_new(moq_bandwidth_Weak *estimate, moq_status *status); +MOQ_MUST_USE bool moq_bandwidth_Viewers_watch(const moq_bandwidth_Viewers *self, moq_bandwidth_Rate max, moq_bandwidth_Viewer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_bandwidth_Viewers_set_target(const moq_bandwidth_Viewers *self, moq_option_bandwidth_Rate target, moq_Error **err, moq_status *status); void moq_bandwidth_Consumer_free(moq_bandwidth_Consumer *self); void moq_bandwidth_Consumer_drop(moq_bandwidth_Consumer *self, moq_status *status); -moq_bandwidth_Consumer *moq_bandwidth_Consumer_clone(const moq_bandwidth_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_bandwidth_Consumer *moq_bandwidth_Consumer_clone(const moq_bandwidth_Consumer *self, moq_status *status); moq_option_bandwidth_Rate moq_bandwidth_Consumer_peek(const moq_bandwidth_Consumer *self, moq_status *status); bool moq_bandwidth_Consumer_probed(const moq_bandwidth_Consumer *self, moq_status *status); typedef struct moq_bandwidth_Consumer_changed_future moq_bandwidth_Consumer_changed_future; -moq_bandwidth_Consumer_changed_future *moq_bandwidth_Consumer_changed(moq_bandwidth_Consumer *self, moq_status *status); -moq_poll moq_bandwidth_Consumer_changed_start(moq_bandwidth_Consumer *self, moq_option_bandwidth_Rate *out, moq_Error **err, moq_bandwidth_Consumer_changed_future **future, moq_status *status); -moq_poll moq_bandwidth_Consumer_changed_poll(moq_bandwidth_Consumer_changed_future *future, moq_waker waker, moq_option_bandwidth_Rate *out, moq_Error **err); +MOQ_MUST_USE moq_bandwidth_Consumer_changed_future *moq_bandwidth_Consumer_changed(moq_bandwidth_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_bandwidth_Consumer_changed_start(moq_bandwidth_Consumer *self, moq_option_bandwidth_Rate *out, moq_Error **err, moq_bandwidth_Consumer_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_bandwidth_Consumer_changed_poll(moq_bandwidth_Consumer_changed_future *future, moq_waker waker, moq_option_bandwidth_Rate *out, moq_Error **err); void moq_bandwidth_Consumer_changed_future_free(moq_bandwidth_Consumer_changed_future *future); void moq_broadcast_DatagramRequests_free(moq_broadcast_DatagramRequests *self); void moq_broadcast_DatagramRequests_drop(moq_broadcast_DatagramRequests *self, moq_status *status); -moq_broadcast_DatagramRequests *moq_broadcast_DatagramRequests_clone(const moq_broadcast_DatagramRequests *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_DatagramRequests *moq_broadcast_DatagramRequests_clone(const moq_broadcast_DatagramRequests *self, moq_status *status); typedef struct moq_broadcast_DatagramRequests_requested_future moq_broadcast_DatagramRequests_requested_future; -moq_broadcast_DatagramRequests_requested_future *moq_broadcast_DatagramRequests_requested(moq_broadcast_DatagramRequests *self, moq_status *status); -moq_poll moq_broadcast_DatagramRequests_requested_start(moq_broadcast_DatagramRequests *self, moq_datagram_Request **out, moq_Error **err, moq_broadcast_DatagramRequests_requested_future **future, moq_status *status); -moq_poll moq_broadcast_DatagramRequests_requested_poll(moq_broadcast_DatagramRequests_requested_future *future, moq_waker waker, moq_datagram_Request **out, moq_Error **err); +MOQ_MUST_USE moq_broadcast_DatagramRequests_requested_future *moq_broadcast_DatagramRequests_requested(moq_broadcast_DatagramRequests *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_DatagramRequests_requested_start(moq_broadcast_DatagramRequests *self, moq_datagram_Request **out, moq_Error **err, moq_broadcast_DatagramRequests_requested_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_DatagramRequests_requested_poll(moq_broadcast_DatagramRequests_requested_future *future, moq_waker waker, moq_datagram_Request **out, moq_Error **err); void moq_broadcast_DatagramRequests_requested_future_free(moq_broadcast_DatagramRequests_requested_future *future); void moq_broadcast_Consumer_free(moq_broadcast_Consumer *self); void moq_broadcast_Consumer_drop(moq_broadcast_Consumer *self, moq_status *status); -moq_broadcast_Consumer *moq_broadcast_Consumer_clone(const moq_broadcast_Consumer *self, moq_status *status); -bool moq_broadcast_Consumer_tracks(const moq_broadcast_Consumer *self, moq_broadcast_Tracks **out, moq_Error **err, moq_status *status); -moq_broadcast_Info *moq_broadcast_Consumer_info(const moq_broadcast_Consumer *self, moq_status *status); -bool moq_broadcast_Consumer_track(const moq_broadcast_Consumer *self, moq_buf name, moq_track_Consumer **out, moq_Error **err, moq_status *status); -bool moq_broadcast_Consumer_datagrams(const moq_broadcast_Consumer *self, moq_buf name, moq_datagram_Consumer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_broadcast_Consumer *moq_broadcast_Consumer_clone(const moq_broadcast_Consumer *self, moq_status *status); +MOQ_MUST_USE bool moq_broadcast_Consumer_tracks(const moq_broadcast_Consumer *self, moq_broadcast_Tracks **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_broadcast_Consumer_info(const moq_broadcast_Consumer *self, moq_status *status); +MOQ_MUST_USE bool moq_broadcast_Consumer_track(const moq_broadcast_Consumer *self, moq_buf name, moq_track_Consumer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_broadcast_Consumer_datagrams(const moq_broadcast_Consumer *self, moq_buf name, moq_datagram_Consumer **out, moq_Error **err, moq_status *status); bool moq_broadcast_Consumer_is_closed(const moq_broadcast_Consumer *self, moq_status *status); typedef struct moq_broadcast_Consumer_closed_future moq_broadcast_Consumer_closed_future; -moq_broadcast_Consumer_closed_future *moq_broadcast_Consumer_closed(const moq_broadcast_Consumer *self, moq_status *status); -moq_poll moq_broadcast_Consumer_closed_start(const moq_broadcast_Consumer *self, moq_broadcast_Consumer_closed_future **future, moq_status *status); -moq_poll moq_broadcast_Consumer_closed_poll(moq_broadcast_Consumer_closed_future *future, moq_waker waker); +MOQ_MUST_USE moq_broadcast_Consumer_closed_future *moq_broadcast_Consumer_closed(const moq_broadcast_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_Consumer_closed_start(const moq_broadcast_Consumer *self, moq_broadcast_Consumer_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_Consumer_closed_poll(moq_broadcast_Consumer_closed_future *future, moq_waker waker); void moq_broadcast_Consumer_closed_future_free(moq_broadcast_Consumer_closed_future *future); bool moq_broadcast_Consumer_is_clone(const moq_broadcast_Consumer *self, const moq_broadcast_Consumer *other, moq_status *status); void moq_broadcast_Demand_free(moq_broadcast_Demand *self); void moq_broadcast_Demand_drop(moq_broadcast_Demand *self, moq_status *status); -moq_broadcast_Demand *moq_broadcast_Demand_clone(const moq_broadcast_Demand *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Demand *moq_broadcast_Demand_clone(const moq_broadcast_Demand *self, moq_status *status); bool moq_broadcast_Demand_wanted(const moq_broadcast_Demand *self, moq_status *status); typedef struct moq_broadcast_Demand_wanted_changed_future moq_broadcast_Demand_wanted_changed_future; -moq_broadcast_Demand_wanted_changed_future *moq_broadcast_Demand_wanted_changed(moq_broadcast_Demand *self, moq_status *status); -moq_poll moq_broadcast_Demand_wanted_changed_start(moq_broadcast_Demand *self, bool *out, moq_Error **err, moq_broadcast_Demand_wanted_changed_future **future, moq_status *status); -moq_poll moq_broadcast_Demand_wanted_changed_poll(moq_broadcast_Demand_wanted_changed_future *future, moq_waker waker, bool *out, moq_Error **err); +MOQ_MUST_USE moq_broadcast_Demand_wanted_changed_future *moq_broadcast_Demand_wanted_changed(moq_broadcast_Demand *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_Demand_wanted_changed_start(moq_broadcast_Demand *self, bool *out, moq_Error **err, moq_broadcast_Demand_wanted_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_Demand_wanted_changed_poll(moq_broadcast_Demand_wanted_changed_future *future, moq_waker waker, bool *out, moq_Error **err); void moq_broadcast_Demand_wanted_changed_future_free(moq_broadcast_Demand_wanted_changed_future *future); void moq_broadcast_Info_free(moq_broadcast_Info *self); void moq_broadcast_Info_drop(moq_broadcast_Info *self, moq_status *status); -moq_broadcast_Info *moq_broadcast_Info_clone(const moq_broadcast_Info *self, moq_status *status); -moq_buf moq_broadcast_Info_debug(const moq_broadcast_Info *self, moq_status *status); -moq_broadcast_Info *moq_broadcast_Info_default(void); -moq_cache_Pool *moq_broadcast_Info_pool_get(const moq_broadcast_Info *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_broadcast_Info_clone(const moq_broadcast_Info *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_broadcast_Info_debug(const moq_broadcast_Info *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_broadcast_Info_default(void); +MOQ_MUST_USE moq_cache_Pool *moq_broadcast_Info_pool_get(const moq_broadcast_Info *self, moq_status *status); void moq_broadcast_Info_pool_set(moq_broadcast_Info *self, moq_cache_Pool *value, moq_status *status); moq_option_duration moq_broadcast_Info_cache_duration_get(const moq_broadcast_Info *self, moq_status *status); void moq_broadcast_Info_cache_duration_set(moq_broadcast_Info *self, moq_option_duration value, moq_status *status); -moq_Path *moq_broadcast_Info_path_get(const moq_broadcast_Info *self, moq_status *status); +MOQ_MUST_USE moq_Path *moq_broadcast_Info_path_get(const moq_broadcast_Info *self, moq_status *status); void moq_broadcast_Info_path_set(moq_broadcast_Info *self, moq_Path *value, moq_status *status); -moq_Instance *moq_broadcast_Info_instance_get(const moq_broadcast_Info *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_broadcast_Info_instance_get(const moq_broadcast_Info *self, moq_status *status); void moq_broadcast_Info_instance_set(moq_broadcast_Info *self, moq_Instance *value, moq_status *status); -moq_broadcast_Info *moq_broadcast_Info_new(void); -moq_broadcast_Producer *moq_broadcast_Info_produce(moq_broadcast_Info *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_broadcast_Info_new(void); +MOQ_MUST_USE moq_broadcast_Producer *moq_broadcast_Info_produce(moq_broadcast_Info *self, moq_status *status); void moq_broadcast_Producer_free(moq_broadcast_Producer *self); void moq_broadcast_Producer_drop(moq_broadcast_Producer *self, moq_status *status); -moq_broadcast_Producer *moq_broadcast_Producer_clone(const moq_broadcast_Producer *self, moq_status *status); -moq_broadcast_Producer *moq_broadcast_Producer_new(moq_broadcast_Info *info, moq_status *status); -moq_broadcast_Info *moq_broadcast_Producer_info(const moq_broadcast_Producer *self, moq_status *status); -moq_broadcast_Demand *moq_broadcast_Producer_demand(const moq_broadcast_Producer *self, moq_status *status); -bool moq_broadcast_Producer_create_track(const moq_broadcast_Producer *self, moq_buf name, moq_track_Info *info, moq_track_Producer **out, moq_Error **err, moq_status *status); -bool moq_broadcast_Producer_create_datagrams(const moq_broadcast_Producer *self, moq_buf name, const moq_datagram_Info *info, moq_datagram_Producer **out, moq_Error **err, moq_status *status); -bool moq_broadcast_Producer_reserve_track(const moq_broadcast_Producer *self, moq_buf name, moq_track_Request **out, moq_Error **err, moq_status *status); -bool moq_broadcast_Producer_reserve_unlisted_track(const moq_broadcast_Producer *self, moq_buf name, moq_track_Request **out, moq_Error **err, moq_status *status); -bool moq_broadcast_Producer_unique_track(const moq_broadcast_Producer *self, moq_buf suffix, moq_track_Info *info, moq_track_Producer **out, moq_Error **err, moq_status *status); -moq_buf moq_broadcast_Producer_unique_name(const moq_broadcast_Producer *self, moq_buf suffix, moq_status *status); -moq_broadcast_Requests *moq_broadcast_Producer_requests(const moq_broadcast_Producer *self, moq_status *status); -moq_broadcast_Consumer *moq_broadcast_Producer_consume(const moq_broadcast_Producer *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Producer *moq_broadcast_Producer_clone(const moq_broadcast_Producer *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Producer *moq_broadcast_Producer_new(moq_broadcast_Info *info, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_broadcast_Producer_info(const moq_broadcast_Producer *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Demand *moq_broadcast_Producer_demand(const moq_broadcast_Producer *self, moq_status *status); +MOQ_MUST_USE bool moq_broadcast_Producer_create_track(const moq_broadcast_Producer *self, moq_buf name, moq_track_Info *info, moq_track_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_broadcast_Producer_create_datagrams(const moq_broadcast_Producer *self, moq_buf name, const moq_datagram_Info *info, moq_datagram_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_broadcast_Producer_reserve_track(const moq_broadcast_Producer *self, moq_buf name, moq_track_Request **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_broadcast_Producer_reserve_unlisted_track(const moq_broadcast_Producer *self, moq_buf name, moq_track_Request **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_broadcast_Producer_unique_track(const moq_broadcast_Producer *self, moq_buf suffix, moq_track_Info *info, moq_track_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_broadcast_Producer_unique_name(const moq_broadcast_Producer *self, moq_buf suffix, moq_status *status); +MOQ_MUST_USE moq_broadcast_Requests *moq_broadcast_Producer_requests(const moq_broadcast_Producer *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Consumer *moq_broadcast_Producer_consume(const moq_broadcast_Producer *self, moq_status *status); void moq_broadcast_Producer_close(const moq_broadcast_Producer *self, moq_status *status); bool moq_broadcast_Producer_is_clone(const moq_broadcast_Producer *self, const moq_broadcast_Producer *other, moq_status *status); void moq_broadcast_Requests_free(moq_broadcast_Requests *self); void moq_broadcast_Requests_drop(moq_broadcast_Requests *self, moq_status *status); -moq_broadcast_Requests *moq_broadcast_Requests_clone(const moq_broadcast_Requests *self, moq_status *status); -moq_broadcast_Info *moq_broadcast_Requests_info(const moq_broadcast_Requests *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Requests *moq_broadcast_Requests_clone(const moq_broadcast_Requests *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_broadcast_Requests_info(const moq_broadcast_Requests *self, moq_status *status); typedef struct moq_broadcast_Requests_requested_track_future moq_broadcast_Requests_requested_track_future; -moq_broadcast_Requests_requested_track_future *moq_broadcast_Requests_requested_track(moq_broadcast_Requests *self, moq_status *status); -moq_poll moq_broadcast_Requests_requested_track_start(moq_broadcast_Requests *self, moq_track_Request **out, moq_Error **err, moq_broadcast_Requests_requested_track_future **future, moq_status *status); -moq_poll moq_broadcast_Requests_requested_track_poll(moq_broadcast_Requests_requested_track_future *future, moq_waker waker, moq_track_Request **out, moq_Error **err); +MOQ_MUST_USE moq_broadcast_Requests_requested_track_future *moq_broadcast_Requests_requested_track(moq_broadcast_Requests *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_Requests_requested_track_start(moq_broadcast_Requests *self, moq_track_Request **out, moq_Error **err, moq_broadcast_Requests_requested_track_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_Requests_requested_track_poll(moq_broadcast_Requests_requested_track_future *future, moq_waker waker, moq_track_Request **out, moq_Error **err); void moq_broadcast_Requests_requested_track_future_free(moq_broadcast_Requests_requested_track_future *future); -moq_broadcast_Consumer *moq_broadcast_Requests_consume(const moq_broadcast_Requests *self, moq_status *status); -moq_broadcast_DatagramRequests *moq_broadcast_Requests_datagrams(const moq_broadcast_Requests *self, moq_status *status); -bool moq_broadcast_Requests_lister(const moq_broadcast_Requests *self, moq_broadcast_Lister **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_broadcast_Consumer *moq_broadcast_Requests_consume(const moq_broadcast_Requests *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_DatagramRequests *moq_broadcast_Requests_datagrams(const moq_broadcast_Requests *self, moq_status *status); +MOQ_MUST_USE bool moq_broadcast_Requests_lister(const moq_broadcast_Requests *self, moq_broadcast_Lister **out, moq_Error **err, moq_status *status); typedef struct moq_broadcast_Requests_closed_future moq_broadcast_Requests_closed_future; -moq_broadcast_Requests_closed_future *moq_broadcast_Requests_closed(const moq_broadcast_Requests *self, moq_status *status); -moq_poll moq_broadcast_Requests_closed_start(const moq_broadcast_Requests *self, moq_broadcast_Requests_closed_future **future, moq_status *status); -moq_poll moq_broadcast_Requests_closed_poll(moq_broadcast_Requests_closed_future *future, moq_waker waker); +MOQ_MUST_USE moq_broadcast_Requests_closed_future *moq_broadcast_Requests_closed(const moq_broadcast_Requests *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_Requests_closed_start(const moq_broadcast_Requests *self, moq_broadcast_Requests_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_Requests_closed_poll(moq_broadcast_Requests_closed_future *future, moq_waker waker); void moq_broadcast_Requests_closed_future_free(moq_broadcast_Requests_closed_future *future); bool moq_broadcast_Requests_is_clone(const moq_broadcast_Requests *self, const moq_broadcast_Requests *other, moq_status *status); void moq_broadcast_Lister_free(moq_broadcast_Lister *self); typedef struct moq_broadcast_Lister_poll_wanted_future moq_broadcast_Lister_poll_wanted_future; -moq_broadcast_Lister_poll_wanted_future *moq_broadcast_Lister_poll_wanted(const moq_broadcast_Lister *self); -moq_poll moq_broadcast_Lister_poll_wanted_start(const moq_broadcast_Lister *self, moq_Error **err, moq_broadcast_Lister_poll_wanted_future **future); -moq_poll moq_broadcast_Lister_poll_wanted_poll(moq_broadcast_Lister_poll_wanted_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_broadcast_Lister_poll_wanted_future *moq_broadcast_Lister_poll_wanted(const moq_broadcast_Lister *self); +MOQ_MUST_USE moq_poll moq_broadcast_Lister_poll_wanted_start(const moq_broadcast_Lister *self, moq_Error **err, moq_broadcast_Lister_poll_wanted_future **future); +MOQ_MUST_USE moq_poll moq_broadcast_Lister_poll_wanted_poll(moq_broadcast_Lister_poll_wanted_future *future, moq_waker waker, moq_Error **err); void moq_broadcast_Lister_poll_wanted_future_free(moq_broadcast_Lister_poll_wanted_future *future); typedef struct moq_broadcast_Lister_poll_unwanted_future moq_broadcast_Lister_poll_unwanted_future; -moq_broadcast_Lister_poll_unwanted_future *moq_broadcast_Lister_poll_unwanted(const moq_broadcast_Lister *self); -moq_poll moq_broadcast_Lister_poll_unwanted_start(const moq_broadcast_Lister *self, moq_Error **err, moq_broadcast_Lister_poll_unwanted_future **future); -moq_poll moq_broadcast_Lister_poll_unwanted_poll(moq_broadcast_Lister_poll_unwanted_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_broadcast_Lister_poll_unwanted_future *moq_broadcast_Lister_poll_unwanted(const moq_broadcast_Lister *self); +MOQ_MUST_USE moq_poll moq_broadcast_Lister_poll_unwanted_start(const moq_broadcast_Lister *self, moq_Error **err, moq_broadcast_Lister_poll_unwanted_future **future); +MOQ_MUST_USE moq_poll moq_broadcast_Lister_poll_unwanted_poll(moq_broadcast_Lister_poll_unwanted_future *future, moq_waker waker, moq_Error **err); void moq_broadcast_Lister_poll_unwanted_future_free(moq_broadcast_Lister_poll_unwanted_future *future); -bool moq_broadcast_Lister_add(const moq_broadcast_Lister *self, moq_buf name, moq_track_Info *info, moq_Error **err, moq_status *status); -bool moq_broadcast_Lister_remove(const moq_broadcast_Lister *self, moq_broadcast_Kind kind, moq_buf name, moq_Error **err); -bool moq_broadcast_Lister_finish(const moq_broadcast_Lister *self, moq_broadcast_Kind kind, moq_buf name, moq_Error **err); +MOQ_MUST_USE bool moq_broadcast_Lister_add(const moq_broadcast_Lister *self, moq_buf name, moq_track_Info *info, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_broadcast_Lister_remove(const moq_broadcast_Lister *self, moq_broadcast_Kind kind, moq_buf name, moq_Error **err); +MOQ_MUST_USE bool moq_broadcast_Lister_finish(const moq_broadcast_Lister *self, moq_broadcast_Kind kind, moq_buf name, moq_Error **err); void moq_broadcast_Lister_synced(const moq_broadcast_Lister *self); void moq_broadcast_Lister_clear(const moq_broadcast_Lister *self); void moq_broadcast_Lister_end(const moq_broadcast_Lister *self); @@ -4258,345 +4268,345 @@ void moq_broadcast_Lister_abort(const moq_broadcast_Lister *self, moq_Error *err void moq_broadcast_Tracks_free(moq_broadcast_Tracks *self); void moq_broadcast_Tracks_drop(moq_broadcast_Tracks *self, moq_status *status); typedef struct moq_broadcast_Tracks_next_future moq_broadcast_Tracks_next_future; -moq_broadcast_Tracks_next_future *moq_broadcast_Tracks_next(moq_broadcast_Tracks *self, moq_status *status); -moq_poll moq_broadcast_Tracks_next_start(moq_broadcast_Tracks *self, moq_broadcast_TracksEvent **out, moq_Error **err, moq_broadcast_Tracks_next_future **future, moq_status *status); -moq_poll moq_broadcast_Tracks_next_poll(moq_broadcast_Tracks_next_future *future, moq_waker waker, moq_broadcast_TracksEvent **out, moq_Error **err); +MOQ_MUST_USE moq_broadcast_Tracks_next_future *moq_broadcast_Tracks_next(moq_broadcast_Tracks *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_Tracks_next_start(moq_broadcast_Tracks *self, moq_broadcast_TracksEvent **out, moq_Error **err, moq_broadcast_Tracks_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_broadcast_Tracks_next_poll(moq_broadcast_Tracks_next_future *future, moq_waker waker, moq_broadcast_TracksEvent **out, moq_Error **err); void moq_broadcast_Tracks_next_future_free(moq_broadcast_Tracks_next_future *future); -moq_broadcast_Consumer *moq_broadcast_Tracks_broadcast(const moq_broadcast_Tracks *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Consumer *moq_broadcast_Tracks_broadcast(const moq_broadcast_Tracks *self, moq_status *status); void moq_broadcast_TracksEvent_free(moq_broadcast_TracksEvent *self); bool moq_broadcast_TracksEvent_borrowed(const moq_broadcast_TracksEvent *self); -moq_broadcast_TracksEvent *moq_broadcast_TracksEvent_clone(const moq_broadcast_TracksEvent *self); -moq_buf moq_broadcast_TracksEvent_debug(const moq_broadcast_TracksEvent *self); +MOQ_MUST_USE moq_broadcast_TracksEvent *moq_broadcast_TracksEvent_clone(const moq_broadcast_TracksEvent *self); +MOQ_MUST_USE moq_buf moq_broadcast_TracksEvent_debug(const moq_broadcast_TracksEvent *self); void moq_cache_Config_free(moq_cache_Config *self); void moq_cache_Config_drop(moq_cache_Config *self, moq_status *status); bool moq_cache_Config_borrowed(const moq_cache_Config *self); -moq_cache_Config *moq_cache_Config_clone(const moq_cache_Config *self, moq_status *status); -moq_buf moq_cache_Config_debug(const moq_cache_Config *self, moq_status *status); -moq_cache_Config *moq_cache_Config_default(void); -moq_cache_Config *moq_cache_Config_with_capacity(moq_cache_Config *self, moq_option_u64 capacity, moq_status *status); -moq_cache_Config *moq_cache_Config_with_expiry(moq_cache_Config *self, moq_option_duration expiry, moq_status *status); +MOQ_MUST_USE moq_cache_Config *moq_cache_Config_clone(const moq_cache_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_cache_Config_debug(const moq_cache_Config *self, moq_status *status); +MOQ_MUST_USE moq_cache_Config *moq_cache_Config_default(void); +MOQ_MUST_USE moq_cache_Config *moq_cache_Config_with_capacity(moq_cache_Config *self, moq_option_u64 capacity, moq_status *status); +MOQ_MUST_USE moq_cache_Config *moq_cache_Config_with_expiry(moq_cache_Config *self, moq_option_duration expiry, moq_status *status); void moq_cache_Pool_free(moq_cache_Pool *self); void moq_cache_Pool_drop(moq_cache_Pool *self, moq_status *status); bool moq_cache_Pool_borrowed(const moq_cache_Pool *self); -moq_cache_Pool *moq_cache_Pool_clone(const moq_cache_Pool *self, moq_status *status); -moq_buf moq_cache_Pool_debug(const moq_cache_Pool *self, moq_status *status); -moq_cache_Pool *moq_cache_Pool_default(void); -moq_cache_Pool *moq_cache_Pool_new(moq_cache_Config *config, moq_status *status); -moq_cache_Pool *moq_cache_Pool_unbounded(void); +MOQ_MUST_USE moq_cache_Pool *moq_cache_Pool_clone(const moq_cache_Pool *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_cache_Pool_debug(const moq_cache_Pool *self, moq_status *status); +MOQ_MUST_USE moq_cache_Pool *moq_cache_Pool_default(void); +MOQ_MUST_USE moq_cache_Pool *moq_cache_Pool_new(moq_cache_Config *config, moq_status *status); +MOQ_MUST_USE moq_cache_Pool *moq_cache_Pool_unbounded(void); moq_option_u64 moq_cache_Pool_capacity(const moq_cache_Pool *self, moq_status *status); uint64_t moq_cache_Pool_used(const moq_cache_Pool *self, moq_status *status); void moq_cache_Pool_resize(const moq_cache_Pool *self, moq_option_u64 capacity, moq_status *status); moq_option_duration moq_cache_Pool_expiry(const moq_cache_Pool *self, moq_status *status); moq_option_clock_Instant moq_cache_Pool_poll(const moq_cache_Pool *self, moq_clock_Instant now, const moq_Waiter *waiter, moq_status *status); -moq_cache_PoolWeak *moq_cache_Pool_downgrade(const moq_cache_Pool *self, moq_status *status); +MOQ_MUST_USE moq_cache_PoolWeak *moq_cache_Pool_downgrade(const moq_cache_Pool *self, moq_status *status); void moq_cache_PoolWeak_free(moq_cache_PoolWeak *self); bool moq_cache_PoolWeak_borrowed(const moq_cache_PoolWeak *self); -moq_cache_PoolWeak *moq_cache_PoolWeak_clone(const moq_cache_PoolWeak *self); -moq_buf moq_cache_PoolWeak_debug(const moq_cache_PoolWeak *self); -moq_cache_Pool *moq_cache_PoolWeak_upgrade(const moq_cache_PoolWeak *self); +MOQ_MUST_USE moq_cache_PoolWeak *moq_cache_PoolWeak_clone(const moq_cache_PoolWeak *self); +MOQ_MUST_USE moq_buf moq_cache_PoolWeak_debug(const moq_cache_PoolWeak *self); +MOQ_MUST_USE moq_cache_Pool *moq_cache_PoolWeak_upgrade(const moq_cache_PoolWeak *self); void moq_datagram_Producer_free(moq_datagram_Producer *self); void moq_datagram_Producer_drop(moq_datagram_Producer *self, moq_status *status); -moq_datagram_Producer *moq_datagram_Producer_clone(const moq_datagram_Producer *self, moq_status *status); -moq_buf moq_datagram_Producer_name(const moq_datagram_Producer *self, moq_status *status); -moq_datagram_Info *moq_datagram_Producer_info(const moq_datagram_Producer *self, moq_status *status); -bool moq_datagram_Producer_append(moq_datagram_Producer *self, moq_Timestamp timestamp, moq_buf payload, uint64_t *out, moq_Error **err, moq_status *status); -bool moq_datagram_Producer_insert(moq_datagram_Producer *self, moq_datagram_Datagram datagram, moq_Error **err, moq_status *status); -moq_datagram_Consumer *moq_datagram_Producer_consume(const moq_datagram_Producer *self, moq_status *status); +MOQ_MUST_USE moq_datagram_Producer *moq_datagram_Producer_clone(const moq_datagram_Producer *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_datagram_Producer_name(const moq_datagram_Producer *self, moq_status *status); +MOQ_MUST_USE moq_datagram_Info *moq_datagram_Producer_info(const moq_datagram_Producer *self, moq_status *status); +MOQ_MUST_USE bool moq_datagram_Producer_append(moq_datagram_Producer *self, moq_Timestamp timestamp, moq_buf payload, uint64_t *out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_datagram_Producer_insert(moq_datagram_Producer *self, moq_datagram_Datagram datagram, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_datagram_Consumer *moq_datagram_Producer_consume(const moq_datagram_Producer *self, moq_status *status); void moq_datagram_Producer_finish(moq_datagram_Producer *self, moq_status *status); void moq_datagram_Producer_abort(moq_datagram_Producer *self, moq_Error *err_, moq_status *status); moq_option_i8 moq_datagram_Producer_priority(const moq_datagram_Producer *self, moq_status *status); typedef struct moq_datagram_Producer_priority_changed_future moq_datagram_Producer_priority_changed_future; -moq_datagram_Producer_priority_changed_future *moq_datagram_Producer_priority_changed(moq_datagram_Producer *self, moq_status *status); -moq_poll moq_datagram_Producer_priority_changed_start(moq_datagram_Producer *self, moq_option_i8 *out, moq_datagram_Producer_priority_changed_future **future, moq_status *status); -moq_poll moq_datagram_Producer_priority_changed_poll(moq_datagram_Producer_priority_changed_future *future, moq_waker waker, moq_option_i8 *out); +MOQ_MUST_USE moq_datagram_Producer_priority_changed_future *moq_datagram_Producer_priority_changed(moq_datagram_Producer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_datagram_Producer_priority_changed_start(moq_datagram_Producer *self, moq_option_i8 *out, moq_datagram_Producer_priority_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_datagram_Producer_priority_changed_poll(moq_datagram_Producer_priority_changed_future *future, moq_waker waker, moq_option_i8 *out); void moq_datagram_Producer_priority_changed_future_free(moq_datagram_Producer_priority_changed_future *future); void moq_datagram_Request_free(moq_datagram_Request *self); void moq_datagram_Request_drop(moq_datagram_Request *self, moq_status *status); -moq_buf moq_datagram_Request_name(const moq_datagram_Request *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_datagram_Request_name(const moq_datagram_Request *self, moq_status *status); moq_option_i8 moq_datagram_Request_priority(const moq_datagram_Request *self, moq_status *status); -moq_datagram_Producer *moq_datagram_Request_accept(moq_datagram_Request *self, const moq_datagram_Info *info, moq_status *status); +MOQ_MUST_USE moq_datagram_Producer *moq_datagram_Request_accept(moq_datagram_Request *self, const moq_datagram_Info *info, moq_status *status); void moq_datagram_Request_reject(moq_datagram_Request *self, moq_Error *err_, moq_status *status); void moq_datagram_Consumer_free(moq_datagram_Consumer *self); void moq_datagram_Consumer_drop(moq_datagram_Consumer *self, moq_status *status); -moq_datagram_Consumer *moq_datagram_Consumer_clone(const moq_datagram_Consumer *self, moq_status *status); -moq_buf moq_datagram_Consumer_name(const moq_datagram_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_datagram_Consumer *moq_datagram_Consumer_clone(const moq_datagram_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_datagram_Consumer_name(const moq_datagram_Consumer *self, moq_status *status); typedef struct moq_datagram_Consumer_info_future moq_datagram_Consumer_info_future; -moq_datagram_Consumer_info_future *moq_datagram_Consumer_info(const moq_datagram_Consumer *self, moq_status *status); -moq_poll moq_datagram_Consumer_info_start(const moq_datagram_Consumer *self, moq_datagram_Info **out, moq_Error **err, moq_datagram_Consumer_info_future **future, moq_status *status); -moq_poll moq_datagram_Consumer_info_poll(moq_datagram_Consumer_info_future *future, moq_waker waker, moq_datagram_Info **out, moq_Error **err); +MOQ_MUST_USE moq_datagram_Consumer_info_future *moq_datagram_Consumer_info(const moq_datagram_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_datagram_Consumer_info_start(const moq_datagram_Consumer *self, moq_datagram_Info **out, moq_Error **err, moq_datagram_Consumer_info_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_datagram_Consumer_info_poll(moq_datagram_Consumer_info_future *future, moq_waker waker, moq_datagram_Info **out, moq_Error **err); void moq_datagram_Consumer_info_future_free(moq_datagram_Consumer_info_future *future); typedef struct moq_datagram_Consumer_recv_future moq_datagram_Consumer_recv_future; -moq_datagram_Consumer_recv_future *moq_datagram_Consumer_recv(moq_datagram_Consumer *self, moq_status *status); -moq_poll moq_datagram_Consumer_recv_start(moq_datagram_Consumer *self, moq_option_datagram_Datagram *out, moq_Error **err, moq_datagram_Consumer_recv_future **future, moq_status *status); -moq_poll moq_datagram_Consumer_recv_poll(moq_datagram_Consumer_recv_future *future, moq_waker waker, moq_option_datagram_Datagram *out, moq_Error **err); +MOQ_MUST_USE moq_datagram_Consumer_recv_future *moq_datagram_Consumer_recv(moq_datagram_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_datagram_Consumer_recv_start(moq_datagram_Consumer *self, moq_option_datagram_Datagram *out, moq_Error **err, moq_datagram_Consumer_recv_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_datagram_Consumer_recv_poll(moq_datagram_Consumer_recv_future *future, moq_waker waker, moq_option_datagram_Datagram *out, moq_Error **err); void moq_datagram_Consumer_recv_future_free(moq_datagram_Consumer_recv_future *future); int8_t moq_datagram_Consumer_priority(const moq_datagram_Consumer *self, moq_status *status); void moq_datagram_Consumer_set_priority(moq_datagram_Consumer *self, int8_t priority, moq_status *status); void moq_datagram_Info_free(moq_datagram_Info *self); void moq_datagram_Info_drop(moq_datagram_Info *self, moq_status *status); -moq_datagram_Info *moq_datagram_Info_clone(const moq_datagram_Info *self, moq_status *status); +MOQ_MUST_USE moq_datagram_Info *moq_datagram_Info_clone(const moq_datagram_Info *self, moq_status *status); bool moq_datagram_Info_eq(const moq_datagram_Info *a, const moq_datagram_Info *b, moq_status *status); -moq_buf moq_datagram_Info_debug(const moq_datagram_Info *self, moq_status *status); -moq_datagram_Info *moq_datagram_Info_default(void); +MOQ_MUST_USE moq_buf moq_datagram_Info_debug(const moq_datagram_Info *self, moq_status *status); +MOQ_MUST_USE moq_datagram_Info *moq_datagram_Info_default(void); moq_option_Timescale moq_datagram_Info_timescale_get(const moq_datagram_Info *self, moq_status *status); void moq_datagram_Info_timescale_set(moq_datagram_Info *self, moq_option_Timescale value, moq_status *status); int8_t moq_datagram_Info_priority_get(const moq_datagram_Info *self, moq_status *status); void moq_datagram_Info_priority_set(moq_datagram_Info *self, int8_t value, moq_status *status); -moq_datagram_Info *moq_datagram_Info_with_timescale(const moq_datagram_Info *self, moq_option_Timescale timescale, moq_status *status); -moq_datagram_Info *moq_datagram_Info_with_priority(const moq_datagram_Info *self, int8_t priority, moq_status *status); -bool moq_datagram_Info_rescale(const moq_datagram_Info *self, moq_Timestamp timestamp, moq_Timestamp *out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_datagram_Info *moq_datagram_Info_with_timescale(const moq_datagram_Info *self, moq_option_Timescale timescale, moq_status *status); +MOQ_MUST_USE moq_datagram_Info *moq_datagram_Info_with_priority(const moq_datagram_Info *self, int8_t priority, moq_status *status); +MOQ_MUST_USE bool moq_datagram_Info_rescale(const moq_datagram_Info *self, moq_Timestamp timestamp, moq_Timestamp *out, moq_Error **err, moq_status *status); void moq_frame_Producer_free(moq_frame_Producer *self); void moq_frame_Producer_drop(moq_frame_Producer *self, moq_status *status); -moq_group_Producer *moq_frame_Producer_group(const moq_frame_Producer *self, moq_status *status); +MOQ_MUST_USE moq_group_Producer *moq_frame_Producer_group(const moq_frame_Producer *self, moq_status *status); size_t moq_frame_Producer_remaining(const moq_frame_Producer *self, moq_status *status); -bool moq_frame_Producer_write(moq_frame_Producer *self, moq_buf chunk, moq_Error **err, moq_status *status); -bool moq_frame_Producer_finish(moq_frame_Producer *self, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_frame_Producer_abort(moq_frame_Producer *self, moq_Error *err_, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_frame_Producer_write(moq_frame_Producer *self, moq_buf chunk, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_frame_Producer_finish(moq_frame_Producer *self, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_frame_Producer_abort(moq_frame_Producer *self, moq_Error *err_, moq_Error **err, moq_status *status); uint64_t moq_frame_Producer_size_get(const moq_frame_Producer *self, moq_status *status); moq_Timestamp moq_frame_Producer_timestamp_get(const moq_frame_Producer *self, moq_status *status); void moq_frame_Frame_free(moq_frame_Frame *self); void moq_frame_Frame_drop(moq_frame_Frame *self, moq_status *status); -moq_frame_Frame *moq_frame_Frame_clone(const moq_frame_Frame *self, moq_status *status); -moq_buf moq_frame_Frame_debug(const moq_frame_Frame *self, moq_status *status); +MOQ_MUST_USE moq_frame_Frame *moq_frame_Frame_clone(const moq_frame_Frame *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_frame_Frame_debug(const moq_frame_Frame *self, moq_status *status); moq_Timestamp moq_frame_Frame_timestamp_get(const moq_frame_Frame *self, moq_status *status); void moq_frame_Frame_timestamp_set(moq_frame_Frame *self, moq_Timestamp value, moq_status *status); -moq_buf moq_frame_Frame_payload_get(const moq_frame_Frame *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_frame_Frame_payload_get(const moq_frame_Frame *self, moq_status *status); void moq_frame_Frame_payload_set(moq_frame_Frame *self, moq_buf value, moq_status *status); -moq_frame_Frame *moq_frame_Frame_new(moq_Timestamp timestamp, moq_buf payload); +MOQ_MUST_USE moq_frame_Frame *moq_frame_Frame_new(moq_Timestamp timestamp, moq_buf payload); moq_clock_Instant moq_frame_Frame_arrived(const moq_frame_Frame *self, moq_status *status); void moq_frame_Consumer_free(moq_frame_Consumer *self); void moq_frame_Consumer_drop(moq_frame_Consumer *self, moq_status *status); -moq_frame_Consumer *moq_frame_Consumer_clone(const moq_frame_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_frame_Consumer *moq_frame_Consumer_clone(const moq_frame_Consumer *self, moq_status *status); typedef struct moq_frame_Consumer_read_chunk_future moq_frame_Consumer_read_chunk_future; -moq_frame_Consumer_read_chunk_future *moq_frame_Consumer_read_chunk(moq_frame_Consumer *self, moq_status *status); -moq_poll moq_frame_Consumer_read_chunk_start(moq_frame_Consumer *self, moq_buf *out, moq_Error **err, moq_frame_Consumer_read_chunk_future **future, moq_status *status); -moq_poll moq_frame_Consumer_read_chunk_poll(moq_frame_Consumer_read_chunk_future *future, moq_waker waker, moq_buf *out, moq_Error **err); +MOQ_MUST_USE moq_frame_Consumer_read_chunk_future *moq_frame_Consumer_read_chunk(moq_frame_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_frame_Consumer_read_chunk_start(moq_frame_Consumer *self, moq_buf *out, moq_Error **err, moq_frame_Consumer_read_chunk_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_frame_Consumer_read_chunk_poll(moq_frame_Consumer_read_chunk_future *future, moq_waker waker, moq_buf *out, moq_Error **err); void moq_frame_Consumer_read_chunk_future_free(moq_frame_Consumer_read_chunk_future *future); typedef struct moq_frame_Consumer_read_all_future moq_frame_Consumer_read_all_future; -moq_frame_Consumer_read_all_future *moq_frame_Consumer_read_all(moq_frame_Consumer *self, moq_status *status); -moq_poll moq_frame_Consumer_read_all_start(moq_frame_Consumer *self, moq_buf *out, moq_Error **err, moq_frame_Consumer_read_all_future **future, moq_status *status); -moq_poll moq_frame_Consumer_read_all_poll(moq_frame_Consumer_read_all_future *future, moq_waker waker, moq_buf *out, moq_Error **err); +MOQ_MUST_USE moq_frame_Consumer_read_all_future *moq_frame_Consumer_read_all(moq_frame_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_frame_Consumer_read_all_start(moq_frame_Consumer *self, moq_buf *out, moq_Error **err, moq_frame_Consumer_read_all_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_frame_Consumer_read_all_poll(moq_frame_Consumer_read_all_future *future, moq_waker waker, moq_buf *out, moq_Error **err); void moq_frame_Consumer_read_all_future_free(moq_frame_Consumer_read_all_future *future); uint64_t moq_frame_Consumer_size_get(const moq_frame_Consumer *self, moq_status *status); moq_Timestamp moq_frame_Consumer_timestamp_get(const moq_frame_Consumer *self, moq_status *status); void moq_group_Producer_free(moq_group_Producer *self); void moq_group_Producer_drop(moq_group_Producer *self, moq_status *status); moq_option_Timescale moq_group_Producer_timescale(const moq_group_Producer *self, moq_status *status); -bool moq_group_Producer_start_at(moq_group_Producer *self, uint64_t index, moq_Error **err, moq_status *status); -bool moq_group_Producer_write_frame(moq_group_Producer *self, moq_Timestamp timestamp, moq_buf data_, moq_Error **err, moq_status *status); -bool moq_group_Producer_create_frame(moq_group_Producer *self, moq_frame_Info frame, moq_frame_Producer **out, moq_Error **err, moq_status *status); -bool moq_group_Producer_finish_at(moq_group_Producer *self, uint64_t end, moq_group_Finished **out, moq_Error **err, moq_status *status); -bool moq_group_Producer_finish(moq_group_Producer *self, moq_group_Finished **out, moq_Error **err, moq_status *status); -bool moq_group_Producer_abort(moq_group_Producer *self, moq_Error *err_, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_group_Producer_start_at(moq_group_Producer *self, uint64_t index, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_group_Producer_write_frame(moq_group_Producer *self, moq_Timestamp timestamp, moq_buf data_, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_group_Producer_create_frame(moq_group_Producer *self, moq_frame_Info frame, moq_frame_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_group_Producer_finish_at(moq_group_Producer *self, uint64_t end, moq_group_Finished **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_group_Producer_finish(moq_group_Producer *self, moq_group_Finished **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_group_Producer_abort(moq_group_Producer *self, moq_Error *err_, moq_Error **err, moq_status *status); typedef struct moq_group_Producer_ready_future moq_group_Producer_ready_future; -moq_group_Producer_ready_future *moq_group_Producer_ready(const moq_group_Producer *self, moq_frame_Info frame, moq_status *status); -moq_poll moq_group_Producer_ready_start(const moq_group_Producer *self, moq_frame_Info frame, moq_group_Producer_ready_future **future, moq_status *status); -moq_poll moq_group_Producer_ready_poll(moq_group_Producer_ready_future *future, moq_waker waker); +MOQ_MUST_USE moq_group_Producer_ready_future *moq_group_Producer_ready(const moq_group_Producer *self, moq_frame_Info frame, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Producer_ready_start(const moq_group_Producer *self, moq_frame_Info frame, moq_group_Producer_ready_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Producer_ready_poll(moq_group_Producer_ready_future *future, moq_waker waker); void moq_group_Producer_ready_future_free(moq_group_Producer_ready_future *future); size_t moq_group_Producer_frame_count(const moq_group_Producer *self, moq_status *status); -moq_group_Consumer *moq_group_Producer_consume(const moq_group_Producer *self, moq_status *status); +MOQ_MUST_USE moq_group_Consumer *moq_group_Producer_consume(const moq_group_Producer *self, moq_status *status); typedef struct moq_group_Producer_closed_future moq_group_Producer_closed_future; -moq_group_Producer_closed_future *moq_group_Producer_closed(const moq_group_Producer *self, moq_status *status); -moq_poll moq_group_Producer_closed_start(const moq_group_Producer *self, moq_Error **err, moq_group_Producer_closed_future **future, moq_status *status); -moq_poll moq_group_Producer_closed_poll(moq_group_Producer_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_group_Producer_closed_future *moq_group_Producer_closed(const moq_group_Producer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Producer_closed_start(const moq_group_Producer *self, moq_Error **err, moq_group_Producer_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Producer_closed_poll(moq_group_Producer_closed_future *future, moq_waker waker, moq_Error **err); void moq_group_Producer_closed_future_free(moq_group_Producer_closed_future *future); -moq_group_Demand *moq_group_Producer_demand(const moq_group_Producer *self, moq_status *status); +MOQ_MUST_USE moq_group_Demand *moq_group_Producer_demand(const moq_group_Producer *self, moq_status *status); uint64_t moq_group_Producer_start_get(const moq_group_Producer *self, moq_status *status); void moq_group_Finished_free(moq_group_Finished *self); void moq_group_Finished_drop(moq_group_Finished *self, moq_status *status); -bool moq_group_Finished_abort(moq_group_Finished *self, moq_Error *err_, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_group_Finished_abort(moq_group_Finished *self, moq_Error *err_, moq_Error **err, moq_status *status); size_t moq_group_Finished_frame_count(const moq_group_Finished *self, moq_status *status); -moq_group_Consumer *moq_group_Finished_consume(const moq_group_Finished *self, moq_status *status); +MOQ_MUST_USE moq_group_Consumer *moq_group_Finished_consume(const moq_group_Finished *self, moq_status *status); uint64_t moq_group_Finished_start_get(const moq_group_Finished *self, moq_status *status); void moq_group_Demand_free(moq_group_Demand *self); void moq_group_Demand_drop(moq_group_Demand *self, moq_status *status); -moq_group_Demand *moq_group_Demand_clone(const moq_group_Demand *self, moq_status *status); +MOQ_MUST_USE moq_group_Demand *moq_group_Demand_clone(const moq_group_Demand *self, moq_status *status); uint64_t moq_group_Demand_start(const moq_group_Demand *self, moq_status *status); bool moq_group_Demand_wanted(const moq_group_Demand *self, moq_status *status); typedef struct moq_group_Demand_wanted_changed_future moq_group_Demand_wanted_changed_future; -moq_group_Demand_wanted_changed_future *moq_group_Demand_wanted_changed(moq_group_Demand *self, moq_status *status); -moq_poll moq_group_Demand_wanted_changed_start(moq_group_Demand *self, bool *out, moq_Error **err, moq_group_Demand_wanted_changed_future **future, moq_status *status); -moq_poll moq_group_Demand_wanted_changed_poll(moq_group_Demand_wanted_changed_future *future, moq_waker waker, bool *out, moq_Error **err); +MOQ_MUST_USE moq_group_Demand_wanted_changed_future *moq_group_Demand_wanted_changed(moq_group_Demand *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Demand_wanted_changed_start(moq_group_Demand *self, bool *out, moq_Error **err, moq_group_Demand_wanted_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Demand_wanted_changed_poll(moq_group_Demand_wanted_changed_future *future, moq_waker waker, bool *out, moq_Error **err); void moq_group_Demand_wanted_changed_future_free(moq_group_Demand_wanted_changed_future *future); typedef struct moq_group_Demand_closed_future moq_group_Demand_closed_future; -moq_group_Demand_closed_future *moq_group_Demand_closed(const moq_group_Demand *self, moq_status *status); -moq_poll moq_group_Demand_closed_start(const moq_group_Demand *self, moq_Error **err, moq_group_Demand_closed_future **future, moq_status *status); -moq_poll moq_group_Demand_closed_poll(moq_group_Demand_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_group_Demand_closed_future *moq_group_Demand_closed(const moq_group_Demand *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Demand_closed_start(const moq_group_Demand *self, moq_Error **err, moq_group_Demand_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Demand_closed_poll(moq_group_Demand_closed_future *future, moq_waker waker, moq_Error **err); void moq_group_Demand_closed_future_free(moq_group_Demand_closed_future *future); void moq_group_Consumer_free(moq_group_Consumer *self); void moq_group_Consumer_drop(moq_group_Consumer *self, moq_status *status); -moq_group_Consumer *moq_group_Consumer_clone(const moq_group_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_group_Consumer *moq_group_Consumer_clone(const moq_group_Consumer *self, moq_status *status); moq_option_Timescale moq_group_Consumer_timescale(const moq_group_Consumer *self, moq_status *status); moq_clock_Instant moq_group_Consumer_arrived(const moq_group_Consumer *self, moq_status *status); uint64_t moq_group_Consumer_index(const moq_group_Consumer *self, moq_status *status); -moq_group_Consumer *moq_group_Consumer_with_range(moq_group_Consumer *self, moq_bounds_u64 frames, moq_status *status); +MOQ_MUST_USE moq_group_Consumer *moq_group_Consumer_with_range(moq_group_Consumer *self, moq_bounds_u64 frames, moq_status *status); void moq_group_Consumer_skip_to(moq_group_Consumer *self, uint64_t index, moq_status *status); size_t moq_group_Consumer_frame_count(const moq_group_Consumer *self, moq_status *status); moq_option_u64 moq_group_Consumer_end(const moq_group_Consumer *self, moq_status *status); typedef struct moq_group_Consumer_next_frame_future moq_group_Consumer_next_frame_future; -moq_group_Consumer_next_frame_future *moq_group_Consumer_next_frame(moq_group_Consumer *self, moq_status *status); -moq_poll moq_group_Consumer_next_frame_start(moq_group_Consumer *self, moq_frame_Consumer **out, moq_Error **err, moq_group_Consumer_next_frame_future **future, moq_status *status); -moq_poll moq_group_Consumer_next_frame_poll(moq_group_Consumer_next_frame_future *future, moq_waker waker, moq_frame_Consumer **out, moq_Error **err); +MOQ_MUST_USE moq_group_Consumer_next_frame_future *moq_group_Consumer_next_frame(moq_group_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Consumer_next_frame_start(moq_group_Consumer *self, moq_frame_Consumer **out, moq_Error **err, moq_group_Consumer_next_frame_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Consumer_next_frame_poll(moq_group_Consumer_next_frame_future *future, moq_waker waker, moq_frame_Consumer **out, moq_Error **err); void moq_group_Consumer_next_frame_future_free(moq_group_Consumer_next_frame_future *future); typedef struct moq_group_Consumer_read_frame_future moq_group_Consumer_read_frame_future; -moq_group_Consumer_read_frame_future *moq_group_Consumer_read_frame(moq_group_Consumer *self, moq_status *status); -moq_poll moq_group_Consumer_read_frame_start(moq_group_Consumer *self, moq_frame_Frame **out, moq_Error **err, moq_group_Consumer_read_frame_future **future, moq_status *status); -moq_poll moq_group_Consumer_read_frame_poll(moq_group_Consumer_read_frame_future *future, moq_waker waker, moq_frame_Frame **out, moq_Error **err); +MOQ_MUST_USE moq_group_Consumer_read_frame_future *moq_group_Consumer_read_frame(moq_group_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Consumer_read_frame_start(moq_group_Consumer *self, moq_frame_Frame **out, moq_Error **err, moq_group_Consumer_read_frame_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Consumer_read_frame_poll(moq_group_Consumer_read_frame_future *future, moq_waker waker, moq_frame_Frame **out, moq_Error **err); void moq_group_Consumer_read_frame_future_free(moq_group_Consumer_read_frame_future *future); typedef struct moq_group_Consumer_finished_future moq_group_Consumer_finished_future; -moq_group_Consumer_finished_future *moq_group_Consumer_finished(moq_group_Consumer *self, moq_status *status); -moq_poll moq_group_Consumer_finished_start(moq_group_Consumer *self, uint64_t *out, moq_Error **err, moq_group_Consumer_finished_future **future, moq_status *status); -moq_poll moq_group_Consumer_finished_poll(moq_group_Consumer_finished_future *future, moq_waker waker, uint64_t *out, moq_Error **err); +MOQ_MUST_USE moq_group_Consumer_finished_future *moq_group_Consumer_finished(moq_group_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Consumer_finished_start(moq_group_Consumer *self, uint64_t *out, moq_Error **err, moq_group_Consumer_finished_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_group_Consumer_finished_poll(moq_group_Consumer_finished_future *future, moq_waker waker, uint64_t *out, moq_Error **err); void moq_group_Consumer_finished_future_free(moq_group_Consumer_finished_future *future); uint64_t moq_group_Consumer_start_get(const moq_group_Consumer *self, moq_status *status); void moq_group_Fetch_free(moq_group_Fetch *self); void moq_group_Fetch_drop(moq_group_Fetch *self, moq_status *status); -moq_group_Fetch *moq_group_Fetch_clone(const moq_group_Fetch *self, moq_status *status); -moq_buf moq_group_Fetch_debug(const moq_group_Fetch *self, moq_status *status); -moq_group_Fetch *moq_group_Fetch_default(void); +MOQ_MUST_USE moq_group_Fetch *moq_group_Fetch_clone(const moq_group_Fetch *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_group_Fetch_debug(const moq_group_Fetch *self, moq_status *status); +MOQ_MUST_USE moq_group_Fetch *moq_group_Fetch_default(void); int8_t moq_group_Fetch_priority_get(const moq_group_Fetch *self, moq_status *status); void moq_group_Fetch_priority_set(moq_group_Fetch *self, int8_t value, moq_status *status); moq_option_duration moq_group_Fetch_max_delay_get(const moq_group_Fetch *self, moq_status *status); void moq_group_Fetch_max_delay_set(moq_group_Fetch *self, moq_option_duration value, moq_status *status); -moq_group_Fetch *moq_group_Fetch_with_priority(moq_group_Fetch *self, int8_t priority, moq_status *status); -moq_group_Fetch *moq_group_Fetch_with_max_delay(moq_group_Fetch *self, moq_duration max_delay, moq_status *status); +MOQ_MUST_USE moq_group_Fetch *moq_group_Fetch_with_priority(moq_group_Fetch *self, int8_t priority, moq_status *status); +MOQ_MUST_USE moq_group_Fetch *moq_group_Fetch_with_max_delay(moq_group_Fetch *self, moq_duration max_delay, moq_status *status); void moq_track_Finished_free(moq_track_Finished *self); void moq_track_Finished_drop(moq_track_Finished *self, moq_status *status); -moq_buf moq_track_Finished_name(const moq_track_Finished *self, moq_status *status); -moq_broadcast_Info *moq_track_Finished_broadcast(const moq_track_Finished *self, moq_status *status); -moq_track_Info *moq_track_Finished_info(const moq_track_Finished *self, moq_status *status); -moq_track_Requests *moq_track_Finished_requests(const moq_track_Finished *self, moq_status *status); -bool moq_track_Finished_create_group(const moq_track_Finished *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_track_Finished_abort(moq_track_Finished *self, moq_Error *err_, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_track_Finished_name(const moq_track_Finished *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_track_Finished_broadcast(const moq_track_Finished *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_track_Finished_info(const moq_track_Finished *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_track_Finished_requests(const moq_track_Finished *self, moq_status *status); +MOQ_MUST_USE bool moq_track_Finished_create_group(const moq_track_Finished *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_track_Finished_abort(moq_track_Finished *self, moq_Error *err_, moq_Error **err, moq_status *status); typedef struct moq_track_Finished_closed_future moq_track_Finished_closed_future; -moq_track_Finished_closed_future *moq_track_Finished_closed(const moq_track_Finished *self, moq_status *status); -moq_poll moq_track_Finished_closed_start(const moq_track_Finished *self, moq_Error **err, moq_track_Finished_closed_future **future, moq_status *status); -moq_poll moq_track_Finished_closed_poll(moq_track_Finished_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_track_Finished_closed_future *moq_track_Finished_closed(const moq_track_Finished *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Finished_closed_start(const moq_track_Finished *self, moq_Error **err, moq_track_Finished_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Finished_closed_poll(moq_track_Finished_closed_future *future, moq_waker waker, moq_Error **err); void moq_track_Finished_closed_future_free(moq_track_Finished_closed_future *future); -moq_track_Consumer *moq_track_Finished_consume(const moq_track_Finished *self, moq_status *status); -moq_track_Subscriber *moq_track_Finished_subscribe(const moq_track_Finished *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Consumer *moq_track_Finished_consume(const moq_track_Finished *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_track_Finished_subscribe(const moq_track_Finished *self, moq_track_Subscription *subscription, moq_status *status); void moq_track_Requests_free(moq_track_Requests *self); -moq_track_Requests *moq_track_Requests_clone(const moq_track_Requests *self); -moq_buf moq_track_Requests_name(const moq_track_Requests *self); +MOQ_MUST_USE moq_track_Requests *moq_track_Requests_clone(const moq_track_Requests *self); +MOQ_MUST_USE moq_buf moq_track_Requests_name(const moq_track_Requests *self); typedef struct moq_track_Requests_requested_fill_future moq_track_Requests_requested_fill_future; -moq_track_Requests_requested_fill_future *moq_track_Requests_requested_fill(const moq_track_Requests *self); -moq_poll moq_track_Requests_requested_fill_start(const moq_track_Requests *self, moq_track_Fill **out, moq_Error **err, moq_track_Requests_requested_fill_future **future); -moq_poll moq_track_Requests_requested_fill_poll(moq_track_Requests_requested_fill_future *future, moq_waker waker, moq_track_Fill **out, moq_Error **err); +MOQ_MUST_USE moq_track_Requests_requested_fill_future *moq_track_Requests_requested_fill(const moq_track_Requests *self); +MOQ_MUST_USE moq_poll moq_track_Requests_requested_fill_start(const moq_track_Requests *self, moq_track_Fill **out, moq_Error **err, moq_track_Requests_requested_fill_future **future); +MOQ_MUST_USE moq_poll moq_track_Requests_requested_fill_poll(moq_track_Requests_requested_fill_future *future, moq_waker waker, moq_track_Fill **out, moq_Error **err); void moq_track_Requests_requested_fill_future_free(moq_track_Requests_requested_fill_future *future); -moq_track_Demand *moq_track_Requests_demand(const moq_track_Requests *self); +MOQ_MUST_USE moq_track_Demand *moq_track_Requests_demand(const moq_track_Requests *self); void moq_track_Demand_free(moq_track_Demand *self); void moq_track_Demand_drop(moq_track_Demand *self, moq_status *status); -moq_track_Demand *moq_track_Demand_clone(const moq_track_Demand *self, moq_status *status); -moq_buf moq_track_Demand_name(const moq_track_Demand *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_track_Demand_clone(const moq_track_Demand *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_track_Demand_name(const moq_track_Demand *self, moq_status *status); bool moq_track_Demand_wanted(const moq_track_Demand *self, moq_status *status); typedef struct moq_track_Demand_wanted_changed_future moq_track_Demand_wanted_changed_future; -moq_track_Demand_wanted_changed_future *moq_track_Demand_wanted_changed(moq_track_Demand *self, moq_status *status); -moq_poll moq_track_Demand_wanted_changed_start(moq_track_Demand *self, bool *out, moq_Error **err, moq_track_Demand_wanted_changed_future **future, moq_status *status); -moq_poll moq_track_Demand_wanted_changed_poll(moq_track_Demand_wanted_changed_future *future, moq_waker waker, bool *out, moq_Error **err); +MOQ_MUST_USE moq_track_Demand_wanted_changed_future *moq_track_Demand_wanted_changed(moq_track_Demand *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Demand_wanted_changed_start(moq_track_Demand *self, bool *out, moq_Error **err, moq_track_Demand_wanted_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Demand_wanted_changed_poll(moq_track_Demand_wanted_changed_future *future, moq_waker waker, bool *out, moq_Error **err); void moq_track_Demand_wanted_changed_future_free(moq_track_Demand_wanted_changed_future *future); typedef struct moq_track_Demand_refresh_future moq_track_Demand_refresh_future; -moq_track_Demand_refresh_future *moq_track_Demand_refresh(const moq_track_Demand *self, moq_status *status); -moq_poll moq_track_Demand_refresh_start(const moq_track_Demand *self, moq_Error **err, moq_track_Demand_refresh_future **future, moq_status *status); -moq_poll moq_track_Demand_refresh_poll(moq_track_Demand_refresh_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_track_Demand_refresh_future *moq_track_Demand_refresh(const moq_track_Demand *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Demand_refresh_start(const moq_track_Demand *self, moq_Error **err, moq_track_Demand_refresh_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Demand_refresh_poll(moq_track_Demand_refresh_future *future, moq_waker waker, moq_Error **err); void moq_track_Demand_refresh_future_free(moq_track_Demand_refresh_future *future); typedef struct moq_track_Demand_closed_future moq_track_Demand_closed_future; -moq_track_Demand_closed_future *moq_track_Demand_closed(const moq_track_Demand *self, moq_status *status); -moq_poll moq_track_Demand_closed_start(const moq_track_Demand *self, moq_Error **err, moq_track_Demand_closed_future **future, moq_status *status); -moq_poll moq_track_Demand_closed_poll(moq_track_Demand_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_track_Demand_closed_future *moq_track_Demand_closed(const moq_track_Demand *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Demand_closed_start(const moq_track_Demand *self, moq_Error **err, moq_track_Demand_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Demand_closed_poll(moq_track_Demand_closed_future *future, moq_waker waker, moq_Error **err); void moq_track_Demand_closed_future_free(moq_track_Demand_closed_future *future); void moq_track_Subscriber_free(moq_track_Subscriber *self); void moq_track_Subscriber_drop(moq_track_Subscriber *self, moq_status *status); -moq_stats_Bill *moq_track_Subscriber_bill(moq_track_Subscriber *self, moq_status *status); -moq_track_Info *moq_track_Subscriber_info(const moq_track_Subscriber *self, moq_status *status); -moq_buf moq_track_Subscriber_name(const moq_track_Subscriber *self, moq_status *status); -moq_broadcast_Info *moq_track_Subscriber_broadcast(const moq_track_Subscriber *self, moq_status *status); -moq_track_Control *moq_track_Subscriber_control(const moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE moq_stats_Bill *moq_track_Subscriber_bill(moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_track_Subscriber_info(const moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_track_Subscriber_name(const moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_track_Subscriber_broadcast(const moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE moq_track_Control *moq_track_Subscriber_control(const moq_track_Subscriber *self, moq_status *status); typedef struct moq_track_Subscriber_recv_group_future moq_track_Subscriber_recv_group_future; -moq_track_Subscriber_recv_group_future *moq_track_Subscriber_recv_group(moq_track_Subscriber *self, moq_status *status); -moq_poll moq_track_Subscriber_recv_group_start(moq_track_Subscriber *self, moq_group_Consumer **out, moq_Error **err, moq_track_Subscriber_recv_group_future **future, moq_status *status); -moq_poll moq_track_Subscriber_recv_group_poll(moq_track_Subscriber_recv_group_future *future, moq_waker waker, moq_group_Consumer **out, moq_Error **err); +MOQ_MUST_USE moq_track_Subscriber_recv_group_future *moq_track_Subscriber_recv_group(moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Subscriber_recv_group_start(moq_track_Subscriber *self, moq_group_Consumer **out, moq_Error **err, moq_track_Subscriber_recv_group_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Subscriber_recv_group_poll(moq_track_Subscriber_recv_group_future *future, moq_waker waker, moq_group_Consumer **out, moq_Error **err); void moq_track_Subscriber_recv_group_future_free(moq_track_Subscriber_recv_group_future *future); -moq_track_Ordered *moq_track_Subscriber_ordered(moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE moq_track_Ordered *moq_track_Subscriber_ordered(moq_track_Subscriber *self, moq_status *status); bool moq_track_Subscriber_is_clone(const moq_track_Subscriber *self, const moq_track_Subscriber *other, moq_status *status); typedef struct moq_track_Subscriber_start_future moq_track_Subscriber_start_future; -moq_track_Subscriber_start_future *moq_track_Subscriber_start(moq_track_Subscriber *self, moq_status *status); -moq_poll moq_track_Subscriber_start_start(moq_track_Subscriber *self, moq_option_u64 *out, moq_track_Subscriber_start_future **future, moq_status *status); -moq_poll moq_track_Subscriber_start_poll(moq_track_Subscriber_start_future *future, moq_waker waker, moq_option_u64 *out); +MOQ_MUST_USE moq_track_Subscriber_start_future *moq_track_Subscriber_start(moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Subscriber_start_start(moq_track_Subscriber *self, moq_option_u64 *out, moq_track_Subscriber_start_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Subscriber_start_poll(moq_track_Subscriber_start_future *future, moq_waker waker, moq_option_u64 *out); void moq_track_Subscriber_start_future_free(moq_track_Subscriber_start_future *future); moq_option_u64 moq_track_Subscriber_floor(const moq_track_Subscriber *self, moq_status *status); moq_option_u64 moq_track_Subscriber_next_in_range(const moq_track_Subscriber *self, uint64_t from, moq_status *status); bool moq_track_Subscriber_is_skipped(const moq_track_Subscriber *self, moq_range_u64 groups, moq_status *status); typedef struct moq_track_Subscriber_finished_future moq_track_Subscriber_finished_future; -moq_track_Subscriber_finished_future *moq_track_Subscriber_finished(moq_track_Subscriber *self, moq_status *status); -moq_poll moq_track_Subscriber_finished_start(moq_track_Subscriber *self, moq_track_Position *out, moq_Error **err, moq_track_Subscriber_finished_future **future, moq_status *status); -moq_poll moq_track_Subscriber_finished_poll(moq_track_Subscriber_finished_future *future, moq_waker waker, moq_track_Position *out, moq_Error **err); +MOQ_MUST_USE moq_track_Subscriber_finished_future *moq_track_Subscriber_finished(moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Subscriber_finished_start(moq_track_Subscriber *self, moq_track_Position *out, moq_Error **err, moq_track_Subscriber_finished_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Subscriber_finished_poll(moq_track_Subscriber_finished_future *future, moq_waker waker, moq_track_Position *out, moq_Error **err); void moq_track_Subscriber_finished_future_free(moq_track_Subscriber_finished_future *future); -moq_track_Subscriber *moq_track_Subscriber_with_range(moq_track_Subscriber *self, moq_bounds_u64 groups, moq_status *status); -moq_track_Subscription *moq_track_Subscriber_subscription(const moq_track_Subscriber *self, moq_status *status); -bool moq_track_Subscriber_update(moq_track_Subscriber *self, moq_track_Subscription *subscription, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_track_Subscriber_with_range(moq_track_Subscriber *self, moq_bounds_u64 groups, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_track_Subscriber_subscription(const moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE bool moq_track_Subscriber_update(moq_track_Subscriber *self, moq_track_Subscription *subscription, moq_Error **err, moq_status *status); typedef struct moq_track_Subscriber_largest_future moq_track_Subscriber_largest_future; -moq_track_Subscriber_largest_future *moq_track_Subscriber_largest(moq_track_Subscriber *self, moq_status *status); -moq_poll moq_track_Subscriber_largest_start(moq_track_Subscriber *self, moq_option_track_Position *out, moq_track_Subscriber_largest_future **future, moq_status *status); -moq_poll moq_track_Subscriber_largest_poll(moq_track_Subscriber_largest_future *future, moq_waker waker, moq_option_track_Position *out); +MOQ_MUST_USE moq_track_Subscriber_largest_future *moq_track_Subscriber_largest(moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Subscriber_largest_start(moq_track_Subscriber *self, moq_option_track_Position *out, moq_track_Subscriber_largest_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Subscriber_largest_poll(moq_track_Subscriber_largest_future *future, moq_waker waker, moq_option_track_Position *out); void moq_track_Subscriber_largest_future_free(moq_track_Subscriber_largest_future *future); typedef struct moq_track_Subscriber_refresh_future moq_track_Subscriber_refresh_future; -moq_track_Subscriber_refresh_future *moq_track_Subscriber_refresh(const moq_track_Subscriber *self, moq_status *status); -moq_poll moq_track_Subscriber_refresh_start(const moq_track_Subscriber *self, moq_Error **err, moq_track_Subscriber_refresh_future **future, moq_status *status); -moq_poll moq_track_Subscriber_refresh_poll(moq_track_Subscriber_refresh_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_track_Subscriber_refresh_future *moq_track_Subscriber_refresh(const moq_track_Subscriber *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Subscriber_refresh_start(const moq_track_Subscriber *self, moq_Error **err, moq_track_Subscriber_refresh_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Subscriber_refresh_poll(moq_track_Subscriber_refresh_future *future, moq_waker waker, moq_Error **err); void moq_track_Subscriber_refresh_future_free(moq_track_Subscriber_refresh_future *future); void moq_track_Ordered_free(moq_track_Ordered *self); void moq_track_Ordered_drop(moq_track_Ordered *self, moq_status *status); -moq_track_Info *moq_track_Ordered_info(const moq_track_Ordered *self, moq_status *status); -moq_buf moq_track_Ordered_name(const moq_track_Ordered *self, moq_status *status); -moq_broadcast_Info *moq_track_Ordered_broadcast(const moq_track_Ordered *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_track_Ordered_info(const moq_track_Ordered *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_track_Ordered_name(const moq_track_Ordered *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_track_Ordered_broadcast(const moq_track_Ordered *self, moq_status *status); typedef struct moq_track_Ordered_next_group_future moq_track_Ordered_next_group_future; -moq_track_Ordered_next_group_future *moq_track_Ordered_next_group(moq_track_Ordered *self, moq_status *status); -moq_poll moq_track_Ordered_next_group_start(moq_track_Ordered *self, moq_track_Item **out, moq_Error **err, moq_track_Ordered_next_group_future **future, moq_status *status); -moq_poll moq_track_Ordered_next_group_poll(moq_track_Ordered_next_group_future *future, moq_waker waker, moq_track_Item **out, moq_Error **err); +MOQ_MUST_USE moq_track_Ordered_next_group_future *moq_track_Ordered_next_group(moq_track_Ordered *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Ordered_next_group_start(moq_track_Ordered *self, moq_track_Item **out, moq_Error **err, moq_track_Ordered_next_group_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Ordered_next_group_poll(moq_track_Ordered_next_group_future *future, moq_waker waker, moq_track_Item **out, moq_Error **err); void moq_track_Ordered_next_group_future_free(moq_track_Ordered_next_group_future *future); -moq_track_Control *moq_track_Ordered_control(const moq_track_Ordered *self, moq_status *status); +MOQ_MUST_USE moq_track_Control *moq_track_Ordered_control(const moq_track_Ordered *self, moq_status *status); typedef struct moq_track_Ordered_refresh_future moq_track_Ordered_refresh_future; -moq_track_Ordered_refresh_future *moq_track_Ordered_refresh(const moq_track_Ordered *self, moq_status *status); -moq_poll moq_track_Ordered_refresh_start(const moq_track_Ordered *self, moq_Error **err, moq_track_Ordered_refresh_future **future, moq_status *status); -moq_poll moq_track_Ordered_refresh_poll(moq_track_Ordered_refresh_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_track_Ordered_refresh_future *moq_track_Ordered_refresh(const moq_track_Ordered *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Ordered_refresh_start(const moq_track_Ordered *self, moq_Error **err, moq_track_Ordered_refresh_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Ordered_refresh_poll(moq_track_Ordered_refresh_future *future, moq_waker waker, moq_Error **err); void moq_track_Ordered_refresh_future_free(moq_track_Ordered_refresh_future *future); -moq_track_Subscription *moq_track_Ordered_subscription(const moq_track_Ordered *self, moq_status *status); -bool moq_track_Ordered_update(moq_track_Ordered *self, moq_track_Subscription *subscription, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_track_Ordered_subscription(const moq_track_Ordered *self, moq_status *status); +MOQ_MUST_USE bool moq_track_Ordered_update(moq_track_Ordered *self, moq_track_Subscription *subscription, moq_Error **err, moq_status *status); typedef struct moq_track_Ordered_finished_future moq_track_Ordered_finished_future; -moq_track_Ordered_finished_future *moq_track_Ordered_finished(moq_track_Ordered *self, moq_status *status); -moq_poll moq_track_Ordered_finished_start(moq_track_Ordered *self, moq_track_Position *out, moq_Error **err, moq_track_Ordered_finished_future **future, moq_status *status); -moq_poll moq_track_Ordered_finished_poll(moq_track_Ordered_finished_future *future, moq_waker waker, moq_track_Position *out, moq_Error **err); +MOQ_MUST_USE moq_track_Ordered_finished_future *moq_track_Ordered_finished(moq_track_Ordered *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Ordered_finished_start(moq_track_Ordered *self, moq_track_Position *out, moq_Error **err, moq_track_Ordered_finished_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Ordered_finished_poll(moq_track_Ordered_finished_future *future, moq_waker waker, moq_track_Position *out, moq_Error **err); void moq_track_Ordered_finished_future_free(moq_track_Ordered_finished_future *future); typedef struct moq_track_Ordered_largest_future moq_track_Ordered_largest_future; -moq_track_Ordered_largest_future *moq_track_Ordered_largest(moq_track_Ordered *self, moq_status *status); -moq_poll moq_track_Ordered_largest_start(moq_track_Ordered *self, moq_option_track_Position *out, moq_track_Ordered_largest_future **future, moq_status *status); -moq_poll moq_track_Ordered_largest_poll(moq_track_Ordered_largest_future *future, moq_waker waker, moq_option_track_Position *out); +MOQ_MUST_USE moq_track_Ordered_largest_future *moq_track_Ordered_largest(moq_track_Ordered *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Ordered_largest_start(moq_track_Ordered *self, moq_option_track_Position *out, moq_track_Ordered_largest_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Ordered_largest_poll(moq_track_Ordered_largest_future *future, moq_waker waker, moq_option_track_Position *out); void moq_track_Ordered_largest_future_free(moq_track_Ordered_largest_future *future); bool moq_track_Ordered_is_skipped(const moq_track_Ordered *self, moq_range_u64 groups, moq_status *status); bool moq_track_Ordered_is_clone(const moq_track_Ordered *self, const moq_track_Ordered *other, moq_status *status); void moq_track_Item_free(moq_track_Item *self); void moq_track_Item_drop(moq_track_Item *self, moq_status *status); -moq_group_Consumer *moq_track_Item_group(moq_track_Item *self, moq_status *status); +MOQ_MUST_USE moq_group_Consumer *moq_track_Item_group(moq_track_Item *self, moq_status *status); void moq_track_Request_free(moq_track_Request *self); void moq_track_Request_drop(moq_track_Request *self, moq_status *status); -moq_buf moq_track_Request_name(const moq_track_Request *self, moq_status *status); -moq_track_Consumer *moq_track_Request_consume(const moq_track_Request *self, moq_status *status); -moq_track_Requests *moq_track_Request_requests(const moq_track_Request *self, moq_status *status); -moq_track_Demand *moq_track_Request_demand(const moq_track_Request *self, moq_status *status); -moq_track_Producer *moq_track_Request_accept(moq_track_Request *self, moq_track_Info *info, moq_status *status); +MOQ_MUST_USE moq_buf moq_track_Request_name(const moq_track_Request *self, moq_status *status); +MOQ_MUST_USE moq_track_Consumer *moq_track_Request_consume(const moq_track_Request *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_track_Request_requests(const moq_track_Request *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_track_Request_demand(const moq_track_Request *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_track_Request_accept(moq_track_Request *self, moq_track_Info *info, moq_status *status); void moq_track_Request_reject(moq_track_Request *self, moq_Error *err_, moq_status *status); -moq_track_Subscription *moq_track_Request_subscription(const moq_track_Request *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_track_Request_subscription(const moq_track_Request *self, moq_status *status); typedef struct moq_track_Request_subscription_changed_future moq_track_Request_subscription_changed_future; -moq_track_Request_subscription_changed_future *moq_track_Request_subscription_changed(moq_track_Request *self, moq_status *status); -moq_poll moq_track_Request_subscription_changed_start(moq_track_Request *self, moq_track_Subscription **out, moq_track_Request_subscription_changed_future **future, moq_status *status); -moq_poll moq_track_Request_subscription_changed_poll(moq_track_Request_subscription_changed_future *future, moq_waker waker, moq_track_Subscription **out); +MOQ_MUST_USE moq_track_Request_subscription_changed_future *moq_track_Request_subscription_changed(moq_track_Request *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Request_subscription_changed_start(moq_track_Request *self, moq_track_Subscription **out, moq_track_Request_subscription_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Request_subscription_changed_poll(moq_track_Request_subscription_changed_future *future, moq_waker waker, moq_track_Subscription **out); void moq_track_Request_subscription_changed_future_free(moq_track_Request_subscription_changed_future *future); void moq_track_Info_free(moq_track_Info *self); void moq_track_Info_drop(moq_track_Info *self, moq_status *status); -moq_track_Info *moq_track_Info_clone(const moq_track_Info *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_track_Info_clone(const moq_track_Info *self, moq_status *status); bool moq_track_Info_eq(const moq_track_Info *a, const moq_track_Info *b, moq_status *status); -moq_buf moq_track_Info_debug(const moq_track_Info *self, moq_status *status); -moq_track_Info *moq_track_Info_default(void); +MOQ_MUST_USE moq_buf moq_track_Info_debug(const moq_track_Info *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_track_Info_default(void); moq_option_Timescale moq_track_Info_timescale_get(const moq_track_Info *self, moq_status *status); void moq_track_Info_timescale_set(moq_track_Info *self, moq_option_Timescale value, moq_status *status); moq_option_duration moq_track_Info_max_age_get(const moq_track_Info *self, moq_status *status); @@ -4605,306 +4615,306 @@ int8_t moq_track_Info_priority_get(const moq_track_Info *self, moq_status *statu void moq_track_Info_priority_set(moq_track_Info *self, int8_t value, moq_status *status); moq_track_Compression moq_track_Info_compression_get(const moq_track_Info *self, moq_status *status); void moq_track_Info_compression_set(moq_track_Info *self, moq_track_Compression value, moq_status *status); -moq_track_Refresh *moq_track_Info_refresh_get(const moq_track_Info *self, moq_status *status); +MOQ_MUST_USE moq_track_Refresh *moq_track_Info_refresh_get(const moq_track_Info *self, moq_status *status); void moq_track_Info_refresh_set(moq_track_Info *self, const moq_track_Refresh *value, moq_status *status); -moq_track_Info *moq_track_Info_with_timescale(moq_track_Info *self, moq_option_Timescale timescale, moq_status *status); -moq_track_Info *moq_track_Info_with_max_age(moq_track_Info *self, moq_option_duration max_age, moq_status *status); -moq_track_Info *moq_track_Info_with_priority(moq_track_Info *self, int8_t priority, moq_status *status); -moq_track_Info *moq_track_Info_with_compression(moq_track_Info *self, moq_track_Compression compression, moq_status *status); -moq_track_Info *moq_track_Info_with_refresh(moq_track_Info *self, const moq_track_Refresh *refresh, moq_status *status); -bool moq_track_Info_rescale(const moq_track_Info *self, moq_Timestamp timestamp, moq_Timestamp *out, moq_Error **err, moq_status *status); -bool moq_track_Info_rescale_in(const moq_track_Info *self, moq_Timestamp timestamp, uint64_t key, moq_Timestamp *out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_track_Info_with_timescale(moq_track_Info *self, moq_option_Timescale timescale, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_track_Info_with_max_age(moq_track_Info *self, moq_option_duration max_age, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_track_Info_with_priority(moq_track_Info *self, int8_t priority, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_track_Info_with_compression(moq_track_Info *self, moq_track_Compression compression, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_track_Info_with_refresh(moq_track_Info *self, const moq_track_Refresh *refresh, moq_status *status); +MOQ_MUST_USE bool moq_track_Info_rescale(const moq_track_Info *self, moq_Timestamp timestamp, moq_Timestamp *out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_track_Info_rescale_in(const moq_track_Info *self, moq_Timestamp timestamp, uint64_t key, moq_Timestamp *out, moq_Error **err, moq_status *status); void moq_track_Refresh_free(moq_track_Refresh *self); void moq_track_Refresh_drop(moq_track_Refresh *self, moq_status *status); -moq_track_Refresh *moq_track_Refresh_clone(const moq_track_Refresh *self, moq_status *status); +MOQ_MUST_USE moq_track_Refresh *moq_track_Refresh_clone(const moq_track_Refresh *self, moq_status *status); bool moq_track_Refresh_eq(const moq_track_Refresh *a, const moq_track_Refresh *b, moq_status *status); uint64_t moq_track_Refresh_hash(const moq_track_Refresh *self, moq_status *status); -moq_buf moq_track_Refresh_debug(const moq_track_Refresh *self, moq_status *status); -moq_track_Refresh *moq_track_Refresh_default(void); +MOQ_MUST_USE moq_buf moq_track_Refresh_debug(const moq_track_Refresh *self, moq_status *status); +MOQ_MUST_USE moq_track_Refresh *moq_track_Refresh_default(void); moq_option_u32 moq_track_Refresh_ratio_get(const moq_track_Refresh *self, moq_status *status); void moq_track_Refresh_ratio_set(moq_track_Refresh *self, moq_option_u32 value, moq_status *status); moq_option_duration moq_track_Refresh_interval_get(const moq_track_Refresh *self, moq_status *status); void moq_track_Refresh_interval_set(moq_track_Refresh *self, moq_option_duration value, moq_status *status); -moq_track_Refresh *moq_track_Refresh_with_ratio(const moq_track_Refresh *self, moq_option_u32 ratio, moq_status *status); -moq_track_Refresh *moq_track_Refresh_with_interval(const moq_track_Refresh *self, moq_option_duration interval, moq_status *status); +MOQ_MUST_USE moq_track_Refresh *moq_track_Refresh_with_ratio(const moq_track_Refresh *self, moq_option_u32 ratio, moq_status *status); +MOQ_MUST_USE moq_track_Refresh *moq_track_Refresh_with_interval(const moq_track_Refresh *self, moq_option_duration interval, moq_status *status); void moq_track_Producer_free(moq_track_Producer *self); void moq_track_Producer_drop(moq_track_Producer *self, moq_status *status); -moq_track_Producer *moq_track_Producer_clone(const moq_track_Producer *self, moq_status *status); -moq_buf moq_track_Producer_name(const moq_track_Producer *self, moq_status *status); -moq_broadcast_Info *moq_track_Producer_broadcast(const moq_track_Producer *self, moq_status *status); -moq_track_Info *moq_track_Producer_info(const moq_track_Producer *self, moq_status *status); -bool moq_track_Producer_create_group(const moq_track_Producer *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_track_Producer_append_group(const moq_track_Producer *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_track_Producer_write_frame(moq_track_Producer *self, moq_Timestamp timestamp, moq_buf frame, moq_Error **err, moq_status *status); -bool moq_track_Producer_finish(moq_track_Producer *self, moq_track_Finished **out, moq_Error **err, moq_status *status); -bool moq_track_Producer_fail(moq_track_Producer *self, moq_Error *err_, moq_track_Finished **out, moq_Error **err, moq_status *status); -bool moq_track_Producer_finish_at(moq_track_Producer *self, moq_track_Position end, moq_Error **err, moq_status *status); -bool moq_track_Producer_start_at(moq_track_Producer *self, moq_option_u64 key, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_track_Producer_clone(const moq_track_Producer *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_track_Producer_name(const moq_track_Producer *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_track_Producer_broadcast(const moq_track_Producer *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_track_Producer_info(const moq_track_Producer *self, moq_status *status); +MOQ_MUST_USE bool moq_track_Producer_create_group(const moq_track_Producer *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_track_Producer_append_group(const moq_track_Producer *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_track_Producer_write_frame(moq_track_Producer *self, moq_Timestamp timestamp, moq_buf frame, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_track_Producer_finish(moq_track_Producer *self, moq_track_Finished **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_track_Producer_fail(moq_track_Producer *self, moq_Error *err_, moq_track_Finished **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_track_Producer_finish_at(moq_track_Producer *self, moq_track_Position end, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_track_Producer_start_at(moq_track_Producer *self, moq_option_u64 key, moq_Error **err, moq_status *status); void moq_track_Producer_skip_groups(const moq_track_Producer *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_track_Producer_finished(const moq_track_Producer *self, moq_status *status); -bool moq_track_Producer_abort(moq_track_Producer *self, moq_Error *err_, moq_Error **err, moq_status *status); -bool moq_track_Producer_abort_unwanted(moq_track_Producer *self, moq_Error *err_, moq_track_Producer **err, moq_status *status); +MOQ_MUST_USE bool moq_track_Producer_abort(moq_track_Producer *self, moq_Error *err_, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_track_Producer_abort_unwanted(moq_track_Producer *self, moq_Error *err_, moq_track_Producer **err, moq_status *status); typedef struct moq_track_Producer_closed_future moq_track_Producer_closed_future; -moq_track_Producer_closed_future *moq_track_Producer_closed(const moq_track_Producer *self, moq_status *status); -moq_poll moq_track_Producer_closed_start(const moq_track_Producer *self, moq_Error **err, moq_track_Producer_closed_future **future, moq_status *status); -moq_poll moq_track_Producer_closed_poll(moq_track_Producer_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_track_Producer_closed_future *moq_track_Producer_closed(const moq_track_Producer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Producer_closed_start(const moq_track_Producer *self, moq_Error **err, moq_track_Producer_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Producer_closed_poll(moq_track_Producer_closed_future *future, moq_waker waker, moq_Error **err); void moq_track_Producer_closed_future_free(moq_track_Producer_closed_future *future); bool moq_track_Producer_is_closed(const moq_track_Producer *self, moq_status *status); moq_option_track_Position moq_track_Producer_largest(const moq_track_Producer *self, moq_status *status); bool moq_track_Producer_is_clone(const moq_track_Producer *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_track_Producer_abort_handle(const moq_track_Producer *self, moq_status *status); -moq_track_Demand *moq_track_Producer_demand(const moq_track_Producer *self, moq_status *status); -moq_track_Consumer *moq_track_Producer_consume(const moq_track_Producer *self, moq_status *status); -moq_track_Subscriber *moq_track_Producer_subscribe(const moq_track_Producer *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_track_Producer_subscription(const moq_track_Producer *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_track_Producer_abort_handle(const moq_track_Producer *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_track_Producer_demand(const moq_track_Producer *self, moq_status *status); +MOQ_MUST_USE moq_track_Consumer *moq_track_Producer_consume(const moq_track_Producer *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_track_Producer_subscribe(const moq_track_Producer *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_track_Producer_subscription(const moq_track_Producer *self, moq_status *status); typedef struct moq_track_Producer_subscription_changed_future moq_track_Producer_subscription_changed_future; -moq_track_Producer_subscription_changed_future *moq_track_Producer_subscription_changed(moq_track_Producer *self, moq_status *status); -moq_poll moq_track_Producer_subscription_changed_start(moq_track_Producer *self, moq_track_Subscription **out, moq_Error **err, moq_track_Producer_subscription_changed_future **future, moq_status *status); -moq_poll moq_track_Producer_subscription_changed_poll(moq_track_Producer_subscription_changed_future *future, moq_waker waker, moq_track_Subscription **out, moq_Error **err); +MOQ_MUST_USE moq_track_Producer_subscription_changed_future *moq_track_Producer_subscription_changed(moq_track_Producer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Producer_subscription_changed_start(moq_track_Producer *self, moq_track_Subscription **out, moq_Error **err, moq_track_Producer_subscription_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Producer_subscription_changed_poll(moq_track_Producer_subscription_changed_future *future, moq_waker waker, moq_track_Subscription **out, moq_Error **err); void moq_track_Producer_subscription_changed_future_free(moq_track_Producer_subscription_changed_future *future); -moq_track_Requests *moq_track_Producer_requests(const moq_track_Producer *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_track_Producer_requests(const moq_track_Producer *self, moq_status *status); void moq_track_AbortHandle_free(moq_track_AbortHandle *self); bool moq_track_AbortHandle_borrowed(const moq_track_AbortHandle *self); -moq_track_AbortHandle *moq_track_AbortHandle_clone(const moq_track_AbortHandle *self); +MOQ_MUST_USE moq_track_AbortHandle *moq_track_AbortHandle_clone(const moq_track_AbortHandle *self); bool moq_track_AbortHandle_is_closed(const moq_track_AbortHandle *self); void moq_track_AbortHandle_abort(const moq_track_AbortHandle *self, moq_Error *err_, moq_status *status); void moq_track_Consumer_free(moq_track_Consumer *self); void moq_track_Consumer_drop(moq_track_Consumer *self, moq_status *status); -moq_track_Consumer *moq_track_Consumer_clone(const moq_track_Consumer *self, moq_status *status); -moq_track_Consumer *moq_track_Consumer_unmetered(moq_track_Consumer *self, moq_status *status); -moq_buf moq_track_Consumer_name(const moq_track_Consumer *self, moq_status *status); -moq_broadcast_Info *moq_track_Consumer_broadcast(const moq_track_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_track_Consumer *moq_track_Consumer_clone(const moq_track_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_track_Consumer *moq_track_Consumer_unmetered(moq_track_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_track_Consumer_name(const moq_track_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_track_Consumer_broadcast(const moq_track_Consumer *self, moq_status *status); typedef struct moq_track_Consumer_subscribe_future moq_track_Consumer_subscribe_future; -moq_track_Consumer_subscribe_future *moq_track_Consumer_subscribe(const moq_track_Consumer *self, moq_track_Subscription *subscription, moq_status *status); -moq_poll moq_track_Consumer_subscribe_start(const moq_track_Consumer *self, moq_track_Subscription *subscription, moq_track_Subscriber **out, moq_Error **err, moq_track_Consumer_subscribe_future **future, moq_status *status); -moq_poll moq_track_Consumer_subscribe_poll(moq_track_Consumer_subscribe_future *future, moq_waker waker, moq_track_Subscriber **out, moq_Error **err); +MOQ_MUST_USE moq_track_Consumer_subscribe_future *moq_track_Consumer_subscribe(const moq_track_Consumer *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Consumer_subscribe_start(const moq_track_Consumer *self, moq_track_Subscription *subscription, moq_track_Subscriber **out, moq_Error **err, moq_track_Consumer_subscribe_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Consumer_subscribe_poll(moq_track_Consumer_subscribe_future *future, moq_waker waker, moq_track_Subscriber **out, moq_Error **err); void moq_track_Consumer_subscribe_future_free(moq_track_Consumer_subscribe_future *future); typedef struct moq_track_Consumer_fetch_group_future moq_track_Consumer_fetch_group_future; -moq_track_Consumer_fetch_group_future *moq_track_Consumer_fetch_group(const moq_track_Consumer *self, uint64_t key, moq_group_Fetch *options, moq_status *status); -moq_poll moq_track_Consumer_fetch_group_start(const moq_track_Consumer *self, uint64_t key, moq_group_Fetch *options, moq_group_Consumer **out, moq_Error **err, moq_track_Consumer_fetch_group_future **future, moq_status *status); -moq_poll moq_track_Consumer_fetch_group_poll(moq_track_Consumer_fetch_group_future *future, moq_waker waker, moq_group_Consumer **out, moq_Error **err); +MOQ_MUST_USE moq_track_Consumer_fetch_group_future *moq_track_Consumer_fetch_group(const moq_track_Consumer *self, uint64_t key, moq_group_Fetch *options, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Consumer_fetch_group_start(const moq_track_Consumer *self, uint64_t key, moq_group_Fetch *options, moq_group_Consumer **out, moq_Error **err, moq_track_Consumer_fetch_group_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Consumer_fetch_group_poll(moq_track_Consumer_fetch_group_future *future, moq_waker waker, moq_group_Consumer **out, moq_Error **err); void moq_track_Consumer_fetch_group_future_free(moq_track_Consumer_fetch_group_future *future); typedef struct moq_track_Consumer_info_future moq_track_Consumer_info_future; -moq_track_Consumer_info_future *moq_track_Consumer_info(const moq_track_Consumer *self, moq_status *status); -moq_poll moq_track_Consumer_info_start(const moq_track_Consumer *self, moq_track_Info **out, moq_Error **err, moq_track_Consumer_info_future **future, moq_status *status); -moq_poll moq_track_Consumer_info_poll(moq_track_Consumer_info_future *future, moq_waker waker, moq_track_Info **out, moq_Error **err); +MOQ_MUST_USE moq_track_Consumer_info_future *moq_track_Consumer_info(const moq_track_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Consumer_info_start(const moq_track_Consumer *self, moq_track_Info **out, moq_Error **err, moq_track_Consumer_info_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Consumer_info_poll(moq_track_Consumer_info_future *future, moq_waker waker, moq_track_Info **out, moq_Error **err); void moq_track_Consumer_info_future_free(moq_track_Consumer_info_future *future); typedef struct moq_track_Consumer_largest_future moq_track_Consumer_largest_future; -moq_track_Consumer_largest_future *moq_track_Consumer_largest(moq_track_Consumer *self, moq_status *status); -moq_poll moq_track_Consumer_largest_start(moq_track_Consumer *self, moq_option_track_Position *out, moq_track_Consumer_largest_future **future, moq_status *status); -moq_poll moq_track_Consumer_largest_poll(moq_track_Consumer_largest_future *future, moq_waker waker, moq_option_track_Position *out); +MOQ_MUST_USE moq_track_Consumer_largest_future *moq_track_Consumer_largest(moq_track_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Consumer_largest_start(moq_track_Consumer *self, moq_option_track_Position *out, moq_track_Consumer_largest_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_track_Consumer_largest_poll(moq_track_Consumer_largest_future *future, moq_waker waker, moq_option_track_Position *out); void moq_track_Consumer_largest_future_free(moq_track_Consumer_largest_future *future); void moq_track_Control_free(moq_track_Control *self); -moq_track_Control *moq_track_Control_clone(const moq_track_Control *self); -moq_track_Subscription *moq_track_Control_subscription(const moq_track_Control *self); -bool moq_track_Control_update(const moq_track_Control *self, moq_track_Subscription *subscription, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Control *moq_track_Control_clone(const moq_track_Control *self); +MOQ_MUST_USE moq_track_Subscription *moq_track_Control_subscription(const moq_track_Control *self); +MOQ_MUST_USE bool moq_track_Control_update(const moq_track_Control *self, moq_track_Subscription *subscription, moq_Error **err, moq_status *status); typedef struct moq_track_Control_refresh_future moq_track_Control_refresh_future; -moq_track_Control_refresh_future *moq_track_Control_refresh(const moq_track_Control *self); -moq_poll moq_track_Control_refresh_start(const moq_track_Control *self, moq_Error **err, moq_track_Control_refresh_future **future); -moq_poll moq_track_Control_refresh_poll(moq_track_Control_refresh_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_track_Control_refresh_future *moq_track_Control_refresh(const moq_track_Control *self); +MOQ_MUST_USE moq_poll moq_track_Control_refresh_start(const moq_track_Control *self, moq_Error **err, moq_track_Control_refresh_future **future); +MOQ_MUST_USE moq_poll moq_track_Control_refresh_poll(moq_track_Control_refresh_future *future, moq_waker waker, moq_Error **err); void moq_track_Control_refresh_future_free(moq_track_Control_refresh_future *future); void moq_track_Subscription_free(moq_track_Subscription *self); void moq_track_Subscription_drop(moq_track_Subscription *self, moq_status *status); -moq_track_Subscription *moq_track_Subscription_clone(const moq_track_Subscription *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_track_Subscription_clone(const moq_track_Subscription *self, moq_status *status); bool moq_track_Subscription_eq(const moq_track_Subscription *a, const moq_track_Subscription *b, moq_status *status); -moq_buf moq_track_Subscription_debug(const moq_track_Subscription *self, moq_status *status); -moq_track_Subscription *moq_track_Subscription_default(void); +MOQ_MUST_USE moq_buf moq_track_Subscription_debug(const moq_track_Subscription *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_track_Subscription_default(void); int8_t moq_track_Subscription_priority_get(const moq_track_Subscription *self, moq_status *status); void moq_track_Subscription_priority_set(moq_track_Subscription *self, int8_t value, moq_status *status); moq_track_Delay moq_track_Subscription_delay_get(const moq_track_Subscription *self, moq_status *status); void moq_track_Subscription_delay_set(moq_track_Subscription *self, moq_track_Delay value, moq_status *status); -moq_vec_track_Range moq_track_Subscription_ranges_get(const moq_track_Subscription *self, moq_status *status); +MOQ_MUST_USE moq_vec_track_Range moq_track_Subscription_ranges_get(const moq_track_Subscription *self, moq_status *status); void moq_track_Subscription_ranges_set(moq_track_Subscription *self, moq_vec_track_Range value, moq_status *status); moq_track_Order moq_track_Subscription_order_get(const moq_track_Subscription *self, moq_status *status); void moq_track_Subscription_order_set(moq_track_Subscription *self, moq_track_Order value, moq_status *status); -moq_track_Subscription *moq_track_Subscription_with_priority(moq_track_Subscription *self, int8_t priority, moq_status *status); -moq_track_Subscription *moq_track_Subscription_with_delay(moq_track_Subscription *self, moq_track_Delay delay, moq_status *status); -moq_track_Subscription *moq_track_Subscription_with_ranges(moq_track_Subscription *self, moq_vec_track_Range ranges, moq_status *status); -moq_track_Subscription *moq_track_Subscription_with_order(moq_track_Subscription *self, moq_track_Order order, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_track_Subscription_with_priority(moq_track_Subscription *self, int8_t priority, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_track_Subscription_with_delay(moq_track_Subscription *self, moq_track_Delay delay, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_track_Subscription_with_ranges(moq_track_Subscription *self, moq_vec_track_Range ranges, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_track_Subscription_with_order(moq_track_Subscription *self, moq_track_Order order, moq_status *status); void moq_track_Fill_free(moq_track_Fill *self); void moq_origin_Following_free(moq_origin_Following *self); void moq_origin_Following_drop(moq_origin_Following *self, moq_status *status); typedef struct moq_origin_Following_available_future moq_origin_Following_available_future; -moq_origin_Following_available_future *moq_origin_Following_available(moq_origin_Following *self, moq_status *status); -moq_poll moq_origin_Following_available_start(moq_origin_Following *self, moq_broadcast_Consumer **out, moq_Error **err, moq_origin_Following_available_future **future, moq_status *status); -moq_poll moq_origin_Following_available_poll(moq_origin_Following_available_future *future, moq_waker waker, moq_broadcast_Consumer **out, moq_Error **err); +MOQ_MUST_USE moq_origin_Following_available_future *moq_origin_Following_available(moq_origin_Following *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_origin_Following_available_start(moq_origin_Following *self, moq_broadcast_Consumer **out, moq_Error **err, moq_origin_Following_available_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_origin_Following_available_poll(moq_origin_Following_available_future *future, moq_waker waker, moq_broadcast_Consumer **out, moq_Error **err); void moq_origin_Following_available_future_free(moq_origin_Following_available_future *future); void moq_origin_Claim_free(moq_origin_Claim *self); -moq_origin_Claim *moq_origin_Claim_clone(const moq_origin_Claim *self); -moq_Instance *moq_origin_Claim_instance(const moq_origin_Claim *self); -bool moq_origin_Claim_announce(const moq_origin_Claim *self, moq_Error **err); +MOQ_MUST_USE moq_origin_Claim *moq_origin_Claim_clone(const moq_origin_Claim *self); +MOQ_MUST_USE moq_Instance *moq_origin_Claim_instance(const moq_origin_Claim *self); +MOQ_MUST_USE bool moq_origin_Claim_announce(const moq_origin_Claim *self, moq_Error **err); void moq_origin_Claim_withdraw(const moq_origin_Claim *self); bool moq_origin_Claim_is_announced(const moq_origin_Claim *self); -bool moq_origin_Claim_set_cost(const moq_origin_Claim *self, moq_origin_Cost cost, moq_Error **err); -bool moq_origin_Claim_set_auth(const moq_origin_Claim *self, moq_auth_Credential *auth, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_origin_Claim_set_cost(const moq_origin_Claim *self, moq_origin_Cost cost, moq_Error **err); +MOQ_MUST_USE bool moq_origin_Claim_set_auth(const moq_origin_Claim *self, moq_auth_Credential *auth, moq_Error **err, moq_status *status); typedef struct moq_origin_Claim_requested_future moq_origin_Claim_requested_future; -moq_origin_Claim_requested_future *moq_origin_Claim_requested(const moq_origin_Claim *self); -moq_poll moq_origin_Claim_requested_start(const moq_origin_Claim *self, moq_origin_Request **out, moq_origin_Claim_requested_future **future); -moq_poll moq_origin_Claim_requested_poll(moq_origin_Claim_requested_future *future, moq_waker waker, moq_origin_Request **out); +MOQ_MUST_USE moq_origin_Claim_requested_future *moq_origin_Claim_requested(const moq_origin_Claim *self); +MOQ_MUST_USE moq_poll moq_origin_Claim_requested_start(const moq_origin_Claim *self, moq_origin_Request **out, moq_origin_Claim_requested_future **future); +MOQ_MUST_USE moq_poll moq_origin_Claim_requested_poll(moq_origin_Claim_requested_future *future, moq_waker waker, moq_origin_Request **out); void moq_origin_Claim_requested_future_free(moq_origin_Claim_requested_future *future); void moq_origin_Config_free(moq_origin_Config *self); void moq_origin_Config_drop(moq_origin_Config *self, moq_status *status); -moq_origin_Config *moq_origin_Config_clone(const moq_origin_Config *self, moq_status *status); -moq_buf moq_origin_Config_debug(const moq_origin_Config *self, moq_status *status); -moq_origin_Config *moq_origin_Config_default(void); +MOQ_MUST_USE moq_origin_Config *moq_origin_Config_clone(const moq_origin_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_origin_Config_debug(const moq_origin_Config *self, moq_status *status); +MOQ_MUST_USE moq_origin_Config *moq_origin_Config_default(void); uint64_t moq_origin_Config_node_get(const moq_origin_Config *self, moq_status *status); void moq_origin_Config_node_set(moq_origin_Config *self, uint64_t value, moq_status *status); size_t moq_origin_Config_max_hops_get(const moq_origin_Config *self, moq_status *status); void moq_origin_Config_max_hops_set(moq_origin_Config *self, size_t value, moq_status *status); -moq_cache_Pool *moq_origin_Config_pool_get(const moq_origin_Config *self, moq_status *status); +MOQ_MUST_USE moq_cache_Pool *moq_origin_Config_pool_get(const moq_origin_Config *self, moq_status *status); void moq_origin_Config_pool_set(moq_origin_Config *self, moq_cache_Pool *value, moq_status *status); moq_option_duration moq_origin_Config_cache_duration_get(const moq_origin_Config *self, moq_status *status); void moq_origin_Config_cache_duration_set(moq_origin_Config *self, moq_option_duration value, moq_status *status); -moq_origin_Config *moq_origin_Config_new(uint64_t node); +MOQ_MUST_USE moq_origin_Config *moq_origin_Config_new(uint64_t node); void moq_origin_Consumer_free(moq_origin_Consumer *self); void moq_origin_Consumer_drop(moq_origin_Consumer *self, moq_status *status); -moq_origin_Consumer *moq_origin_Consumer_clone(const moq_origin_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_origin_Consumer *moq_origin_Consumer_clone(const moq_origin_Consumer *self, moq_status *status); uint64_t moq_origin_Consumer_node(const moq_origin_Consumer *self, moq_status *status); -moq_origin_Consumer *moq_origin_Consumer_with_hidden(moq_origin_Consumer *self, bool hidden, moq_status *status); -moq_origin_Consumer *moq_origin_Consumer_covering(moq_origin_Consumer *self, moq_status *status); -bool moq_origin_Consumer_exclude(const moq_origin_Consumer *self, moq_buf prefix, moq_origin_Consumer **out, moq_Error **err, moq_status *status); -moq_origin_Consumer *moq_origin_Consumer_with_stats(moq_origin_Consumer *self, moq_stats_Session *session, moq_status *status); -moq_announce_Consumer *moq_origin_Consumer_announced(const moq_origin_Consumer *self, moq_status *status); -moq_origin_Routes *moq_origin_Consumer_routes(const moq_origin_Consumer *self, moq_status *status); -moq_origin_Consumer *moq_origin_Consumer_consume(const moq_origin_Consumer *self, moq_status *status); -bool moq_origin_Consumer_follow(const moq_origin_Consumer *self, moq_buf path, moq_Instance *instance, moq_origin_Following **out, moq_Error **err, moq_status *status); -bool moq_origin_Consumer_scope(const moq_origin_Consumer *self, moq_buf root, const moq_Patterns *patterns, moq_origin_Consumer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_origin_Consumer *moq_origin_Consumer_with_hidden(moq_origin_Consumer *self, bool hidden, moq_status *status); +MOQ_MUST_USE moq_origin_Consumer *moq_origin_Consumer_covering(moq_origin_Consumer *self, moq_status *status); +MOQ_MUST_USE bool moq_origin_Consumer_exclude(const moq_origin_Consumer *self, moq_buf prefix, moq_origin_Consumer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_origin_Consumer *moq_origin_Consumer_with_stats(moq_origin_Consumer *self, moq_stats_Session *session, moq_status *status); +MOQ_MUST_USE moq_announce_Consumer *moq_origin_Consumer_announced(const moq_origin_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_origin_Routes *moq_origin_Consumer_routes(const moq_origin_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_origin_Consumer *moq_origin_Consumer_consume(const moq_origin_Consumer *self, moq_status *status); +MOQ_MUST_USE bool moq_origin_Consumer_follow(const moq_origin_Consumer *self, moq_buf path, moq_Instance *instance, moq_origin_Following **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_origin_Consumer_scope(const moq_origin_Consumer *self, moq_buf root, const moq_Patterns *patterns, moq_origin_Consumer **out, moq_Error **err, moq_status *status); typedef struct moq_origin_Consumer_request_future moq_origin_Consumer_request_future; -moq_origin_Consumer_request_future *moq_origin_Consumer_request(const moq_origin_Consumer *self, moq_buf path, moq_Instance *instance, moq_status *status); -moq_poll moq_origin_Consumer_request_start(const moq_origin_Consumer *self, moq_buf path, moq_Instance *instance, moq_broadcast_Consumer **out, moq_Error **err, moq_origin_Consumer_request_future **future, moq_status *status); -moq_poll moq_origin_Consumer_request_poll(moq_origin_Consumer_request_future *future, moq_waker waker, moq_broadcast_Consumer **out, moq_Error **err); +MOQ_MUST_USE moq_origin_Consumer_request_future *moq_origin_Consumer_request(const moq_origin_Consumer *self, moq_buf path, moq_Instance *instance, moq_status *status); +MOQ_MUST_USE moq_poll moq_origin_Consumer_request_start(const moq_origin_Consumer *self, moq_buf path, moq_Instance *instance, moq_broadcast_Consumer **out, moq_Error **err, moq_origin_Consumer_request_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_origin_Consumer_request_poll(moq_origin_Consumer_request_future *future, moq_waker waker, moq_broadcast_Consumer **out, moq_Error **err); void moq_origin_Consumer_request_future_free(moq_origin_Consumer_request_future *future); -moq_Path *moq_origin_Consumer_root(const moq_origin_Consumer *self, moq_status *status); -moq_Patterns *moq_origin_Consumer_allowed(const moq_origin_Consumer *self, moq_status *status); -bool moq_origin_Consumer_absolute(const moq_origin_Consumer *self, moq_buf path, moq_Path **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_Path *moq_origin_Consumer_root(const moq_origin_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_Patterns *moq_origin_Consumer_allowed(const moq_origin_Consumer *self, moq_status *status); +MOQ_MUST_USE bool moq_origin_Consumer_absolute(const moq_origin_Consumer *self, moq_buf path, moq_Path **out, moq_Error **err, moq_status *status); void moq_origin_Driver_free(moq_origin_Driver *self); void moq_origin_Driver_drop(moq_origin_Driver *self, moq_status *status); -bool moq_origin_Driver_poll(moq_origin_Driver *self, moq_clock_Instant now, const moq_Waiter *waiter, moq_option_clock_Instant *out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_origin_Driver_poll(moq_origin_Driver *self, moq_clock_Instant now, const moq_Waiter *waiter, moq_option_clock_Instant *out, moq_Error **err, moq_status *status); void moq_origin_Producer_free(moq_origin_Producer *self); void moq_origin_Producer_drop(moq_origin_Producer *self, moq_status *status); -moq_origin_Producer *moq_origin_Producer_clone(const moq_origin_Producer *self, moq_status *status); +MOQ_MUST_USE moq_origin_Producer *moq_origin_Producer_clone(const moq_origin_Producer *self, moq_status *status); void moq_origin_Producer_new(moq_origin_Config *config, moq_origin_Producer **out0, moq_origin_Driver **out1, moq_status *status); -moq_origin_Producer *moq_origin_Producer_with_stats(moq_origin_Producer *self, moq_stats_Session *session, moq_status *status); -moq_origin_Producer *moq_origin_Producer_with_link(moq_origin_Producer *self, moq_origin_Link link, moq_status *status); -moq_origin_Producer *moq_origin_Producer_with_priority(moq_origin_Producer *self, moq_origin_Priority priority, moq_status *status); -moq_origin_Producer *moq_origin_Producer_with_proxy(moq_origin_Producer *self, bool proxy, moq_status *status); -moq_origin_Config *moq_origin_Producer_config(const moq_origin_Producer *self, moq_status *status); +MOQ_MUST_USE moq_origin_Producer *moq_origin_Producer_with_stats(moq_origin_Producer *self, moq_stats_Session *session, moq_status *status); +MOQ_MUST_USE moq_origin_Producer *moq_origin_Producer_with_link(moq_origin_Producer *self, moq_origin_Link link, moq_status *status); +MOQ_MUST_USE moq_origin_Producer *moq_origin_Producer_with_priority(moq_origin_Producer *self, moq_origin_Priority priority, moq_status *status); +MOQ_MUST_USE moq_origin_Producer *moq_origin_Producer_with_proxy(moq_origin_Producer *self, bool proxy, moq_status *status); +MOQ_MUST_USE moq_origin_Config *moq_origin_Producer_config(const moq_origin_Producer *self, moq_status *status); uint64_t moq_origin_Producer_node(const moq_origin_Producer *self, moq_status *status); bool moq_origin_Producer_is_own(const moq_origin_Producer *self, uint64_t id, moq_status *status); -bool moq_origin_Producer_route(const moq_origin_Producer *self, moq_buf path, moq_origin_RouteOptions *options, moq_origin_Route **out, moq_Error **err, moq_status *status); -bool moq_origin_Producer_claim(const moq_origin_Producer *self, moq_buf prefix, moq_origin_RouteOptions *options, moq_origin_Claim **out, moq_Error **err, moq_status *status); -bool moq_origin_Producer_scope(const moq_origin_Producer *self, moq_buf root, const moq_Patterns *patterns, moq_origin_Producer **out, moq_Error **err, moq_status *status); -bool moq_origin_Producer_exclude(const moq_origin_Producer *self, moq_buf prefix, moq_origin_Producer **out, moq_Error **err, moq_status *status); -bool moq_origin_Producer_mount(const moq_origin_Producer *self, moq_buf at, moq_buf target, moq_origin_Producer **out, moq_Error **err, moq_status *status); -moq_origin_Consumer *moq_origin_Producer_consume(const moq_origin_Producer *self, moq_status *status); -moq_Path *moq_origin_Producer_root(const moq_origin_Producer *self, moq_status *status); -moq_Patterns *moq_origin_Producer_allowed(const moq_origin_Producer *self, moq_status *status); -bool moq_origin_Producer_absolute(const moq_origin_Producer *self, moq_buf path, moq_Path **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_origin_Producer_route(const moq_origin_Producer *self, moq_buf path, moq_origin_RouteOptions *options, moq_origin_Route **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_origin_Producer_claim(const moq_origin_Producer *self, moq_buf prefix, moq_origin_RouteOptions *options, moq_origin_Claim **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_origin_Producer_scope(const moq_origin_Producer *self, moq_buf root, const moq_Patterns *patterns, moq_origin_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_origin_Producer_exclude(const moq_origin_Producer *self, moq_buf prefix, moq_origin_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_origin_Producer_mount(const moq_origin_Producer *self, moq_buf at, moq_buf target, moq_origin_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_origin_Consumer *moq_origin_Producer_consume(const moq_origin_Producer *self, moq_status *status); +MOQ_MUST_USE moq_Path *moq_origin_Producer_root(const moq_origin_Producer *self, moq_status *status); +MOQ_MUST_USE moq_Patterns *moq_origin_Producer_allowed(const moq_origin_Producer *self, moq_status *status); +MOQ_MUST_USE bool moq_origin_Producer_absolute(const moq_origin_Producer *self, moq_buf path, moq_Path **out, moq_Error **err, moq_status *status); void moq_origin_Request_free(moq_origin_Request *self); void moq_origin_Request_drop(moq_origin_Request *self, moq_status *status); -moq_Path *moq_origin_Request_path(const moq_origin_Request *self, moq_status *status); -bool moq_origin_Request_route(moq_origin_Request *self, moq_origin_RouteOptions *options, moq_origin_Route **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_Path *moq_origin_Request_path(const moq_origin_Request *self, moq_status *status); +MOQ_MUST_USE bool moq_origin_Request_route(moq_origin_Request *self, moq_origin_RouteOptions *options, moq_origin_Route **out, moq_Error **err, moq_status *status); void moq_origin_Request_serve_Producer(moq_origin_Request *self, const moq_broadcast_Producer *broadcast, moq_status *status); void moq_origin_Request_serve_Consumer(moq_origin_Request *self, const moq_broadcast_Consumer *broadcast, moq_status *status); void moq_origin_Request_reject(moq_origin_Request *self, moq_Error *err_, moq_status *status); void moq_origin_Route_free(moq_origin_Route *self); -moq_origin_Route *moq_origin_Route_clone(const moq_origin_Route *self); -moq_broadcast_Producer *moq_origin_Route_broadcast(const moq_origin_Route *self); -moq_Instance *moq_origin_Route_instance(const moq_origin_Route *self); -bool moq_origin_Route_announce(const moq_origin_Route *self, moq_Error **err); +MOQ_MUST_USE moq_origin_Route *moq_origin_Route_clone(const moq_origin_Route *self); +MOQ_MUST_USE moq_broadcast_Producer *moq_origin_Route_broadcast(const moq_origin_Route *self); +MOQ_MUST_USE moq_Instance *moq_origin_Route_instance(const moq_origin_Route *self); +MOQ_MUST_USE bool moq_origin_Route_announce(const moq_origin_Route *self, moq_Error **err); void moq_origin_Route_withdraw(const moq_origin_Route *self); bool moq_origin_Route_is_announced(const moq_origin_Route *self); -bool moq_origin_Route_set_cost(const moq_origin_Route *self, moq_origin_Cost cost, moq_Error **err); -bool moq_origin_Route_set_auth(const moq_origin_Route *self, moq_auth_Credential *auth, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_origin_Route_set_cost(const moq_origin_Route *self, moq_origin_Cost cost, moq_Error **err); +MOQ_MUST_USE bool moq_origin_Route_set_auth(const moq_origin_Route *self, moq_auth_Credential *auth, moq_Error **err, moq_status *status); void moq_origin_RouteInfo_free(moq_origin_RouteInfo *self); void moq_origin_RouteInfo_drop(moq_origin_RouteInfo *self, moq_status *status); bool moq_origin_RouteInfo_borrowed(const moq_origin_RouteInfo *self); -moq_origin_RouteInfo *moq_origin_RouteInfo_clone(const moq_origin_RouteInfo *self, moq_status *status); +MOQ_MUST_USE moq_origin_RouteInfo *moq_origin_RouteInfo_clone(const moq_origin_RouteInfo *self, moq_status *status); bool moq_origin_RouteInfo_eq(const moq_origin_RouteInfo *a, const moq_origin_RouteInfo *b, moq_status *status); -moq_buf moq_origin_RouteInfo_debug(const moq_origin_RouteInfo *self, moq_status *status); -moq_Instance *moq_origin_RouteInfo_instance(const moq_origin_RouteInfo *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_origin_RouteInfo_debug(const moq_origin_RouteInfo *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_origin_RouteInfo_instance(const moq_origin_RouteInfo *self, moq_status *status); moq_origin_Cost moq_origin_RouteInfo_cost(const moq_origin_RouteInfo *self, moq_status *status); bool moq_origin_RouteInfo_available(const moq_origin_RouteInfo *self, moq_status *status); void moq_origin_RouteOptions_free(moq_origin_RouteOptions *self); void moq_origin_RouteOptions_drop(moq_origin_RouteOptions *self, moq_status *status); bool moq_origin_RouteOptions_borrowed(const moq_origin_RouteOptions *self); -moq_origin_RouteOptions *moq_origin_RouteOptions_clone(const moq_origin_RouteOptions *self, moq_status *status); -moq_buf moq_origin_RouteOptions_debug(const moq_origin_RouteOptions *self, moq_status *status); -moq_origin_RouteOptions *moq_origin_RouteOptions_default(void); -moq_origin_RouteOptions *moq_origin_RouteOptions_hidden(void); -moq_origin_RouteOptions *moq_origin_RouteOptions_with_cost(moq_origin_RouteOptions *self, moq_origin_Cost cost, moq_status *status); -moq_origin_RouteOptions *moq_origin_RouteOptions_with_auth(moq_origin_RouteOptions *self, moq_auth_Credential *auth, moq_status *status); -moq_origin_RouteOptions *moq_origin_RouteOptions_with_instance(moq_origin_RouteOptions *self, moq_Instance *instance, uint64_t epoch, moq_status *status); +MOQ_MUST_USE moq_origin_RouteOptions *moq_origin_RouteOptions_clone(const moq_origin_RouteOptions *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_origin_RouteOptions_debug(const moq_origin_RouteOptions *self, moq_status *status); +MOQ_MUST_USE moq_origin_RouteOptions *moq_origin_RouteOptions_default(void); +MOQ_MUST_USE moq_origin_RouteOptions *moq_origin_RouteOptions_hidden(void); +MOQ_MUST_USE moq_origin_RouteOptions *moq_origin_RouteOptions_with_cost(moq_origin_RouteOptions *self, moq_origin_Cost cost, moq_status *status); +MOQ_MUST_USE moq_origin_RouteOptions *moq_origin_RouteOptions_with_auth(moq_origin_RouteOptions *self, moq_auth_Credential *auth, moq_status *status); +MOQ_MUST_USE moq_origin_RouteOptions *moq_origin_RouteOptions_with_instance(moq_origin_RouteOptions *self, moq_Instance *instance, uint64_t epoch, moq_status *status); void moq_origin_RouteEvent_free(moq_origin_RouteEvent *self); void moq_origin_RouteEvent_drop(moq_origin_RouteEvent *self, moq_status *status); -moq_origin_RouteEvent *moq_origin_RouteEvent_clone(const moq_origin_RouteEvent *self, moq_status *status); -moq_buf moq_origin_RouteEvent_debug(const moq_origin_RouteEvent *self, moq_status *status); +MOQ_MUST_USE moq_origin_RouteEvent *moq_origin_RouteEvent_clone(const moq_origin_RouteEvent *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_origin_RouteEvent_debug(const moq_origin_RouteEvent *self, moq_status *status); moq_origin_RouteKind moq_origin_RouteEvent_kind_get(const moq_origin_RouteEvent *self, moq_status *status); void moq_origin_RouteEvent_kind_set(moq_origin_RouteEvent *self, moq_origin_RouteKind value, moq_status *status); -moq_announce_Announce *moq_origin_RouteEvent_announce_get(const moq_origin_RouteEvent *self, moq_status *status); +MOQ_MUST_USE moq_announce_Announce *moq_origin_RouteEvent_announce_get(const moq_origin_RouteEvent *self, moq_status *status); void moq_origin_RouteEvent_announce_set(moq_origin_RouteEvent *self, moq_announce_Announce *value, moq_status *status); void moq_origin_Routes_free(moq_origin_Routes *self); void moq_origin_Routes_drop(moq_origin_Routes *self, moq_status *status); typedef struct moq_origin_Routes_next_future moq_origin_Routes_next_future; -moq_origin_Routes_next_future *moq_origin_Routes_next(moq_origin_Routes *self, moq_status *status); -moq_poll moq_origin_Routes_next_start(moq_origin_Routes *self, moq_origin_RouteEvent **out, moq_origin_Routes_next_future **future, moq_status *status); -moq_poll moq_origin_Routes_next_poll(moq_origin_Routes_next_future *future, moq_waker waker, moq_origin_RouteEvent **out); +MOQ_MUST_USE moq_origin_Routes_next_future *moq_origin_Routes_next(moq_origin_Routes *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_origin_Routes_next_start(moq_origin_Routes *self, moq_origin_RouteEvent **out, moq_origin_Routes_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_origin_Routes_next_poll(moq_origin_Routes_next_future *future, moq_waker waker, moq_origin_RouteEvent **out); void moq_origin_Routes_next_future_free(moq_origin_Routes_next_future *future); -moq_origin_RouteEvent *moq_origin_Routes_try_next(moq_origin_Routes *self, moq_status *status); +MOQ_MUST_USE moq_origin_RouteEvent *moq_origin_Routes_try_next(moq_origin_Routes *self, moq_status *status); bool moq_origin_Routes_is_closed(const moq_origin_Routes *self, moq_status *status); typedef struct moq_origin_Routes_poll_synced_future moq_origin_Routes_poll_synced_future; -moq_origin_Routes_poll_synced_future *moq_origin_Routes_poll_synced(const moq_origin_Routes *self, moq_status *status); -moq_poll moq_origin_Routes_poll_synced_start(const moq_origin_Routes *self, moq_origin_Routes_poll_synced_future **future, moq_status *status); -moq_poll moq_origin_Routes_poll_synced_poll(moq_origin_Routes_poll_synced_future *future, moq_waker waker); +MOQ_MUST_USE moq_origin_Routes_poll_synced_future *moq_origin_Routes_poll_synced(const moq_origin_Routes *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_origin_Routes_poll_synced_start(const moq_origin_Routes *self, moq_origin_Routes_poll_synced_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_origin_Routes_poll_synced_poll(moq_origin_Routes_poll_synced_future *future, moq_waker waker); void moq_origin_Routes_poll_synced_future_free(moq_origin_Routes_poll_synced_future *future); -moq_Path *moq_origin_Routes_root(const moq_origin_Routes *self, moq_status *status); -bool moq_origin_Routes_absolute(const moq_origin_Routes *self, moq_buf prefix, moq_Path **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_Path *moq_origin_Routes_root(const moq_origin_Routes *self, moq_status *status); +MOQ_MUST_USE bool moq_origin_Routes_absolute(const moq_origin_Routes *self, moq_buf prefix, moq_Path **out, moq_Error **err, moq_status *status); void moq_announce_Consumer_free(moq_announce_Consumer *self); void moq_announce_Consumer_drop(moq_announce_Consumer *self, moq_status *status); typedef struct moq_announce_Consumer_next_future moq_announce_Consumer_next_future; -moq_announce_Consumer_next_future *moq_announce_Consumer_next(moq_announce_Consumer *self, moq_status *status); -moq_poll moq_announce_Consumer_next_start(moq_announce_Consumer *self, moq_announce_Event **out, moq_announce_Consumer_next_future **future, moq_status *status); -moq_poll moq_announce_Consumer_next_poll(moq_announce_Consumer_next_future *future, moq_waker waker, moq_announce_Event **out); +MOQ_MUST_USE moq_announce_Consumer_next_future *moq_announce_Consumer_next(moq_announce_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_announce_Consumer_next_start(moq_announce_Consumer *self, moq_announce_Event **out, moq_announce_Consumer_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_announce_Consumer_next_poll(moq_announce_Consumer_next_future *future, moq_waker waker, moq_announce_Event **out); void moq_announce_Consumer_next_future_free(moq_announce_Consumer_next_future *future); -moq_announce_Event *moq_announce_Consumer_try_next(moq_announce_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_announce_Event *moq_announce_Consumer_try_next(moq_announce_Consumer *self, moq_status *status); bool moq_announce_Consumer_is_closed(const moq_announce_Consumer *self, moq_status *status); typedef struct moq_announce_Consumer_poll_synced_future moq_announce_Consumer_poll_synced_future; -moq_announce_Consumer_poll_synced_future *moq_announce_Consumer_poll_synced(const moq_announce_Consumer *self, moq_status *status); -moq_poll moq_announce_Consumer_poll_synced_start(const moq_announce_Consumer *self, moq_announce_Consumer_poll_synced_future **future, moq_status *status); -moq_poll moq_announce_Consumer_poll_synced_poll(moq_announce_Consumer_poll_synced_future *future, moq_waker waker); +MOQ_MUST_USE moq_announce_Consumer_poll_synced_future *moq_announce_Consumer_poll_synced(const moq_announce_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_announce_Consumer_poll_synced_start(const moq_announce_Consumer *self, moq_announce_Consumer_poll_synced_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_announce_Consumer_poll_synced_poll(moq_announce_Consumer_poll_synced_future *future, moq_waker waker); void moq_announce_Consumer_poll_synced_future_free(moq_announce_Consumer_poll_synced_future *future); -moq_Path *moq_announce_Consumer_root(const moq_announce_Consumer *self, moq_status *status); -bool moq_announce_Consumer_absolute(const moq_announce_Consumer *self, moq_buf prefix, moq_Path **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_Path *moq_announce_Consumer_root(const moq_announce_Consumer *self, moq_status *status); +MOQ_MUST_USE bool moq_announce_Consumer_absolute(const moq_announce_Consumer *self, moq_buf prefix, moq_Path **out, moq_Error **err, moq_status *status); void moq_announce_Event_free(moq_announce_Event *self); bool moq_announce_Event_borrowed(const moq_announce_Event *self); -moq_announce_Event *moq_announce_Event_clone(const moq_announce_Event *self); -moq_buf moq_announce_Event_debug(const moq_announce_Event *self); +MOQ_MUST_USE moq_announce_Event *moq_announce_Event_clone(const moq_announce_Event *self); +MOQ_MUST_USE moq_buf moq_announce_Event_debug(const moq_announce_Event *self); void moq_announce_Announce_free(moq_announce_Announce *self); void moq_announce_Announce_drop(moq_announce_Announce *self, moq_status *status); -moq_announce_Announce *moq_announce_Announce_clone(const moq_announce_Announce *self, moq_status *status); -moq_buf moq_announce_Announce_debug(const moq_announce_Announce *self, moq_status *status); -moq_Path *moq_announce_Announce_prefix_get(const moq_announce_Announce *self, moq_status *status); +MOQ_MUST_USE moq_announce_Announce *moq_announce_Announce_clone(const moq_announce_Announce *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_announce_Announce_debug(const moq_announce_Announce *self, moq_status *status); +MOQ_MUST_USE moq_Path *moq_announce_Announce_prefix_get(const moq_announce_Announce *self, moq_status *status); void moq_announce_Announce_prefix_set(moq_announce_Announce *self, moq_Path *value, moq_status *status); -moq_vec_Pattern moq_announce_Announce_captures_get(const moq_announce_Announce *self, moq_status *status); +MOQ_MUST_USE moq_vec_Pattern moq_announce_Announce_captures_get(const moq_announce_Announce *self, moq_status *status); void moq_announce_Announce_captures_set(moq_announce_Announce *self, moq_vec_Pattern value, moq_status *status); -moq_origin_RouteInfo *moq_announce_Announce_route_get(const moq_announce_Announce *self, moq_status *status); +MOQ_MUST_USE moq_origin_RouteInfo *moq_announce_Announce_route_get(const moq_announce_Announce *self, moq_status *status); void moq_announce_Announce_route_set(moq_announce_Announce *self, moq_origin_RouteInfo *value, moq_status *status); void moq_hang_stats_Snapshot_free(moq_hang_stats_Snapshot *self); void moq_hang_stats_Snapshot_drop(moq_hang_stats_Snapshot *self, moq_status *status); -moq_hang_stats_Snapshot *moq_hang_stats_Snapshot_clone(const moq_hang_stats_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_hang_stats_Snapshot *moq_hang_stats_Snapshot_clone(const moq_hang_stats_Snapshot *self, moq_status *status); bool moq_hang_stats_Snapshot_eq(const moq_hang_stats_Snapshot *a, const moq_hang_stats_Snapshot *b, moq_status *status); -moq_buf moq_hang_stats_Snapshot_debug(const moq_hang_stats_Snapshot *self, moq_status *status); -moq_hang_stats_Snapshot *moq_hang_stats_Snapshot_default(void); -moq_hang_stats_Transport *moq_hang_stats_Snapshot_transport_get(const moq_hang_stats_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_stats_Snapshot_debug(const moq_hang_stats_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_hang_stats_Snapshot *moq_hang_stats_Snapshot_default(void); +MOQ_MUST_USE moq_hang_stats_Transport *moq_hang_stats_Snapshot_transport_get(const moq_hang_stats_Snapshot *self, moq_status *status); void moq_hang_stats_Snapshot_transport_set(moq_hang_stats_Snapshot *self, moq_hang_stats_Transport *value, moq_status *status); -moq_vec_tuple_string_hang_stats_Rendition moq_hang_stats_Snapshot_renditions_get(const moq_hang_stats_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_stats_Rendition moq_hang_stats_Snapshot_renditions_get(const moq_hang_stats_Snapshot *self, moq_status *status); void moq_hang_stats_Snapshot_renditions_set(moq_hang_stats_Snapshot *self, moq_vec_tuple_string_hang_stats_Rendition value, moq_status *status); void moq_hang_stats_Rendition_free(moq_hang_stats_Rendition *self); void moq_hang_stats_Rendition_drop(moq_hang_stats_Rendition *self, moq_status *status); -moq_hang_stats_Rendition *moq_hang_stats_Rendition_clone(const moq_hang_stats_Rendition *self, moq_status *status); +MOQ_MUST_USE moq_hang_stats_Rendition *moq_hang_stats_Rendition_clone(const moq_hang_stats_Rendition *self, moq_status *status); bool moq_hang_stats_Rendition_eq(const moq_hang_stats_Rendition *a, const moq_hang_stats_Rendition *b, moq_status *status); -moq_buf moq_hang_stats_Rendition_debug(const moq_hang_stats_Rendition *self, moq_status *status); -moq_hang_stats_Rendition *moq_hang_stats_Rendition_default(void); +MOQ_MUST_USE moq_buf moq_hang_stats_Rendition_debug(const moq_hang_stats_Rendition *self, moq_status *status); +MOQ_MUST_USE moq_hang_stats_Rendition *moq_hang_stats_Rendition_default(void); uint64_t moq_hang_stats_Rendition_frames_get(const moq_hang_stats_Rendition *self, moq_status *status); void moq_hang_stats_Rendition_frames_set(moq_hang_stats_Rendition *self, uint64_t value, moq_status *status); uint64_t moq_hang_stats_Rendition_bytes_get(const moq_hang_stats_Rendition *self, moq_status *status); @@ -4917,10 +4927,10 @@ moq_option_u64 moq_hang_stats_Rendition_bitrate_get(const moq_hang_stats_Renditi void moq_hang_stats_Rendition_bitrate_set(moq_hang_stats_Rendition *self, moq_option_u64 value, moq_status *status); void moq_hang_stats_Transport_free(moq_hang_stats_Transport *self); void moq_hang_stats_Transport_drop(moq_hang_stats_Transport *self, moq_status *status); -moq_hang_stats_Transport *moq_hang_stats_Transport_clone(const moq_hang_stats_Transport *self, moq_status *status); +MOQ_MUST_USE moq_hang_stats_Transport *moq_hang_stats_Transport_clone(const moq_hang_stats_Transport *self, moq_status *status); bool moq_hang_stats_Transport_eq(const moq_hang_stats_Transport *a, const moq_hang_stats_Transport *b, moq_status *status); -moq_buf moq_hang_stats_Transport_debug(const moq_hang_stats_Transport *self, moq_status *status); -moq_hang_stats_Transport *moq_hang_stats_Transport_default(void); +MOQ_MUST_USE moq_buf moq_hang_stats_Transport_debug(const moq_hang_stats_Transport *self, moq_status *status); +MOQ_MUST_USE moq_hang_stats_Transport *moq_hang_stats_Transport_default(void); moq_option_duration moq_hang_stats_Transport_rtt_get(const moq_hang_stats_Transport *self, moq_status *status); void moq_hang_stats_Transport_rtt_set(moq_hang_stats_Transport *self, moq_option_duration value, moq_status *status); moq_option_u64 moq_hang_stats_Transport_rate_get(const moq_hang_stats_Transport *self, moq_status *status); @@ -4933,20 +4943,20 @@ moq_option_duration moq_hang_stats_Transport_age_get(const moq_hang_stats_Transp void moq_hang_stats_Transport_age_set(moq_hang_stats_Transport *self, moq_option_duration value, moq_status *status); void moq_hang_echo_Snapshot_free(moq_hang_echo_Snapshot *self); void moq_hang_echo_Snapshot_drop(moq_hang_echo_Snapshot *self, moq_status *status); -moq_hang_echo_Snapshot *moq_hang_echo_Snapshot_clone(const moq_hang_echo_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_hang_echo_Snapshot *moq_hang_echo_Snapshot_clone(const moq_hang_echo_Snapshot *self, moq_status *status); bool moq_hang_echo_Snapshot_eq(const moq_hang_echo_Snapshot *a, const moq_hang_echo_Snapshot *b, moq_status *status); -moq_buf moq_hang_echo_Snapshot_debug(const moq_hang_echo_Snapshot *self, moq_status *status); -moq_hang_echo_Snapshot *moq_hang_echo_Snapshot_default(void); -moq_hang_stats_Transport *moq_hang_echo_Snapshot_transport_get(const moq_hang_echo_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_echo_Snapshot_debug(const moq_hang_echo_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_hang_echo_Snapshot *moq_hang_echo_Snapshot_default(void); +MOQ_MUST_USE moq_hang_stats_Transport *moq_hang_echo_Snapshot_transport_get(const moq_hang_echo_Snapshot *self, moq_status *status); void moq_hang_echo_Snapshot_transport_set(moq_hang_echo_Snapshot *self, moq_hang_stats_Transport *value, moq_status *status); -moq_vec_tuple_string_hang_echo_Rendition moq_hang_echo_Snapshot_renditions_get(const moq_hang_echo_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_echo_Rendition moq_hang_echo_Snapshot_renditions_get(const moq_hang_echo_Snapshot *self, moq_status *status); void moq_hang_echo_Snapshot_renditions_set(moq_hang_echo_Snapshot *self, moq_vec_tuple_string_hang_echo_Rendition value, moq_status *status); void moq_hang_echo_Rendition_free(moq_hang_echo_Rendition *self); void moq_hang_echo_Rendition_drop(moq_hang_echo_Rendition *self, moq_status *status); -moq_hang_echo_Rendition *moq_hang_echo_Rendition_clone(const moq_hang_echo_Rendition *self, moq_status *status); +MOQ_MUST_USE moq_hang_echo_Rendition *moq_hang_echo_Rendition_clone(const moq_hang_echo_Rendition *self, moq_status *status); bool moq_hang_echo_Rendition_eq(const moq_hang_echo_Rendition *a, const moq_hang_echo_Rendition *b, moq_status *status); -moq_buf moq_hang_echo_Rendition_debug(const moq_hang_echo_Rendition *self, moq_status *status); -moq_hang_echo_Rendition *moq_hang_echo_Rendition_default(void); +MOQ_MUST_USE moq_buf moq_hang_echo_Rendition_debug(const moq_hang_echo_Rendition *self, moq_status *status); +MOQ_MUST_USE moq_hang_echo_Rendition *moq_hang_echo_Rendition_default(void); uint64_t moq_hang_echo_Rendition_frames_get(const moq_hang_echo_Rendition *self, moq_status *status); void moq_hang_echo_Rendition_frames_set(moq_hang_echo_Rendition *self, uint64_t value, moq_status *status); uint64_t moq_hang_echo_Rendition_bytes_get(const moq_hang_echo_Rendition *self, moq_status *status); @@ -4963,87 +4973,87 @@ uint64_t moq_hang_echo_Rendition_underruns_get(const moq_hang_echo_Rendition *se void moq_hang_echo_Rendition_underruns_set(moq_hang_echo_Rendition *self, uint64_t value, moq_status *status); moq_duration moq_hang_echo_Rendition_stalled_get(const moq_hang_echo_Rendition *self, moq_status *status); void moq_hang_echo_Rendition_stalled_set(moq_hang_echo_Rendition *self, moq_duration value, moq_status *status); -moq_hang_echo_Arrival *moq_hang_echo_Rendition_arrival_get(const moq_hang_echo_Rendition *self, moq_status *status); +MOQ_MUST_USE moq_hang_echo_Arrival *moq_hang_echo_Rendition_arrival_get(const moq_hang_echo_Rendition *self, moq_status *status); void moq_hang_echo_Rendition_arrival_set(moq_hang_echo_Rendition *self, moq_hang_echo_Arrival *value, moq_status *status); void moq_hang_echo_Arrival_free(moq_hang_echo_Arrival *self); void moq_hang_echo_Arrival_drop(moq_hang_echo_Arrival *self, moq_status *status); -moq_hang_echo_Arrival *moq_hang_echo_Arrival_clone(const moq_hang_echo_Arrival *self, moq_status *status); +MOQ_MUST_USE moq_hang_echo_Arrival *moq_hang_echo_Arrival_clone(const moq_hang_echo_Arrival *self, moq_status *status); bool moq_hang_echo_Arrival_eq(const moq_hang_echo_Arrival *a, const moq_hang_echo_Arrival *b, moq_status *status); -moq_buf moq_hang_echo_Arrival_debug(const moq_hang_echo_Arrival *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_echo_Arrival_debug(const moq_hang_echo_Arrival *self, moq_status *status); moq_Timestamp moq_hang_echo_Arrival_timestamp_get(const moq_hang_echo_Arrival *self, moq_status *status); void moq_hang_echo_Arrival_timestamp_set(moq_hang_echo_Arrival *self, moq_Timestamp value, moq_status *status); moq_clock_Wall moq_hang_echo_Arrival_wall_get(const moq_hang_echo_Arrival *self, moq_status *status); void moq_hang_echo_Arrival_wall_set(moq_hang_echo_Arrival *self, moq_clock_Wall value, moq_status *status); -moq_hang_echo_Arrival *moq_hang_echo_Arrival_new(moq_Timestamp timestamp, moq_clock_Wall wall); +MOQ_MUST_USE moq_hang_echo_Arrival *moq_hang_echo_Arrival_new(moq_Timestamp timestamp, moq_clock_Wall wall); void moq_hang_catalog_Skipped_free(moq_hang_catalog_Skipped *self); void moq_hang_catalog_Skipped_drop(moq_hang_catalog_Skipped *self, moq_status *status); -moq_hang_catalog_Skipped *moq_hang_catalog_Skipped_clone(const moq_hang_catalog_Skipped *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Skipped *moq_hang_catalog_Skipped_clone(const moq_hang_catalog_Skipped *self, moq_status *status); bool moq_hang_catalog_Skipped_eq(const moq_hang_catalog_Skipped *a, const moq_hang_catalog_Skipped *b, moq_status *status); -moq_buf moq_hang_catalog_Skipped_debug(const moq_hang_catalog_Skipped *self, moq_status *status); -moq_hang_catalog_Skipped *moq_hang_catalog_Skipped_default(void); -moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_video_get(const moq_hang_catalog_Skipped *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_Skipped_debug(const moq_hang_catalog_Skipped *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Skipped *moq_hang_catalog_Skipped_default(void); +MOQ_MUST_USE moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_video_get(const moq_hang_catalog_Skipped *self, moq_status *status); void moq_hang_catalog_Skipped_video_set(moq_hang_catalog_Skipped *self, moq_vec_tuple_string_u64 value, moq_status *status); -moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_audio_get(const moq_hang_catalog_Skipped *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_audio_get(const moq_hang_catalog_Skipped *self, moq_status *status); void moq_hang_catalog_Skipped_audio_set(moq_hang_catalog_Skipped *self, moq_vec_tuple_string_u64 value, moq_status *status); -moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_text_get(const moq_hang_catalog_Skipped *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_text_get(const moq_hang_catalog_Skipped *self, moq_status *status); void moq_hang_catalog_Skipped_text_set(moq_hang_catalog_Skipped *self, moq_vec_tuple_string_u64 value, moq_status *status); -moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_json_get(const moq_hang_catalog_Skipped *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_json_get(const moq_hang_catalog_Skipped *self, moq_status *status); void moq_hang_catalog_Skipped_json_set(moq_hang_catalog_Skipped *self, moq_vec_tuple_string_u64 value, moq_status *status); -moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_binary_get(const moq_hang_catalog_Skipped *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_binary_get(const moq_hang_catalog_Skipped *self, moq_status *status); void moq_hang_catalog_Skipped_binary_set(moq_hang_catalog_Skipped *self, moq_vec_tuple_string_u64 value, moq_status *status); -moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_include_get(const moq_hang_catalog_Skipped *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_u64 moq_hang_catalog_Skipped_include_get(const moq_hang_catalog_Skipped *self, moq_status *status); void moq_hang_catalog_Skipped_include_set(moq_hang_catalog_Skipped *self, moq_vec_tuple_string_u64 value, moq_status *status); bool moq_hang_catalog_Skipped_is_empty(const moq_hang_catalog_Skipped *self, moq_status *status); moq_option_u64 moq_hang_catalog_Skipped_version(const moq_hang_catalog_Skipped *self, moq_status *status); void moq_hang_catalog_Consumer_free(moq_hang_catalog_Consumer *self); void moq_hang_catalog_Consumer_drop(moq_hang_catalog_Consumer *self, moq_status *status); -moq_hang_catalog_Consumer *moq_hang_catalog_Consumer_new(moq_track_Consumer *track, moq_duration delay, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Consumer *moq_hang_catalog_Consumer_new(moq_track_Consumer *track, moq_duration delay, moq_status *status); typedef struct moq_hang_catalog_Consumer_poll_next_future moq_hang_catalog_Consumer_poll_next_future; -moq_hang_catalog_Consumer_poll_next_future *moq_hang_catalog_Consumer_poll_next(moq_hang_catalog_Consumer *self, moq_status *status); -moq_poll moq_hang_catalog_Consumer_poll_next_start(moq_hang_catalog_Consumer *self, moq_moq_json_Timed_Catalog **out, moq_hang_Error **err, moq_hang_catalog_Consumer_poll_next_future **future, moq_status *status); -moq_poll moq_hang_catalog_Consumer_poll_next_poll(moq_hang_catalog_Consumer_poll_next_future *future, moq_waker waker, moq_moq_json_Timed_Catalog **out, moq_hang_Error **err); +MOQ_MUST_USE moq_hang_catalog_Consumer_poll_next_future *moq_hang_catalog_Consumer_poll_next(moq_hang_catalog_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_hang_catalog_Consumer_poll_next_start(moq_hang_catalog_Consumer *self, moq_moq_json_Timed_Catalog **out, moq_hang_Error **err, moq_hang_catalog_Consumer_poll_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_hang_catalog_Consumer_poll_next_poll(moq_hang_catalog_Consumer_poll_next_future *future, moq_waker waker, moq_moq_json_Timed_Catalog **out, moq_hang_Error **err); void moq_hang_catalog_Consumer_poll_next_future_free(moq_hang_catalog_Consumer_poll_next_future *future); void moq_hang_catalog_Audio_free(moq_hang_catalog_Audio *self); void moq_hang_catalog_Audio_drop(moq_hang_catalog_Audio *self, moq_status *status); -moq_hang_catalog_Audio *moq_hang_catalog_Audio_clone(const moq_hang_catalog_Audio *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Audio *moq_hang_catalog_Audio_clone(const moq_hang_catalog_Audio *self, moq_status *status); bool moq_hang_catalog_Audio_eq(const moq_hang_catalog_Audio *a, const moq_hang_catalog_Audio *b, moq_status *status); -moq_buf moq_hang_catalog_Audio_debug(const moq_hang_catalog_Audio *self, moq_status *status); -moq_hang_catalog_Audio *moq_hang_catalog_Audio_default(void); -moq_vec_tuple_string_hang_catalog_AudioConfig moq_hang_catalog_Audio_renditions_get(const moq_hang_catalog_Audio *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_Audio_debug(const moq_hang_catalog_Audio *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Audio *moq_hang_catalog_Audio_default(void); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_AudioConfig moq_hang_catalog_Audio_renditions_get(const moq_hang_catalog_Audio *self, moq_status *status); void moq_hang_catalog_Audio_renditions_set(moq_hang_catalog_Audio *self, moq_vec_tuple_string_hang_catalog_AudioConfig value, moq_status *status); -bool moq_hang_catalog_Audio_insert(moq_hang_catalog_Audio *self, moq_buf name, moq_hang_catalog_AudioConfig *config, moq_hang_Error **err, moq_status *status); -moq_hang_catalog_AudioConfig *moq_hang_catalog_Audio_remove(moq_hang_catalog_Audio *self, moq_buf name, moq_status *status); +MOQ_MUST_USE bool moq_hang_catalog_Audio_insert(moq_hang_catalog_Audio *self, moq_buf name, moq_hang_catalog_AudioConfig *config, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_AudioConfig *moq_hang_catalog_Audio_remove(moq_hang_catalog_Audio *self, moq_buf name, moq_status *status); bool moq_hang_catalog_Audio_is_empty(const moq_hang_catalog_Audio *self, moq_status *status); -moq_vec_tuple_string_hang_catalog_AudioConfig moq_hang_catalog_Audio_enabled(const moq_hang_catalog_Audio *self, moq_status *status); -moq_vec_tuple_string_hang_catalog_AudioConfig moq_hang_catalog_Audio_ranked(const moq_hang_catalog_Audio *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_AudioConfig moq_hang_catalog_Audio_enabled(const moq_hang_catalog_Audio *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_AudioConfig moq_hang_catalog_Audio_ranked(const moq_hang_catalog_Audio *self, moq_status *status); void moq_hang_catalog_AudioConfig_free(moq_hang_catalog_AudioConfig *self); void moq_hang_catalog_AudioConfig_drop(moq_hang_catalog_AudioConfig *self, moq_status *status); -moq_hang_catalog_AudioConfig *moq_hang_catalog_AudioConfig_clone(const moq_hang_catalog_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_AudioConfig *moq_hang_catalog_AudioConfig_clone(const moq_hang_catalog_AudioConfig *self, moq_status *status); bool moq_hang_catalog_AudioConfig_eq(const moq_hang_catalog_AudioConfig *a, const moq_hang_catalog_AudioConfig *b, moq_status *status); -moq_buf moq_hang_catalog_AudioConfig_debug(const moq_hang_catalog_AudioConfig *self, moq_status *status); -moq_path_Relative *moq_hang_catalog_AudioConfig_broadcast_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_AudioConfig_debug(const moq_hang_catalog_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_hang_catalog_AudioConfig_broadcast_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_broadcast_set(moq_hang_catalog_AudioConfig *self, moq_path_Relative *value, moq_status *status); -moq_buf moq_hang_catalog_AudioConfig_track_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_AudioConfig_track_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_track_set(moq_hang_catalog_AudioConfig *self, moq_buf value, moq_status *status); -moq_Instance *moq_hang_catalog_AudioConfig_instance_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_hang_catalog_AudioConfig_instance_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_instance_set(moq_hang_catalog_AudioConfig *self, moq_Instance *value, moq_status *status); -moq_buf moq_hang_catalog_AudioConfig_label_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_AudioConfig_label_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_label_set(moq_hang_catalog_AudioConfig *self, moq_buf value, moq_status *status); -moq_hang_catalog_AudioCodec moq_hang_catalog_AudioConfig_codec_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_AudioCodec moq_hang_catalog_AudioConfig_codec_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_codec_set(moq_hang_catalog_AudioConfig *self, moq_hang_catalog_AudioCodec value, moq_status *status); uint32_t moq_hang_catalog_AudioConfig_sample_rate_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_sample_rate_set(moq_hang_catalog_AudioConfig *self, uint32_t value, moq_status *status); uint32_t moq_hang_catalog_AudioConfig_channel_count_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_channel_count_set(moq_hang_catalog_AudioConfig *self, uint32_t value, moq_status *status); -moq_option_hang_catalog_AudioLayout moq_hang_catalog_AudioConfig_layout_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_option_hang_catalog_AudioLayout moq_hang_catalog_AudioConfig_layout_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_layout_set(moq_hang_catalog_AudioConfig *self, moq_option_hang_catalog_AudioLayout value, moq_status *status); moq_option_u64 moq_hang_catalog_AudioConfig_bitrate_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_bitrate_set(moq_hang_catalog_AudioConfig *self, moq_option_u64 value, moq_status *status); bool moq_hang_catalog_AudioConfig_enabled_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_enabled_set(moq_hang_catalog_AudioConfig *self, bool value, moq_status *status); -moq_buf moq_hang_catalog_AudioConfig_description_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_AudioConfig_description_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_description_set(moq_hang_catalog_AudioConfig *self, moq_buf value, moq_status *status); -moq_hang_catalog_Container *moq_hang_catalog_AudioConfig_container_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Container *moq_hang_catalog_AudioConfig_container_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_container_set(moq_hang_catalog_AudioConfig *self, moq_hang_catalog_Container *value, moq_status *status); moq_option_duration moq_hang_catalog_AudioConfig_jitter_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_jitter_set(moq_hang_catalog_AudioConfig *self, moq_option_duration value, moq_status *status); @@ -5051,33 +5061,33 @@ moq_option_duration moq_hang_catalog_AudioConfig_warmup_get(const moq_hang_catal void moq_hang_catalog_AudioConfig_warmup_set(moq_hang_catalog_AudioConfig *self, moq_option_duration value, moq_status *status); moq_option_duration moq_hang_catalog_AudioConfig_delay_get(const moq_hang_catalog_AudioConfig *self, moq_status *status); void moq_hang_catalog_AudioConfig_delay_set(moq_hang_catalog_AudioConfig *self, moq_option_duration value, moq_status *status); -moq_hang_catalog_AudioConfig *moq_hang_catalog_AudioConfig_new(moq_hang_catalog_AudioCodec codec, uint32_t sample_rate, uint32_t channel_count); +MOQ_MUST_USE moq_hang_catalog_AudioConfig *moq_hang_catalog_AudioConfig_new(moq_hang_catalog_AudioCodec codec, uint32_t sample_rate, uint32_t channel_count); bool moq_hang_catalog_AudioConfig_same_identity(const moq_hang_catalog_AudioConfig *self, const moq_hang_catalog_AudioConfig *other, moq_status *status); void moq_hang_catalog_Binary_free(moq_hang_catalog_Binary *self); void moq_hang_catalog_Binary_drop(moq_hang_catalog_Binary *self, moq_status *status); -moq_hang_catalog_Binary *moq_hang_catalog_Binary_clone(const moq_hang_catalog_Binary *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Binary *moq_hang_catalog_Binary_clone(const moq_hang_catalog_Binary *self, moq_status *status); bool moq_hang_catalog_Binary_eq(const moq_hang_catalog_Binary *a, const moq_hang_catalog_Binary *b, moq_status *status); -moq_buf moq_hang_catalog_Binary_debug(const moq_hang_catalog_Binary *self, moq_status *status); -moq_hang_catalog_Binary *moq_hang_catalog_Binary_default(void); -moq_vec_tuple_string_hang_catalog_BinaryConfig moq_hang_catalog_Binary_tracks_get(const moq_hang_catalog_Binary *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_Binary_debug(const moq_hang_catalog_Binary *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Binary *moq_hang_catalog_Binary_default(void); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_BinaryConfig moq_hang_catalog_Binary_tracks_get(const moq_hang_catalog_Binary *self, moq_status *status); void moq_hang_catalog_Binary_tracks_set(moq_hang_catalog_Binary *self, moq_vec_tuple_string_hang_catalog_BinaryConfig value, moq_status *status); -bool moq_hang_catalog_Binary_insert(moq_hang_catalog_Binary *self, moq_buf name, moq_hang_catalog_BinaryConfig *config, moq_hang_Error **err, moq_status *status); -moq_hang_catalog_BinaryConfig *moq_hang_catalog_Binary_remove(moq_hang_catalog_Binary *self, moq_buf name, moq_status *status); +MOQ_MUST_USE bool moq_hang_catalog_Binary_insert(moq_hang_catalog_Binary *self, moq_buf name, moq_hang_catalog_BinaryConfig *config, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_BinaryConfig *moq_hang_catalog_Binary_remove(moq_hang_catalog_Binary *self, moq_buf name, moq_status *status); bool moq_hang_catalog_Binary_is_empty(const moq_hang_catalog_Binary *self, moq_status *status); void moq_hang_catalog_BinaryConfig_free(moq_hang_catalog_BinaryConfig *self); void moq_hang_catalog_BinaryConfig_drop(moq_hang_catalog_BinaryConfig *self, moq_status *status); -moq_hang_catalog_BinaryConfig *moq_hang_catalog_BinaryConfig_clone(const moq_hang_catalog_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_BinaryConfig *moq_hang_catalog_BinaryConfig_clone(const moq_hang_catalog_BinaryConfig *self, moq_status *status); bool moq_hang_catalog_BinaryConfig_eq(const moq_hang_catalog_BinaryConfig *a, const moq_hang_catalog_BinaryConfig *b, moq_status *status); -moq_buf moq_hang_catalog_BinaryConfig_debug(const moq_hang_catalog_BinaryConfig *self, moq_status *status); -moq_path_Relative *moq_hang_catalog_BinaryConfig_broadcast_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_BinaryConfig_debug(const moq_hang_catalog_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_hang_catalog_BinaryConfig_broadcast_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); void moq_hang_catalog_BinaryConfig_broadcast_set(moq_hang_catalog_BinaryConfig *self, moq_path_Relative *value, moq_status *status); -moq_buf moq_hang_catalog_BinaryConfig_track_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_BinaryConfig_track_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); void moq_hang_catalog_BinaryConfig_track_set(moq_hang_catalog_BinaryConfig *self, moq_buf value, moq_status *status); -moq_Instance *moq_hang_catalog_BinaryConfig_instance_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_hang_catalog_BinaryConfig_instance_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); void moq_hang_catalog_BinaryConfig_instance_set(moq_hang_catalog_BinaryConfig *self, moq_Instance *value, moq_status *status); -moq_hang_catalog_Mode moq_hang_catalog_BinaryConfig_mode_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Mode moq_hang_catalog_BinaryConfig_mode_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); void moq_hang_catalog_BinaryConfig_mode_set(moq_hang_catalog_BinaryConfig *self, moq_hang_catalog_Mode value, moq_status *status); -moq_buf moq_hang_catalog_BinaryConfig_mime_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_BinaryConfig_mime_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); void moq_hang_catalog_BinaryConfig_mime_set(moq_hang_catalog_BinaryConfig *self, moq_buf value, moq_status *status); moq_option_u64 moq_hang_catalog_BinaryConfig_bitrate_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); void moq_hang_catalog_BinaryConfig_bitrate_set(moq_hang_catalog_BinaryConfig *self, moq_option_u64 value, moq_status *status); @@ -5085,58 +5095,58 @@ moq_option_duration moq_hang_catalog_BinaryConfig_jitter_get(const moq_hang_cata void moq_hang_catalog_BinaryConfig_jitter_set(moq_hang_catalog_BinaryConfig *self, moq_option_duration value, moq_status *status); moq_option_duration moq_hang_catalog_BinaryConfig_delay_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); void moq_hang_catalog_BinaryConfig_delay_set(moq_hang_catalog_BinaryConfig *self, moq_option_duration value, moq_status *status); -moq_vec_tuple_string_Json moq_hang_catalog_BinaryConfig_extra_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_Json moq_hang_catalog_BinaryConfig_extra_get(const moq_hang_catalog_BinaryConfig *self, moq_status *status); void moq_hang_catalog_BinaryConfig_extra_set(moq_hang_catalog_BinaryConfig *self, moq_vec_tuple_string_Json value, moq_status *status); -moq_hang_catalog_BinaryConfig *moq_hang_catalog_BinaryConfig_new(moq_hang_catalog_Mode mode); +MOQ_MUST_USE moq_hang_catalog_BinaryConfig *moq_hang_catalog_BinaryConfig_new(moq_hang_catalog_Mode mode); void moq_hang_catalog_Container_free(moq_hang_catalog_Container *self); void moq_hang_catalog_Container_drop(moq_hang_catalog_Container *self, moq_status *status); -moq_hang_catalog_Container *moq_hang_catalog_Container_clone(const moq_hang_catalog_Container *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Container *moq_hang_catalog_Container_clone(const moq_hang_catalog_Container *self, moq_status *status); bool moq_hang_catalog_Container_eq(const moq_hang_catalog_Container *a, const moq_hang_catalog_Container *b, moq_status *status); -moq_buf moq_hang_catalog_Container_debug(const moq_hang_catalog_Container *self, moq_status *status); -moq_hang_catalog_Container *moq_hang_catalog_Container_default(void); +MOQ_MUST_USE moq_buf moq_hang_catalog_Container_debug(const moq_hang_catalog_Container *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Container *moq_hang_catalog_Container_default(void); void moq_hang_catalog_Echo_free(moq_hang_catalog_Echo *self); void moq_hang_catalog_Echo_drop(moq_hang_catalog_Echo *self, moq_status *status); -moq_hang_catalog_Echo *moq_hang_catalog_Echo_clone(const moq_hang_catalog_Echo *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Echo *moq_hang_catalog_Echo_clone(const moq_hang_catalog_Echo *self, moq_status *status); bool moq_hang_catalog_Echo_eq(const moq_hang_catalog_Echo *a, const moq_hang_catalog_Echo *b, moq_status *status); -moq_buf moq_hang_catalog_Echo_debug(const moq_hang_catalog_Echo *self, moq_status *status); -moq_path_Relative *moq_hang_catalog_Echo_path_get(const moq_hang_catalog_Echo *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_Echo_debug(const moq_hang_catalog_Echo *self, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_hang_catalog_Echo_path_get(const moq_hang_catalog_Echo *self, moq_status *status); void moq_hang_catalog_Echo_path_set(moq_hang_catalog_Echo *self, moq_path_Relative *value, moq_status *status); -moq_hang_catalog_Echo *moq_hang_catalog_Echo_new(moq_path_Relative *path, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Echo *moq_hang_catalog_Echo_new(moq_path_Relative *path, moq_status *status); void moq_hang_catalog_Include_free(moq_hang_catalog_Include *self); void moq_hang_catalog_Include_drop(moq_hang_catalog_Include *self, moq_status *status); -moq_hang_catalog_Include *moq_hang_catalog_Include_clone(const moq_hang_catalog_Include *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Include *moq_hang_catalog_Include_clone(const moq_hang_catalog_Include *self, moq_status *status); bool moq_hang_catalog_Include_eq(const moq_hang_catalog_Include *a, const moq_hang_catalog_Include *b, moq_status *status); -moq_buf moq_hang_catalog_Include_debug(const moq_hang_catalog_Include *self, moq_status *status); -moq_path_Relative *moq_hang_catalog_Include_broadcast_get(const moq_hang_catalog_Include *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_Include_debug(const moq_hang_catalog_Include *self, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_hang_catalog_Include_broadcast_get(const moq_hang_catalog_Include *self, moq_status *status); void moq_hang_catalog_Include_broadcast_set(moq_hang_catalog_Include *self, moq_path_Relative *value, moq_status *status); -moq_Instance *moq_hang_catalog_Include_instance_get(const moq_hang_catalog_Include *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_hang_catalog_Include_instance_get(const moq_hang_catalog_Include *self, moq_status *status); void moq_hang_catalog_Include_instance_set(moq_hang_catalog_Include *self, moq_Instance *value, moq_status *status); -moq_hang_catalog_Include *moq_hang_catalog_Include_new(moq_path_Relative *broadcast, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Include *moq_hang_catalog_Include_new(moq_path_Relative *broadcast, moq_status *status); void moq_hang_catalog_Json_free(moq_hang_catalog_Json *self); void moq_hang_catalog_Json_drop(moq_hang_catalog_Json *self, moq_status *status); -moq_hang_catalog_Json *moq_hang_catalog_Json_clone(const moq_hang_catalog_Json *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Json *moq_hang_catalog_Json_clone(const moq_hang_catalog_Json *self, moq_status *status); bool moq_hang_catalog_Json_eq(const moq_hang_catalog_Json *a, const moq_hang_catalog_Json *b, moq_status *status); -moq_buf moq_hang_catalog_Json_debug(const moq_hang_catalog_Json *self, moq_status *status); -moq_hang_catalog_Json *moq_hang_catalog_Json_default(void); -moq_vec_tuple_string_hang_catalog_JsonConfig moq_hang_catalog_Json_tracks_get(const moq_hang_catalog_Json *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_Json_debug(const moq_hang_catalog_Json *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Json *moq_hang_catalog_Json_default(void); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_JsonConfig moq_hang_catalog_Json_tracks_get(const moq_hang_catalog_Json *self, moq_status *status); void moq_hang_catalog_Json_tracks_set(moq_hang_catalog_Json *self, moq_vec_tuple_string_hang_catalog_JsonConfig value, moq_status *status); -bool moq_hang_catalog_Json_insert(moq_hang_catalog_Json *self, moq_buf name, moq_hang_catalog_JsonConfig *config, moq_hang_Error **err, moq_status *status); -moq_hang_catalog_JsonConfig *moq_hang_catalog_Json_remove(moq_hang_catalog_Json *self, moq_buf name, moq_status *status); +MOQ_MUST_USE bool moq_hang_catalog_Json_insert(moq_hang_catalog_Json *self, moq_buf name, moq_hang_catalog_JsonConfig *config, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_JsonConfig *moq_hang_catalog_Json_remove(moq_hang_catalog_Json *self, moq_buf name, moq_status *status); bool moq_hang_catalog_Json_is_empty(const moq_hang_catalog_Json *self, moq_status *status); void moq_hang_catalog_JsonConfig_free(moq_hang_catalog_JsonConfig *self); void moq_hang_catalog_JsonConfig_drop(moq_hang_catalog_JsonConfig *self, moq_status *status); -moq_hang_catalog_JsonConfig *moq_hang_catalog_JsonConfig_clone(const moq_hang_catalog_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_JsonConfig *moq_hang_catalog_JsonConfig_clone(const moq_hang_catalog_JsonConfig *self, moq_status *status); bool moq_hang_catalog_JsonConfig_eq(const moq_hang_catalog_JsonConfig *a, const moq_hang_catalog_JsonConfig *b, moq_status *status); -moq_buf moq_hang_catalog_JsonConfig_debug(const moq_hang_catalog_JsonConfig *self, moq_status *status); -moq_path_Relative *moq_hang_catalog_JsonConfig_broadcast_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_JsonConfig_debug(const moq_hang_catalog_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_hang_catalog_JsonConfig_broadcast_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); void moq_hang_catalog_JsonConfig_broadcast_set(moq_hang_catalog_JsonConfig *self, moq_path_Relative *value, moq_status *status); -moq_buf moq_hang_catalog_JsonConfig_track_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_JsonConfig_track_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); void moq_hang_catalog_JsonConfig_track_set(moq_hang_catalog_JsonConfig *self, moq_buf value, moq_status *status); -moq_Instance *moq_hang_catalog_JsonConfig_instance_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_hang_catalog_JsonConfig_instance_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); void moq_hang_catalog_JsonConfig_instance_set(moq_hang_catalog_JsonConfig *self, moq_Instance *value, moq_status *status); -moq_hang_catalog_Mode moq_hang_catalog_JsonConfig_mode_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Mode moq_hang_catalog_JsonConfig_mode_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); void moq_hang_catalog_JsonConfig_mode_set(moq_hang_catalog_JsonConfig *self, moq_hang_catalog_Mode value, moq_status *status); -moq_buf moq_hang_catalog_JsonConfig_schema_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_JsonConfig_schema_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); void moq_hang_catalog_JsonConfig_schema_set(moq_hang_catalog_JsonConfig *self, moq_buf value, moq_status *status); moq_option_u64 moq_hang_catalog_JsonConfig_bitrate_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); void moq_hang_catalog_JsonConfig_bitrate_set(moq_hang_catalog_JsonConfig *self, moq_option_u64 value, moq_status *status); @@ -5144,60 +5154,60 @@ moq_option_duration moq_hang_catalog_JsonConfig_jitter_get(const moq_hang_catalo void moq_hang_catalog_JsonConfig_jitter_set(moq_hang_catalog_JsonConfig *self, moq_option_duration value, moq_status *status); moq_option_duration moq_hang_catalog_JsonConfig_delay_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); void moq_hang_catalog_JsonConfig_delay_set(moq_hang_catalog_JsonConfig *self, moq_option_duration value, moq_status *status); -moq_vec_tuple_string_Json moq_hang_catalog_JsonConfig_extra_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_Json moq_hang_catalog_JsonConfig_extra_get(const moq_hang_catalog_JsonConfig *self, moq_status *status); void moq_hang_catalog_JsonConfig_extra_set(moq_hang_catalog_JsonConfig *self, moq_vec_tuple_string_Json value, moq_status *status); -moq_hang_catalog_JsonConfig *moq_hang_catalog_JsonConfig_new(moq_hang_catalog_Mode mode); +MOQ_MUST_USE moq_hang_catalog_JsonConfig *moq_hang_catalog_JsonConfig_new(moq_hang_catalog_Mode mode); void moq_hang_catalog_Stats_free(moq_hang_catalog_Stats *self); void moq_hang_catalog_Stats_drop(moq_hang_catalog_Stats *self, moq_status *status); -moq_hang_catalog_Stats *moq_hang_catalog_Stats_clone(const moq_hang_catalog_Stats *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Stats *moq_hang_catalog_Stats_clone(const moq_hang_catalog_Stats *self, moq_status *status); bool moq_hang_catalog_Stats_eq(const moq_hang_catalog_Stats *a, const moq_hang_catalog_Stats *b, moq_status *status); -moq_buf moq_hang_catalog_Stats_debug(const moq_hang_catalog_Stats *self, moq_status *status); -moq_buf moq_hang_catalog_Stats_track_get(const moq_hang_catalog_Stats *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_Stats_debug(const moq_hang_catalog_Stats *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_Stats_track_get(const moq_hang_catalog_Stats *self, moq_status *status); void moq_hang_catalog_Stats_track_set(moq_hang_catalog_Stats *self, moq_buf value, moq_status *status); -moq_hang_catalog_Stats *moq_hang_catalog_Stats_new(moq_buf track); +MOQ_MUST_USE moq_hang_catalog_Stats *moq_hang_catalog_Stats_new(moq_buf track); void moq_hang_catalog_Text_free(moq_hang_catalog_Text *self); void moq_hang_catalog_Text_drop(moq_hang_catalog_Text *self, moq_status *status); -moq_hang_catalog_Text *moq_hang_catalog_Text_clone(const moq_hang_catalog_Text *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Text *moq_hang_catalog_Text_clone(const moq_hang_catalog_Text *self, moq_status *status); bool moq_hang_catalog_Text_eq(const moq_hang_catalog_Text *a, const moq_hang_catalog_Text *b, moq_status *status); -moq_buf moq_hang_catalog_Text_debug(const moq_hang_catalog_Text *self, moq_status *status); -moq_hang_catalog_Text *moq_hang_catalog_Text_default(void); -moq_vec_tuple_string_hang_catalog_TextConfig moq_hang_catalog_Text_renditions_get(const moq_hang_catalog_Text *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_Text_debug(const moq_hang_catalog_Text *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Text *moq_hang_catalog_Text_default(void); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_TextConfig moq_hang_catalog_Text_renditions_get(const moq_hang_catalog_Text *self, moq_status *status); void moq_hang_catalog_Text_renditions_set(moq_hang_catalog_Text *self, moq_vec_tuple_string_hang_catalog_TextConfig value, moq_status *status); -bool moq_hang_catalog_Text_insert(moq_hang_catalog_Text *self, moq_buf name, moq_hang_catalog_TextConfig *config, moq_hang_Error **err, moq_status *status); -moq_hang_catalog_TextConfig *moq_hang_catalog_Text_remove(moq_hang_catalog_Text *self, moq_buf name, moq_status *status); +MOQ_MUST_USE bool moq_hang_catalog_Text_insert(moq_hang_catalog_Text *self, moq_buf name, moq_hang_catalog_TextConfig *config, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_TextConfig *moq_hang_catalog_Text_remove(moq_hang_catalog_Text *self, moq_buf name, moq_status *status); bool moq_hang_catalog_Text_is_empty(const moq_hang_catalog_Text *self, moq_status *status); void moq_hang_catalog_TextConfig_free(moq_hang_catalog_TextConfig *self); void moq_hang_catalog_TextConfig_drop(moq_hang_catalog_TextConfig *self, moq_status *status); -moq_hang_catalog_TextConfig *moq_hang_catalog_TextConfig_clone(const moq_hang_catalog_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_TextConfig *moq_hang_catalog_TextConfig_clone(const moq_hang_catalog_TextConfig *self, moq_status *status); bool moq_hang_catalog_TextConfig_eq(const moq_hang_catalog_TextConfig *a, const moq_hang_catalog_TextConfig *b, moq_status *status); -moq_buf moq_hang_catalog_TextConfig_debug(const moq_hang_catalog_TextConfig *self, moq_status *status); -moq_path_Relative *moq_hang_catalog_TextConfig_broadcast_get(const moq_hang_catalog_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_TextConfig_debug(const moq_hang_catalog_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_hang_catalog_TextConfig_broadcast_get(const moq_hang_catalog_TextConfig *self, moq_status *status); void moq_hang_catalog_TextConfig_broadcast_set(moq_hang_catalog_TextConfig *self, moq_path_Relative *value, moq_status *status); -moq_buf moq_hang_catalog_TextConfig_track_get(const moq_hang_catalog_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_TextConfig_track_get(const moq_hang_catalog_TextConfig *self, moq_status *status); void moq_hang_catalog_TextConfig_track_set(moq_hang_catalog_TextConfig *self, moq_buf value, moq_status *status); -moq_Instance *moq_hang_catalog_TextConfig_instance_get(const moq_hang_catalog_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_hang_catalog_TextConfig_instance_get(const moq_hang_catalog_TextConfig *self, moq_status *status); void moq_hang_catalog_TextConfig_instance_set(moq_hang_catalog_TextConfig *self, moq_Instance *value, moq_status *status); -moq_hang_catalog_TextFormat moq_hang_catalog_TextConfig_format_get(const moq_hang_catalog_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_TextFormat moq_hang_catalog_TextConfig_format_get(const moq_hang_catalog_TextConfig *self, moq_status *status); void moq_hang_catalog_TextConfig_format_set(moq_hang_catalog_TextConfig *self, moq_hang_catalog_TextFormat value, moq_status *status); -moq_hang_catalog_TextRole moq_hang_catalog_TextConfig_role_get(const moq_hang_catalog_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_TextRole moq_hang_catalog_TextConfig_role_get(const moq_hang_catalog_TextConfig *self, moq_status *status); void moq_hang_catalog_TextConfig_role_set(moq_hang_catalog_TextConfig *self, moq_hang_catalog_TextRole value, moq_status *status); -moq_buf moq_hang_catalog_TextConfig_lang_get(const moq_hang_catalog_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_TextConfig_lang_get(const moq_hang_catalog_TextConfig *self, moq_status *status); void moq_hang_catalog_TextConfig_lang_set(moq_hang_catalog_TextConfig *self, moq_buf value, moq_status *status); -moq_buf moq_hang_catalog_TextConfig_label_get(const moq_hang_catalog_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_TextConfig_label_get(const moq_hang_catalog_TextConfig *self, moq_status *status); void moq_hang_catalog_TextConfig_label_set(moq_hang_catalog_TextConfig *self, moq_buf value, moq_status *status); -moq_hang_catalog_Container *moq_hang_catalog_TextConfig_container_get(const moq_hang_catalog_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Container *moq_hang_catalog_TextConfig_container_get(const moq_hang_catalog_TextConfig *self, moq_status *status); void moq_hang_catalog_TextConfig_container_set(moq_hang_catalog_TextConfig *self, moq_hang_catalog_Container *value, moq_status *status); moq_option_duration moq_hang_catalog_TextConfig_jitter_get(const moq_hang_catalog_TextConfig *self, moq_status *status); void moq_hang_catalog_TextConfig_jitter_set(moq_hang_catalog_TextConfig *self, moq_option_duration value, moq_status *status); moq_option_duration moq_hang_catalog_TextConfig_delay_get(const moq_hang_catalog_TextConfig *self, moq_status *status); void moq_hang_catalog_TextConfig_delay_set(moq_hang_catalog_TextConfig *self, moq_option_duration value, moq_status *status); -moq_hang_catalog_TextConfig *moq_hang_catalog_TextConfig_new(moq_hang_catalog_TextFormat format); +MOQ_MUST_USE moq_hang_catalog_TextConfig *moq_hang_catalog_TextConfig_new(moq_hang_catalog_TextFormat format); void moq_hang_catalog_Timeline_free(moq_hang_catalog_Timeline *self); void moq_hang_catalog_Timeline_drop(moq_hang_catalog_Timeline *self, moq_status *status); -moq_hang_catalog_Timeline *moq_hang_catalog_Timeline_clone(const moq_hang_catalog_Timeline *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Timeline *moq_hang_catalog_Timeline_clone(const moq_hang_catalog_Timeline *self, moq_status *status); bool moq_hang_catalog_Timeline_eq(const moq_hang_catalog_Timeline *a, const moq_hang_catalog_Timeline *b, moq_status *status); -moq_buf moq_hang_catalog_Timeline_debug(const moq_hang_catalog_Timeline *self, moq_status *status); -moq_hang_catalog_Timeline *moq_hang_catalog_Timeline_default(void); +MOQ_MUST_USE moq_buf moq_hang_catalog_Timeline_debug(const moq_hang_catalog_Timeline *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Timeline *moq_hang_catalog_Timeline_default(void); moq_option_hang_catalog_Clock moq_hang_catalog_Timeline_clock_get(const moq_hang_catalog_Timeline *self, moq_status *status); void moq_hang_catalog_Timeline_clock_set(moq_hang_catalog_Timeline *self, moq_option_hang_catalog_Clock value, moq_status *status); moq_option_duration moq_hang_catalog_Timeline_interval_get(const moq_hang_catalog_Timeline *self, moq_status *status); @@ -5205,10 +5215,10 @@ void moq_hang_catalog_Timeline_interval_set(moq_hang_catalog_Timeline *self, moq bool moq_hang_catalog_Timeline_is_empty(const moq_hang_catalog_Timeline *self, moq_status *status); void moq_hang_catalog_Color_free(moq_hang_catalog_Color *self); void moq_hang_catalog_Color_drop(moq_hang_catalog_Color *self, moq_status *status); -moq_hang_catalog_Color *moq_hang_catalog_Color_clone(const moq_hang_catalog_Color *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Color *moq_hang_catalog_Color_clone(const moq_hang_catalog_Color *self, moq_status *status); bool moq_hang_catalog_Color_eq(const moq_hang_catalog_Color *a, const moq_hang_catalog_Color *b, moq_status *status); -moq_buf moq_hang_catalog_Color_debug(const moq_hang_catalog_Color *self, moq_status *status); -moq_hang_catalog_Color *moq_hang_catalog_Color_default(void); +MOQ_MUST_USE moq_buf moq_hang_catalog_Color_debug(const moq_hang_catalog_Color *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Color *moq_hang_catalog_Color_default(void); moq_option_u8 moq_hang_catalog_Color_primaries_get(const moq_hang_catalog_Color *self, moq_status *status); void moq_hang_catalog_Color_primaries_set(moq_hang_catalog_Color *self, moq_option_u8 value, moq_status *status); moq_option_u8 moq_hang_catalog_Color_transfer_get(const moq_hang_catalog_Color *self, moq_status *status); @@ -5223,17 +5233,17 @@ moq_option_hang_catalog_ContentLight moq_hang_catalog_Color_content_light_get(co void moq_hang_catalog_Color_content_light_set(moq_hang_catalog_Color *self, moq_option_hang_catalog_ContentLight value, moq_status *status); void moq_hang_catalog_Projection_free(moq_hang_catalog_Projection *self); void moq_hang_catalog_Projection_drop(moq_hang_catalog_Projection *self, moq_status *status); -moq_hang_catalog_Projection *moq_hang_catalog_Projection_clone(const moq_hang_catalog_Projection *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Projection *moq_hang_catalog_Projection_clone(const moq_hang_catalog_Projection *self, moq_status *status); bool moq_hang_catalog_Projection_eq(const moq_hang_catalog_Projection *a, const moq_hang_catalog_Projection *b, moq_status *status); -moq_buf moq_hang_catalog_Projection_debug(const moq_hang_catalog_Projection *self, moq_status *status); -moq_hang_catalog_Projection *moq_hang_catalog_Projection_default(void); +MOQ_MUST_USE moq_buf moq_hang_catalog_Projection_debug(const moq_hang_catalog_Projection *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Projection *moq_hang_catalog_Projection_default(void); void moq_hang_catalog_Video_free(moq_hang_catalog_Video *self); void moq_hang_catalog_Video_drop(moq_hang_catalog_Video *self, moq_status *status); -moq_hang_catalog_Video *moq_hang_catalog_Video_clone(const moq_hang_catalog_Video *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Video *moq_hang_catalog_Video_clone(const moq_hang_catalog_Video *self, moq_status *status); bool moq_hang_catalog_Video_eq(const moq_hang_catalog_Video *a, const moq_hang_catalog_Video *b, moq_status *status); -moq_buf moq_hang_catalog_Video_debug(const moq_hang_catalog_Video *self, moq_status *status); -moq_hang_catalog_Video *moq_hang_catalog_Video_default(void); -moq_vec_tuple_string_hang_catalog_VideoConfig moq_hang_catalog_Video_renditions_get(const moq_hang_catalog_Video *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_Video_debug(const moq_hang_catalog_Video *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Video *moq_hang_catalog_Video_default(void); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_VideoConfig moq_hang_catalog_Video_renditions_get(const moq_hang_catalog_Video *self, moq_status *status); void moq_hang_catalog_Video_renditions_set(moq_hang_catalog_Video *self, moq_vec_tuple_string_hang_catalog_VideoConfig value, moq_status *status); moq_option_hang_catalog_Display moq_hang_catalog_Video_display_get(const moq_hang_catalog_Video *self, moq_status *status); void moq_hang_catalog_Video_display_set(moq_hang_catalog_Video *self, moq_option_hang_catalog_Display value, moq_status *status); @@ -5241,18 +5251,18 @@ moq_option_f64 moq_hang_catalog_Video_rotation_get(const moq_hang_catalog_Video void moq_hang_catalog_Video_rotation_set(moq_hang_catalog_Video *self, moq_option_f64 value, moq_status *status); moq_option_bool moq_hang_catalog_Video_flip_get(const moq_hang_catalog_Video *self, moq_status *status); void moq_hang_catalog_Video_flip_set(moq_hang_catalog_Video *self, moq_option_bool value, moq_status *status); -bool moq_hang_catalog_Video_insert(moq_hang_catalog_Video *self, moq_buf name, moq_hang_catalog_VideoConfig *config, moq_hang_Error **err, moq_status *status); -moq_hang_catalog_VideoConfig *moq_hang_catalog_Video_remove(moq_hang_catalog_Video *self, moq_buf name, moq_status *status); +MOQ_MUST_USE bool moq_hang_catalog_Video_insert(moq_hang_catalog_Video *self, moq_buf name, moq_hang_catalog_VideoConfig *config, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_VideoConfig *moq_hang_catalog_Video_remove(moq_hang_catalog_Video *self, moq_buf name, moq_status *status); bool moq_hang_catalog_Video_is_empty(const moq_hang_catalog_Video *self, moq_status *status); -moq_vec_tuple_string_hang_catalog_VideoConfig moq_hang_catalog_Video_enabled(const moq_hang_catalog_Video *self, moq_status *status); -moq_vec_tuple_string_hang_catalog_VideoConfig moq_hang_catalog_Video_ranked(const moq_hang_catalog_Video *self, moq_status *status); -bool moq_hang_catalog_Video_set_properties(moq_hang_catalog_Video *self, moq_hang_catalog_VideoProperties *properties, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_VideoConfig moq_hang_catalog_Video_enabled(const moq_hang_catalog_Video *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_VideoConfig moq_hang_catalog_Video_ranked(const moq_hang_catalog_Video *self, moq_status *status); +MOQ_MUST_USE bool moq_hang_catalog_Video_set_properties(moq_hang_catalog_Video *self, moq_hang_catalog_VideoProperties *properties, moq_hang_Error **err, moq_status *status); void moq_hang_catalog_VideoProperties_free(moq_hang_catalog_VideoProperties *self); void moq_hang_catalog_VideoProperties_drop(moq_hang_catalog_VideoProperties *self, moq_status *status); -moq_hang_catalog_VideoProperties *moq_hang_catalog_VideoProperties_clone(const moq_hang_catalog_VideoProperties *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_VideoProperties *moq_hang_catalog_VideoProperties_clone(const moq_hang_catalog_VideoProperties *self, moq_status *status); bool moq_hang_catalog_VideoProperties_eq(const moq_hang_catalog_VideoProperties *a, const moq_hang_catalog_VideoProperties *b, moq_status *status); -moq_buf moq_hang_catalog_VideoProperties_debug(const moq_hang_catalog_VideoProperties *self, moq_status *status); -moq_hang_catalog_VideoProperties *moq_hang_catalog_VideoProperties_default(void); +MOQ_MUST_USE moq_buf moq_hang_catalog_VideoProperties_debug(const moq_hang_catalog_VideoProperties *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_VideoProperties *moq_hang_catalog_VideoProperties_default(void); moq_option_hang_catalog_Display moq_hang_catalog_VideoProperties_display_get(const moq_hang_catalog_VideoProperties *self, moq_status *status); void moq_hang_catalog_VideoProperties_display_set(moq_hang_catalog_VideoProperties *self, moq_option_hang_catalog_Display value, moq_status *status); moq_option_f64 moq_hang_catalog_VideoProperties_rotation_get(const moq_hang_catalog_VideoProperties *self, moq_status *status); @@ -5261,20 +5271,20 @@ moq_option_bool moq_hang_catalog_VideoProperties_flip_get(const moq_hang_catalog void moq_hang_catalog_VideoProperties_flip_set(moq_hang_catalog_VideoProperties *self, moq_option_bool value, moq_status *status); void moq_hang_catalog_VideoConfig_free(moq_hang_catalog_VideoConfig *self); void moq_hang_catalog_VideoConfig_drop(moq_hang_catalog_VideoConfig *self, moq_status *status); -moq_hang_catalog_VideoConfig *moq_hang_catalog_VideoConfig_clone(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_VideoConfig *moq_hang_catalog_VideoConfig_clone(const moq_hang_catalog_VideoConfig *self, moq_status *status); bool moq_hang_catalog_VideoConfig_eq(const moq_hang_catalog_VideoConfig *a, const moq_hang_catalog_VideoConfig *b, moq_status *status); -moq_buf moq_hang_catalog_VideoConfig_debug(const moq_hang_catalog_VideoConfig *self, moq_status *status); -moq_path_Relative *moq_hang_catalog_VideoConfig_broadcast_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_VideoConfig_debug(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_hang_catalog_VideoConfig_broadcast_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_broadcast_set(moq_hang_catalog_VideoConfig *self, moq_path_Relative *value, moq_status *status); -moq_buf moq_hang_catalog_VideoConfig_track_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_VideoConfig_track_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_track_set(moq_hang_catalog_VideoConfig *self, moq_buf value, moq_status *status); -moq_Instance *moq_hang_catalog_VideoConfig_instance_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_hang_catalog_VideoConfig_instance_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_instance_set(moq_hang_catalog_VideoConfig *self, moq_Instance *value, moq_status *status); -moq_buf moq_hang_catalog_VideoConfig_label_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_VideoConfig_label_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_label_set(moq_hang_catalog_VideoConfig *self, moq_buf value, moq_status *status); -moq_hang_catalog_VideoCodec moq_hang_catalog_VideoConfig_codec_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_VideoCodec moq_hang_catalog_VideoConfig_codec_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_codec_set(moq_hang_catalog_VideoConfig *self, moq_hang_catalog_VideoCodec value, moq_status *status); -moq_buf moq_hang_catalog_VideoConfig_description_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_hang_catalog_VideoConfig_description_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_description_set(moq_hang_catalog_VideoConfig *self, moq_buf value, moq_status *status); moq_option_u32 moq_hang_catalog_VideoConfig_coded_width_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_coded_width_set(moq_hang_catalog_VideoConfig *self, moq_option_u32 value, moq_status *status); @@ -5284,11 +5294,11 @@ moq_option_u32 moq_hang_catalog_VideoConfig_display_aspect_width_get(const moq_h void moq_hang_catalog_VideoConfig_display_aspect_width_set(moq_hang_catalog_VideoConfig *self, moq_option_u32 value, moq_status *status); moq_option_u32 moq_hang_catalog_VideoConfig_display_aspect_height_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_display_aspect_height_set(moq_hang_catalog_VideoConfig *self, moq_option_u32 value, moq_status *status); -moq_hang_catalog_Color *moq_hang_catalog_VideoConfig_color_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Color *moq_hang_catalog_VideoConfig_color_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_color_set(moq_hang_catalog_VideoConfig *self, moq_hang_catalog_Color *value, moq_status *status); -moq_hang_catalog_Projection *moq_hang_catalog_VideoConfig_projection_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Projection *moq_hang_catalog_VideoConfig_projection_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_projection_set(moq_hang_catalog_VideoConfig *self, moq_hang_catalog_Projection *value, moq_status *status); -moq_option_hang_catalog_Stereo moq_hang_catalog_VideoConfig_stereo_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_option_hang_catalog_Stereo moq_hang_catalog_VideoConfig_stereo_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_stereo_set(moq_hang_catalog_VideoConfig *self, moq_option_hang_catalog_Stereo value, moq_status *status); bool moq_hang_catalog_VideoConfig_interlaced_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_interlaced_set(moq_hang_catalog_VideoConfig *self, bool value, moq_status *status); @@ -5304,41 +5314,41 @@ moq_option_u8 moq_hang_catalog_VideoConfig_reorder_get(const moq_hang_catalog_Vi void moq_hang_catalog_VideoConfig_reorder_set(moq_hang_catalog_VideoConfig *self, moq_option_u8 value, moq_status *status); moq_option_bool moq_hang_catalog_VideoConfig_optimize_for_latency_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_optimize_for_latency_set(moq_hang_catalog_VideoConfig *self, moq_option_bool value, moq_status *status); -moq_hang_catalog_Container *moq_hang_catalog_VideoConfig_container_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Container *moq_hang_catalog_VideoConfig_container_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_container_set(moq_hang_catalog_VideoConfig *self, moq_hang_catalog_Container *value, moq_status *status); moq_option_duration moq_hang_catalog_VideoConfig_jitter_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_jitter_set(moq_hang_catalog_VideoConfig *self, moq_option_duration value, moq_status *status); moq_option_duration moq_hang_catalog_VideoConfig_delay_get(const moq_hang_catalog_VideoConfig *self, moq_status *status); void moq_hang_catalog_VideoConfig_delay_set(moq_hang_catalog_VideoConfig *self, moq_option_duration value, moq_status *status); -moq_hang_catalog_VideoConfig *moq_hang_catalog_VideoConfig_new(moq_hang_catalog_VideoCodec codec); +MOQ_MUST_USE moq_hang_catalog_VideoConfig *moq_hang_catalog_VideoConfig_new(moq_hang_catalog_VideoCodec codec); bool moq_hang_catalog_VideoConfig_same_identity(const moq_hang_catalog_VideoConfig *self, const moq_hang_catalog_VideoConfig *other, moq_status *status); void moq_mux_catalog_Consumer_free(moq_mux_catalog_Consumer *self); void moq_mux_catalog_Consumer_drop(moq_mux_catalog_Consumer *self, moq_status *status); typedef struct moq_mux_catalog_Consumer_new_future moq_mux_catalog_Consumer_new_future; -moq_mux_catalog_Consumer_new_future *moq_mux_catalog_Consumer_new(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_status *status); -moq_poll moq_mux_catalog_Consumer_new_start(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer **out, moq_mux_Error **err, moq_mux_catalog_Consumer_new_future **future, moq_status *status); -moq_poll moq_mux_catalog_Consumer_new_poll(moq_mux_catalog_Consumer_new_future *future, moq_waker waker, moq_mux_catalog_Consumer **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_Consumer_new_future *moq_mux_catalog_Consumer_new(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_Consumer_new_start(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer **out, moq_mux_Error **err, moq_mux_catalog_Consumer_new_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_Consumer_new_poll(moq_mux_catalog_Consumer_new_future *future, moq_waker waker, moq_mux_catalog_Consumer **out, moq_mux_Error **err); void moq_mux_catalog_Consumer_new_future_free(moq_mux_catalog_Consumer_new_future *future); void moq_mux_catalog_Consumer_Extra_free(moq_mux_catalog_Consumer_Extra *self); void moq_mux_catalog_Consumer_Extra_drop(moq_mux_catalog_Consumer_Extra *self, moq_status *status); typedef struct moq_mux_catalog_Consumer_Extra_new_future moq_mux_catalog_Consumer_Extra_new_future; -moq_mux_catalog_Consumer_Extra_new_future *moq_mux_catalog_Consumer_Extra_new(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_status *status); -moq_poll moq_mux_catalog_Consumer_Extra_new_start(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer_Extra **out, moq_mux_Error **err, moq_mux_catalog_Consumer_Extra_new_future **future, moq_status *status); -moq_poll moq_mux_catalog_Consumer_Extra_new_poll(moq_mux_catalog_Consumer_Extra_new_future *future, moq_waker waker, moq_mux_catalog_Consumer_Extra **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_Consumer_Extra_new_future *moq_mux_catalog_Consumer_Extra_new(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_Consumer_Extra_new_start(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer_Extra **out, moq_mux_Error **err, moq_mux_catalog_Consumer_Extra_new_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_Consumer_Extra_new_poll(moq_mux_catalog_Consumer_Extra_new_future *future, moq_waker waker, moq_mux_catalog_Consumer_Extra **out, moq_mux_Error **err); void moq_mux_catalog_Consumer_Extra_new_future_free(moq_mux_catalog_Consumer_Extra_new_future *future); void moq_mux_catalog_Consumer_Ext_free(moq_mux_catalog_Consumer_Ext *self); void moq_mux_catalog_Consumer_Ext_drop(moq_mux_catalog_Consumer_Ext *self, moq_status *status); typedef struct moq_mux_catalog_Consumer_Ext_new_future moq_mux_catalog_Consumer_Ext_new_future; -moq_mux_catalog_Consumer_Ext_new_future *moq_mux_catalog_Consumer_Ext_new(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_status *status); -moq_poll moq_mux_catalog_Consumer_Ext_new_start(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer_Ext **out, moq_mux_Error **err, moq_mux_catalog_Consumer_Ext_new_future **future, moq_status *status); -moq_poll moq_mux_catalog_Consumer_Ext_new_poll(moq_mux_catalog_Consumer_Ext_new_future *future, moq_waker waker, moq_mux_catalog_Consumer_Ext **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_Consumer_Ext_new_future *moq_mux_catalog_Consumer_Ext_new(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_Consumer_Ext_new_start(const moq_broadcast_Consumer *broadcast, moq_mux_catalog_CatalogFormat format, moq_mux_catalog_Consumer_Ext **out, moq_mux_Error **err, moq_mux_catalog_Consumer_Ext_new_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_Consumer_Ext_new_poll(moq_mux_catalog_Consumer_Ext_new_future *future, moq_waker waker, moq_mux_catalog_Consumer_Ext **out, moq_mux_Error **err); void moq_mux_catalog_Consumer_Ext_new_future_free(moq_mux_catalog_Consumer_Ext_new_future *future); void moq_mux_catalog_Estimate_free(moq_mux_catalog_Estimate *self); void moq_mux_catalog_Estimate_drop(moq_mux_catalog_Estimate *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_clone(const moq_mux_catalog_Estimate *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_clone(const moq_mux_catalog_Estimate *self, moq_status *status); bool moq_mux_catalog_Estimate_eq(const moq_mux_catalog_Estimate *a, const moq_mux_catalog_Estimate *b, moq_status *status); -moq_buf moq_mux_catalog_Estimate_debug(const moq_mux_catalog_Estimate *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_default(void); +MOQ_MUST_USE moq_buf moq_mux_catalog_Estimate_debug(const moq_mux_catalog_Estimate *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_default(void); moq_option_duration moq_mux_catalog_Estimate_jitter_get(const moq_mux_catalog_Estimate *self, moq_status *status); void moq_mux_catalog_Estimate_jitter_set(moq_mux_catalog_Estimate *self, moq_option_duration value, moq_status *status); moq_option_u64 moq_mux_catalog_Estimate_bitrate_get(const moq_mux_catalog_Estimate *self, moq_status *status); @@ -5347,435 +5357,435 @@ moq_option_duration moq_mux_catalog_Estimate_delay_get(const moq_mux_catalog_Est void moq_mux_catalog_Estimate_delay_set(moq_mux_catalog_Estimate *self, moq_option_duration value, moq_status *status); moq_option_f64 moq_mux_catalog_Estimate_framerate_get(const moq_mux_catalog_Estimate *self, moq_status *status); void moq_mux_catalog_Estimate_framerate_set(moq_mux_catalog_Estimate *self, moq_option_f64 value, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_with_jitter(moq_mux_catalog_Estimate *self, moq_option_duration jitter, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_with_bitrate(moq_mux_catalog_Estimate *self, moq_option_u64 bitrate, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_with_delay(moq_mux_catalog_Estimate *self, moq_option_duration delay, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_with_framerate(moq_mux_catalog_Estimate *self, moq_option_f64 framerate, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_with_jitter(moq_mux_catalog_Estimate *self, moq_option_duration jitter, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_with_bitrate(moq_mux_catalog_Estimate *self, moq_option_u64 bitrate, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_with_delay(moq_mux_catalog_Estimate *self, moq_option_duration delay, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_catalog_Estimate_with_framerate(moq_mux_catalog_Estimate *self, moq_option_f64 framerate, moq_status *status); void moq_mux_catalog_Config_free(moq_mux_catalog_Config *self); void moq_mux_catalog_Config_drop(moq_mux_catalog_Config *self, moq_status *status); -moq_mux_catalog_Config *moq_mux_catalog_Config_clone(const moq_mux_catalog_Config *self, moq_status *status); -moq_mux_catalog_Config *moq_mux_catalog_Config_default(void); -moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_with_catalog_Extra(moq_mux_catalog_Config *self, moq_hang_Catalog_Extra *catalog, moq_status *status); -moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_with_catalog_Ext(moq_mux_catalog_Config *self, moq_hang_Catalog_Ext *catalog, moq_status *status); -moq_mux_catalog_Config *moq_mux_catalog_Config_with_catalog_unit(moq_mux_catalog_Config *self, moq_hang_Catalog *catalog, moq_status *status); -moq_mux_catalog_Config *moq_mux_catalog_Config_with_clock(moq_mux_catalog_Config *self, moq_mux_Clock *clock, moq_status *status); -moq_mux_catalog_Config *moq_mux_catalog_Config_with_max_age(moq_mux_catalog_Config *self, moq_option_duration max_age, moq_status *status); -moq_mux_catalog_Config *moq_mux_catalog_Config_with_bandwidth(moq_mux_catalog_Config *self, moq_bandwidth_Allocator *bandwidth, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config *moq_mux_catalog_Config_clone(const moq_mux_catalog_Config *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config *moq_mux_catalog_Config_default(void); +MOQ_MUST_USE moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_with_catalog_Extra(moq_mux_catalog_Config *self, moq_hang_Catalog_Extra *catalog, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_with_catalog_Ext(moq_mux_catalog_Config *self, moq_hang_Catalog_Ext *catalog, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config *moq_mux_catalog_Config_with_catalog_unit(moq_mux_catalog_Config *self, moq_hang_Catalog *catalog, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config *moq_mux_catalog_Config_with_clock(moq_mux_catalog_Config *self, moq_mux_Clock *clock, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config *moq_mux_catalog_Config_with_max_age(moq_mux_catalog_Config *self, moq_option_duration max_age, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config *moq_mux_catalog_Config_with_bandwidth(moq_mux_catalog_Config *self, moq_bandwidth_Allocator *bandwidth, moq_status *status); void moq_mux_catalog_Config_Extra_free(moq_mux_catalog_Config_Extra *self); void moq_mux_catalog_Config_Extra_drop(moq_mux_catalog_Config_Extra *self, moq_status *status); -moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Extra_clone(const moq_mux_catalog_Config_Extra *self, moq_status *status); -moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Extra_with_catalog_Extra(moq_mux_catalog_Config_Extra *self, moq_hang_Catalog_Extra *catalog, moq_status *status); -moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Extra_with_catalog_Ext(moq_mux_catalog_Config_Extra *self, moq_hang_Catalog_Ext *catalog, moq_status *status); -moq_mux_catalog_Config *moq_mux_catalog_Config_Extra_with_catalog_unit(moq_mux_catalog_Config_Extra *self, moq_hang_Catalog *catalog, moq_status *status); -moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Extra_with_clock(moq_mux_catalog_Config_Extra *self, moq_mux_Clock *clock, moq_status *status); -moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Extra_with_max_age(moq_mux_catalog_Config_Extra *self, moq_option_duration max_age, moq_status *status); -moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Extra_with_bandwidth(moq_mux_catalog_Config_Extra *self, moq_bandwidth_Allocator *bandwidth, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Extra_clone(const moq_mux_catalog_Config_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Extra_with_catalog_Extra(moq_mux_catalog_Config_Extra *self, moq_hang_Catalog_Extra *catalog, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Extra_with_catalog_Ext(moq_mux_catalog_Config_Extra *self, moq_hang_Catalog_Ext *catalog, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config *moq_mux_catalog_Config_Extra_with_catalog_unit(moq_mux_catalog_Config_Extra *self, moq_hang_Catalog *catalog, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Extra_with_clock(moq_mux_catalog_Config_Extra *self, moq_mux_Clock *clock, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Extra_with_max_age(moq_mux_catalog_Config_Extra *self, moq_option_duration max_age, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Extra_with_bandwidth(moq_mux_catalog_Config_Extra *self, moq_bandwidth_Allocator *bandwidth, moq_status *status); void moq_mux_catalog_Config_Ext_free(moq_mux_catalog_Config_Ext *self); void moq_mux_catalog_Config_Ext_drop(moq_mux_catalog_Config_Ext *self, moq_status *status); -moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Ext_clone(const moq_mux_catalog_Config_Ext *self, moq_status *status); -moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Ext_with_catalog_Extra(moq_mux_catalog_Config_Ext *self, moq_hang_Catalog_Extra *catalog, moq_status *status); -moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Ext_with_catalog_Ext(moq_mux_catalog_Config_Ext *self, moq_hang_Catalog_Ext *catalog, moq_status *status); -moq_mux_catalog_Config *moq_mux_catalog_Config_Ext_with_catalog_unit(moq_mux_catalog_Config_Ext *self, moq_hang_Catalog *catalog, moq_status *status); -moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Ext_with_clock(moq_mux_catalog_Config_Ext *self, moq_mux_Clock *clock, moq_status *status); -moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Ext_with_max_age(moq_mux_catalog_Config_Ext *self, moq_option_duration max_age, moq_status *status); -moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Ext_with_bandwidth(moq_mux_catalog_Config_Ext *self, moq_bandwidth_Allocator *bandwidth, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Ext_clone(const moq_mux_catalog_Config_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Extra *moq_mux_catalog_Config_Ext_with_catalog_Extra(moq_mux_catalog_Config_Ext *self, moq_hang_Catalog_Extra *catalog, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Ext_with_catalog_Ext(moq_mux_catalog_Config_Ext *self, moq_hang_Catalog_Ext *catalog, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config *moq_mux_catalog_Config_Ext_with_catalog_unit(moq_mux_catalog_Config_Ext *self, moq_hang_Catalog *catalog, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Ext_with_clock(moq_mux_catalog_Config_Ext *self, moq_mux_Clock *clock, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Ext_with_max_age(moq_mux_catalog_Config_Ext *self, moq_option_duration max_age, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Config_Ext *moq_mux_catalog_Config_Ext_with_bandwidth(moq_mux_catalog_Config_Ext *self, moq_bandwidth_Allocator *bandwidth, moq_status *status); void moq_mux_catalog_Guard_free(moq_mux_catalog_Guard *self); void moq_mux_catalog_Guard_drop(moq_mux_catalog_Guard *self, moq_status *status); -bool moq_mux_catalog_Guard_commit(moq_mux_catalog_Guard *self, moq_mux_Error **err, moq_status *status); -moq_hang_catalog_Video *moq_mux_catalog_Guard_video_get(const moq_mux_catalog_Guard *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_commit(moq_mux_catalog_Guard *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Video *moq_mux_catalog_Guard_video_get(const moq_mux_catalog_Guard *self, moq_status *status); void moq_mux_catalog_Guard_video_set(moq_mux_catalog_Guard *self, moq_hang_catalog_Video *value, moq_status *status); -moq_hang_catalog_Audio *moq_mux_catalog_Guard_audio_get(const moq_mux_catalog_Guard *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Audio *moq_mux_catalog_Guard_audio_get(const moq_mux_catalog_Guard *self, moq_status *status); void moq_mux_catalog_Guard_audio_set(moq_mux_catalog_Guard *self, moq_hang_catalog_Audio *value, moq_status *status); -moq_hang_catalog_Timeline *moq_mux_catalog_Guard_sync_get(const moq_mux_catalog_Guard *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Timeline *moq_mux_catalog_Guard_sync_get(const moq_mux_catalog_Guard *self, moq_status *status); void moq_mux_catalog_Guard_sync_set(moq_mux_catalog_Guard *self, const moq_hang_catalog_Timeline *value, moq_status *status); -moq_hang_catalog_Text *moq_mux_catalog_Guard_text_get(const moq_mux_catalog_Guard *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Text *moq_mux_catalog_Guard_text_get(const moq_mux_catalog_Guard *self, moq_status *status); void moq_mux_catalog_Guard_text_set(moq_mux_catalog_Guard *self, moq_hang_catalog_Text *value, moq_status *status); -moq_hang_catalog_Json *moq_mux_catalog_Guard_json_get(const moq_mux_catalog_Guard *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Json *moq_mux_catalog_Guard_json_get(const moq_mux_catalog_Guard *self, moq_status *status); void moq_mux_catalog_Guard_json_set(moq_mux_catalog_Guard *self, moq_hang_catalog_Json *value, moq_status *status); -moq_hang_catalog_Binary *moq_mux_catalog_Guard_binary_get(const moq_mux_catalog_Guard *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Binary *moq_mux_catalog_Guard_binary_get(const moq_mux_catalog_Guard *self, moq_status *status); void moq_mux_catalog_Guard_binary_set(moq_mux_catalog_Guard *self, moq_hang_catalog_Binary *value, moq_status *status); -moq_hang_catalog_Stats *moq_mux_catalog_Guard_stats_get(const moq_mux_catalog_Guard *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Stats *moq_mux_catalog_Guard_stats_get(const moq_mux_catalog_Guard *self, moq_status *status); void moq_mux_catalog_Guard_stats_set(moq_mux_catalog_Guard *self, moq_hang_catalog_Stats *value, moq_status *status); -moq_hang_catalog_Echo *moq_mux_catalog_Guard_echo_get(const moq_mux_catalog_Guard *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Echo *moq_mux_catalog_Guard_echo_get(const moq_mux_catalog_Guard *self, moq_status *status); void moq_mux_catalog_Guard_echo_set(moq_mux_catalog_Guard *self, moq_hang_catalog_Echo *value, moq_status *status); -moq_vec_tuple_string_hang_catalog_Include moq_mux_catalog_Guard_include_get(const moq_mux_catalog_Guard *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_Include moq_mux_catalog_Guard_include_get(const moq_mux_catalog_Guard *self, moq_status *status); void moq_mux_catalog_Guard_include_set(moq_mux_catalog_Guard *self, moq_vec_tuple_string_hang_catalog_Include value, moq_status *status); -moq_hang_catalog_Skipped *moq_mux_catalog_Guard_skipped_get(const moq_mux_catalog_Guard *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Skipped *moq_mux_catalog_Guard_skipped_get(const moq_mux_catalog_Guard *self, moq_status *status); void moq_mux_catalog_Guard_skipped_set(moq_mux_catalog_Guard *self, moq_hang_catalog_Skipped *value, moq_status *status); -bool moq_mux_catalog_Guard_check_renditions(const moq_mux_catalog_Guard *self, moq_hang_Error **err, moq_status *status); -moq_hang_Catalog *moq_mux_catalog_Guard_without_ext(const moq_mux_catalog_Guard *self, moq_status *status); -bool moq_mux_catalog_Guard_to_json(const moq_mux_catalog_Guard *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_mux_catalog_Guard_to_vec(const moq_mux_catalog_Guard *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_mux_catalog_Guard_to_writer(const moq_mux_catalog_Guard *self, moq_buf writer, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_check_renditions(const moq_mux_catalog_Guard *self, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog *moq_mux_catalog_Guard_without_ext(const moq_mux_catalog_Guard *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_to_json(const moq_mux_catalog_Guard *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_to_vec(const moq_mux_catalog_Guard *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_to_writer(const moq_mux_catalog_Guard *self, moq_buf writer, moq_hang_Error **err, moq_status *status); void moq_mux_catalog_Guard_Extra_free(moq_mux_catalog_Guard_Extra *self); void moq_mux_catalog_Guard_Extra_drop(moq_mux_catalog_Guard_Extra *self, moq_status *status); -bool moq_mux_catalog_Guard_Extra_commit(moq_mux_catalog_Guard_Extra *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Guard_Extra_set_section(moq_mux_catalog_Guard_Extra *self, moq_buf name, moq_Json *value, moq_mux_Error **err, moq_status *status); -moq_Json *moq_mux_catalog_Guard_Extra_remove_section(moq_mux_catalog_Guard_Extra *self, moq_buf name, moq_status *status); -moq_hang_catalog_Video *moq_mux_catalog_Guard_Extra_video_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_Extra_commit(moq_mux_catalog_Guard_Extra *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_Extra_set_section(moq_mux_catalog_Guard_Extra *self, moq_buf name, moq_Json *value, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_Json *moq_mux_catalog_Guard_Extra_remove_section(moq_mux_catalog_Guard_Extra *self, moq_buf name, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Video *moq_mux_catalog_Guard_Extra_video_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); void moq_mux_catalog_Guard_Extra_video_set(moq_mux_catalog_Guard_Extra *self, moq_hang_catalog_Video *value, moq_status *status); -moq_hang_catalog_Audio *moq_mux_catalog_Guard_Extra_audio_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Audio *moq_mux_catalog_Guard_Extra_audio_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); void moq_mux_catalog_Guard_Extra_audio_set(moq_mux_catalog_Guard_Extra *self, moq_hang_catalog_Audio *value, moq_status *status); -moq_hang_catalog_Timeline *moq_mux_catalog_Guard_Extra_sync_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Timeline *moq_mux_catalog_Guard_Extra_sync_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); void moq_mux_catalog_Guard_Extra_sync_set(moq_mux_catalog_Guard_Extra *self, const moq_hang_catalog_Timeline *value, moq_status *status); -moq_hang_catalog_Text *moq_mux_catalog_Guard_Extra_text_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Text *moq_mux_catalog_Guard_Extra_text_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); void moq_mux_catalog_Guard_Extra_text_set(moq_mux_catalog_Guard_Extra *self, moq_hang_catalog_Text *value, moq_status *status); -moq_hang_catalog_Json *moq_mux_catalog_Guard_Extra_json_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Json *moq_mux_catalog_Guard_Extra_json_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); void moq_mux_catalog_Guard_Extra_json_set(moq_mux_catalog_Guard_Extra *self, moq_hang_catalog_Json *value, moq_status *status); -moq_hang_catalog_Binary *moq_mux_catalog_Guard_Extra_binary_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Binary *moq_mux_catalog_Guard_Extra_binary_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); void moq_mux_catalog_Guard_Extra_binary_set(moq_mux_catalog_Guard_Extra *self, moq_hang_catalog_Binary *value, moq_status *status); -moq_hang_catalog_Stats *moq_mux_catalog_Guard_Extra_stats_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Stats *moq_mux_catalog_Guard_Extra_stats_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); void moq_mux_catalog_Guard_Extra_stats_set(moq_mux_catalog_Guard_Extra *self, moq_hang_catalog_Stats *value, moq_status *status); -moq_hang_catalog_Echo *moq_mux_catalog_Guard_Extra_echo_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Echo *moq_mux_catalog_Guard_Extra_echo_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); void moq_mux_catalog_Guard_Extra_echo_set(moq_mux_catalog_Guard_Extra *self, moq_hang_catalog_Echo *value, moq_status *status); -moq_vec_tuple_string_hang_catalog_Include moq_mux_catalog_Guard_Extra_include_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_Include moq_mux_catalog_Guard_Extra_include_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); void moq_mux_catalog_Guard_Extra_include_set(moq_mux_catalog_Guard_Extra *self, moq_vec_tuple_string_hang_catalog_Include value, moq_status *status); -moq_mux_catalog_hang_Extra *moq_mux_catalog_Guard_Extra_ext_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_hang_Extra *moq_mux_catalog_Guard_Extra_ext_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); void moq_mux_catalog_Guard_Extra_ext_set(moq_mux_catalog_Guard_Extra *self, moq_mux_catalog_hang_Extra *value, moq_status *status); -moq_hang_catalog_Skipped *moq_mux_catalog_Guard_Extra_skipped_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Skipped *moq_mux_catalog_Guard_Extra_skipped_get(const moq_mux_catalog_Guard_Extra *self, moq_status *status); void moq_mux_catalog_Guard_Extra_skipped_set(moq_mux_catalog_Guard_Extra *self, moq_hang_catalog_Skipped *value, moq_status *status); -bool moq_mux_catalog_Guard_Extra_check_renditions(const moq_mux_catalog_Guard_Extra *self, moq_hang_Error **err, moq_status *status); -moq_hang_Catalog *moq_mux_catalog_Guard_Extra_without_ext(const moq_mux_catalog_Guard_Extra *self, moq_status *status); -bool moq_mux_catalog_Guard_Extra_to_json(const moq_mux_catalog_Guard_Extra *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_mux_catalog_Guard_Extra_to_vec(const moq_mux_catalog_Guard_Extra *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_mux_catalog_Guard_Extra_to_writer(const moq_mux_catalog_Guard_Extra *self, moq_buf writer, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_Extra_check_renditions(const moq_mux_catalog_Guard_Extra *self, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog *moq_mux_catalog_Guard_Extra_without_ext(const moq_mux_catalog_Guard_Extra *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_Extra_to_json(const moq_mux_catalog_Guard_Extra *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_Extra_to_vec(const moq_mux_catalog_Guard_Extra *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_Extra_to_writer(const moq_mux_catalog_Guard_Extra *self, moq_buf writer, moq_hang_Error **err, moq_status *status); void moq_mux_catalog_Guard_Ext_free(moq_mux_catalog_Guard_Ext *self); void moq_mux_catalog_Guard_Ext_drop(moq_mux_catalog_Guard_Ext *self, moq_status *status); -bool moq_mux_catalog_Guard_Ext_commit(moq_mux_catalog_Guard_Ext *self, moq_mux_Error **err, moq_status *status); -moq_hang_catalog_Video *moq_mux_catalog_Guard_Ext_video_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_Ext_commit(moq_mux_catalog_Guard_Ext *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Video *moq_mux_catalog_Guard_Ext_video_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); void moq_mux_catalog_Guard_Ext_video_set(moq_mux_catalog_Guard_Ext *self, moq_hang_catalog_Video *value, moq_status *status); -moq_hang_catalog_Audio *moq_mux_catalog_Guard_Ext_audio_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Audio *moq_mux_catalog_Guard_Ext_audio_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); void moq_mux_catalog_Guard_Ext_audio_set(moq_mux_catalog_Guard_Ext *self, moq_hang_catalog_Audio *value, moq_status *status); -moq_hang_catalog_Timeline *moq_mux_catalog_Guard_Ext_sync_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Timeline *moq_mux_catalog_Guard_Ext_sync_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); void moq_mux_catalog_Guard_Ext_sync_set(moq_mux_catalog_Guard_Ext *self, const moq_hang_catalog_Timeline *value, moq_status *status); -moq_hang_catalog_Text *moq_mux_catalog_Guard_Ext_text_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Text *moq_mux_catalog_Guard_Ext_text_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); void moq_mux_catalog_Guard_Ext_text_set(moq_mux_catalog_Guard_Ext *self, moq_hang_catalog_Text *value, moq_status *status); -moq_hang_catalog_Json *moq_mux_catalog_Guard_Ext_json_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Json *moq_mux_catalog_Guard_Ext_json_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); void moq_mux_catalog_Guard_Ext_json_set(moq_mux_catalog_Guard_Ext *self, moq_hang_catalog_Json *value, moq_status *status); -moq_hang_catalog_Binary *moq_mux_catalog_Guard_Ext_binary_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Binary *moq_mux_catalog_Guard_Ext_binary_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); void moq_mux_catalog_Guard_Ext_binary_set(moq_mux_catalog_Guard_Ext *self, moq_hang_catalog_Binary *value, moq_status *status); -moq_hang_catalog_Stats *moq_mux_catalog_Guard_Ext_stats_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Stats *moq_mux_catalog_Guard_Ext_stats_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); void moq_mux_catalog_Guard_Ext_stats_set(moq_mux_catalog_Guard_Ext *self, moq_hang_catalog_Stats *value, moq_status *status); -moq_hang_catalog_Echo *moq_mux_catalog_Guard_Ext_echo_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Echo *moq_mux_catalog_Guard_Ext_echo_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); void moq_mux_catalog_Guard_Ext_echo_set(moq_mux_catalog_Guard_Ext *self, moq_hang_catalog_Echo *value, moq_status *status); -moq_vec_tuple_string_hang_catalog_Include moq_mux_catalog_Guard_Ext_include_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_catalog_Include moq_mux_catalog_Guard_Ext_include_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); void moq_mux_catalog_Guard_Ext_include_set(moq_mux_catalog_Guard_Ext *self, moq_vec_tuple_string_hang_catalog_Include value, moq_status *status); -moq_mux_container_ts_Ext *moq_mux_catalog_Guard_Ext_ext_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Ext *moq_mux_catalog_Guard_Ext_ext_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); void moq_mux_catalog_Guard_Ext_ext_set(moq_mux_catalog_Guard_Ext *self, moq_mux_container_ts_Ext *value, moq_status *status); -moq_hang_catalog_Skipped *moq_mux_catalog_Guard_Ext_skipped_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Skipped *moq_mux_catalog_Guard_Ext_skipped_get(const moq_mux_catalog_Guard_Ext *self, moq_status *status); void moq_mux_catalog_Guard_Ext_skipped_set(moq_mux_catalog_Guard_Ext *self, moq_hang_catalog_Skipped *value, moq_status *status); -bool moq_mux_catalog_Guard_Ext_check_renditions(const moq_mux_catalog_Guard_Ext *self, moq_hang_Error **err, moq_status *status); -moq_hang_Catalog *moq_mux_catalog_Guard_Ext_without_ext(const moq_mux_catalog_Guard_Ext *self, moq_status *status); -bool moq_mux_catalog_Guard_Ext_to_json(const moq_mux_catalog_Guard_Ext *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_mux_catalog_Guard_Ext_to_vec(const moq_mux_catalog_Guard_Ext *self, moq_buf *out, moq_hang_Error **err, moq_status *status); -bool moq_mux_catalog_Guard_Ext_to_writer(const moq_mux_catalog_Guard_Ext *self, moq_buf writer, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_Ext_check_renditions(const moq_mux_catalog_Guard_Ext *self, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog *moq_mux_catalog_Guard_Ext_without_ext(const moq_mux_catalog_Guard_Ext *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_Ext_to_json(const moq_mux_catalog_Guard_Ext *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_Ext_to_vec(const moq_mux_catalog_Guard_Ext *self, moq_buf *out, moq_hang_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Guard_Ext_to_writer(const moq_mux_catalog_Guard_Ext *self, moq_buf writer, moq_hang_Error **err, moq_status *status); void moq_mux_catalog_Producer_free(moq_mux_catalog_Producer *self); void moq_mux_catalog_Producer_drop(moq_mux_catalog_Producer *self, moq_status *status); -moq_mux_catalog_Producer *moq_mux_catalog_Producer_clone(const moq_mux_catalog_Producer *self, moq_status *status); -bool moq_mux_catalog_Producer_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Config *config, moq_mux_catalog_Producer **out, moq_mux_Error **err, moq_status *status); -moq_track_Info *moq_mux_catalog_Producer_track_info(const moq_mux_catalog_Producer *self, int8_t priority, moq_status *status); -bool moq_mux_catalog_Producer_timestamp(const moq_mux_catalog_Producer *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_mutate(moq_mux_catalog_Producer *self, void (*f)(void *data, moq_hang_Catalog *), void *f_data, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_modify(moq_mux_catalog_Producer *self, moq_mux_catalog_Guard **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_modify_homed(moq_mux_catalog_Producer *self, moq_mux_catalog_Guard **out, moq_mux_Error **err, moq_status *status); -moq_hang_Catalog *moq_mux_catalog_Producer_snapshot(const moq_mux_catalog_Producer *self, moq_status *status); -moq_mux_Clock *moq_mux_catalog_Producer_clock(const moq_mux_catalog_Producer *self, moq_status *status); -moq_mux_catalog_Timebase *moq_mux_catalog_Producer_timebase(const moq_mux_catalog_Producer *self, moq_status *status); -moq_mux_catalog_Reserved *moq_mux_catalog_Producer_reserve(const moq_mux_catalog_Producer *self, moq_status *status); -bool moq_mux_catalog_Producer_video_Container(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_video_fmp4_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_video_legacy_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_video_loc_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_audio_Container(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_audio_fmp4_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_audio_legacy_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_audio_loc_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_text_Container(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_text_fmp4_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_text_legacy_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_text_loc_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_Container_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_Container_BinaryConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_Container_VideoConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_Container_AudioConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_Container_TextConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_legacy_Wire_TextConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_loc_Wire_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_loc_Wire_VideoConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_loc_Wire_AudioConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_track_loc_Wire_TextConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Producer *moq_mux_catalog_Producer_clone(const moq_mux_catalog_Producer *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Config *config, moq_mux_catalog_Producer **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_catalog_Producer_track_info(const moq_mux_catalog_Producer *self, int8_t priority, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_timestamp(const moq_mux_catalog_Producer *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_mutate(moq_mux_catalog_Producer *self, void (*f)(void *data, moq_hang_Catalog *), void *f_data, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_modify(moq_mux_catalog_Producer *self, moq_mux_catalog_Guard **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_modify_homed(moq_mux_catalog_Producer *self, moq_mux_catalog_Guard **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog *moq_mux_catalog_Producer_snapshot(const moq_mux_catalog_Producer *self, moq_status *status); +MOQ_MUST_USE moq_mux_Clock *moq_mux_catalog_Producer_clock(const moq_mux_catalog_Producer *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Timebase *moq_mux_catalog_Producer_timebase(const moq_mux_catalog_Producer *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Reserved *moq_mux_catalog_Producer_reserve(const moq_mux_catalog_Producer *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_video_Container(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_video_fmp4_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_video_legacy_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_video_loc_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_audio_Container(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_audio_fmp4_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_audio_legacy_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_audio_loc_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_text_Container(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_text_fmp4_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_text_legacy_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_text_loc_Wire(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_Container_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_Container_BinaryConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_Container_VideoConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_Container_AudioConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_Container_TextConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_legacy_Wire_TextConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_loc_Wire_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_loc_Wire_VideoConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_loc_Wire_AudioConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_track_loc_Wire_TextConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_is_claimed_JsonConfig(const moq_mux_catalog_Producer *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_is_claimed_BinaryConfig(const moq_mux_catalog_Producer *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_is_claimed_VideoConfig(const moq_mux_catalog_Producer *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_is_claimed_AudioConfig(const moq_mux_catalog_Producer *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_is_claimed_TextConfig(const moq_mux_catalog_Producer *self, moq_buf name, moq_status *status); -moq_vec_tuple_string_hang_stats_Rendition moq_mux_catalog_Producer_stats(const moq_mux_catalog_Producer *self, moq_status *status); -bool moq_mux_catalog_Producer_json_snapshot_Config(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_json_snapshot_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_json_stream_Config(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_json_stream_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_consume(const moq_mux_catalog_Producer *self, moq_mux_catalog_hang_Consumer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_stats_Rendition moq_mux_catalog_Producer_stats(const moq_mux_catalog_Producer *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_json_snapshot_Config(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_json_snapshot_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_json_stream_Config(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_json_stream_JsonConfig(const moq_mux_catalog_Producer *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_consume(const moq_mux_catalog_Producer *self, moq_mux_catalog_hang_Consumer **out, moq_Error **err, moq_status *status); void moq_mux_catalog_Producer_abort(moq_mux_catalog_Producer *self, moq_Error *err_, moq_status *status); -bool moq_mux_catalog_Producer_finish(moq_mux_catalog_Producer *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_finish(moq_mux_catalog_Producer *self, moq_mux_Error **err, moq_status *status); void moq_mux_catalog_Producer_Extra_free(moq_mux_catalog_Producer_Extra *self); void moq_mux_catalog_Producer_Extra_drop(moq_mux_catalog_Producer_Extra *self, moq_status *status); -moq_mux_catalog_Producer_Extra *moq_mux_catalog_Producer_Extra_clone(const moq_mux_catalog_Producer_Extra *self, moq_status *status); -bool moq_mux_catalog_Producer_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Config_Extra *config, moq_mux_catalog_Producer_Extra **out, moq_mux_Error **err, moq_status *status); -moq_track_Info *moq_mux_catalog_Producer_Extra_track_info(const moq_mux_catalog_Producer_Extra *self, int8_t priority, moq_status *status); -bool moq_mux_catalog_Producer_Extra_timestamp(const moq_mux_catalog_Producer_Extra *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_mutate(moq_mux_catalog_Producer_Extra *self, void (*f)(void *data, moq_hang_Catalog_Extra *), void *f_data, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_modify(moq_mux_catalog_Producer_Extra *self, moq_mux_catalog_Guard_Extra **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_modify_homed(moq_mux_catalog_Producer_Extra *self, moq_mux_catalog_Guard_Extra **out, moq_mux_Error **err, moq_status *status); -moq_hang_Catalog_Extra *moq_mux_catalog_Producer_Extra_snapshot(const moq_mux_catalog_Producer_Extra *self, moq_status *status); -moq_mux_Clock *moq_mux_catalog_Producer_Extra_clock(const moq_mux_catalog_Producer_Extra *self, moq_status *status); -moq_mux_catalog_Timebase_Extra *moq_mux_catalog_Producer_Extra_timebase(const moq_mux_catalog_Producer_Extra *self, moq_status *status); -moq_mux_catalog_Reserved_Extra *moq_mux_catalog_Producer_Extra_reserve(const moq_mux_catalog_Producer_Extra *self, moq_status *status); -bool moq_mux_catalog_Producer_Extra_video_Container(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_video_fmp4_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_video_legacy_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_video_loc_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_audio_Container(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_audio_fmp4_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_audio_legacy_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_audio_loc_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_text_Container(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_text_fmp4_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_text_legacy_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_text_loc_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_Container_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_Container_BinaryConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_Container_VideoConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_Container_AudioConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_Container_TextConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_legacy_Wire_TextConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_loc_Wire_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_loc_Wire_VideoConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_loc_Wire_AudioConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_track_loc_Wire_TextConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Producer_Extra *moq_mux_catalog_Producer_Extra_clone(const moq_mux_catalog_Producer_Extra *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Config_Extra *config, moq_mux_catalog_Producer_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_catalog_Producer_Extra_track_info(const moq_mux_catalog_Producer_Extra *self, int8_t priority, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_timestamp(const moq_mux_catalog_Producer_Extra *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_mutate(moq_mux_catalog_Producer_Extra *self, void (*f)(void *data, moq_hang_Catalog_Extra *), void *f_data, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_modify(moq_mux_catalog_Producer_Extra *self, moq_mux_catalog_Guard_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_modify_homed(moq_mux_catalog_Producer_Extra *self, moq_mux_catalog_Guard_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog_Extra *moq_mux_catalog_Producer_Extra_snapshot(const moq_mux_catalog_Producer_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_Clock *moq_mux_catalog_Producer_Extra_clock(const moq_mux_catalog_Producer_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Timebase_Extra *moq_mux_catalog_Producer_Extra_timebase(const moq_mux_catalog_Producer_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Reserved_Extra *moq_mux_catalog_Producer_Extra_reserve(const moq_mux_catalog_Producer_Extra *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_video_Container(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_video_fmp4_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_video_legacy_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_video_loc_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_audio_Container(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_audio_fmp4_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_audio_legacy_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_audio_loc_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_text_Container(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_text_fmp4_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_text_legacy_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_text_loc_Wire(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_Container_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_Container_BinaryConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_Container_VideoConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_Container_AudioConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_Container_TextConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_legacy_Wire_TextConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_loc_Wire_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_loc_Wire_VideoConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_loc_Wire_AudioConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_track_loc_Wire_TextConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_Extra_is_claimed_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_Extra_is_claimed_BinaryConfig(const moq_mux_catalog_Producer_Extra *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_Extra_is_claimed_VideoConfig(const moq_mux_catalog_Producer_Extra *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_Extra_is_claimed_AudioConfig(const moq_mux_catalog_Producer_Extra *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_Extra_is_claimed_TextConfig(const moq_mux_catalog_Producer_Extra *self, moq_buf name, moq_status *status); -moq_vec_tuple_string_hang_stats_Rendition moq_mux_catalog_Producer_Extra_stats(const moq_mux_catalog_Producer_Extra *self, moq_status *status); -bool moq_mux_catalog_Producer_Extra_json_snapshot_Config(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_json_snapshot_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_json_stream_Config(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_json_stream_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Extra_consume(const moq_mux_catalog_Producer_Extra *self, moq_mux_catalog_hang_Consumer_Extra **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_stats_Rendition moq_mux_catalog_Producer_Extra_stats(const moq_mux_catalog_Producer_Extra *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_json_snapshot_Config(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_json_snapshot_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_json_stream_Config(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_json_stream_JsonConfig(const moq_mux_catalog_Producer_Extra *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_consume(const moq_mux_catalog_Producer_Extra *self, moq_mux_catalog_hang_Consumer_Extra **out, moq_Error **err, moq_status *status); void moq_mux_catalog_Producer_Extra_abort(moq_mux_catalog_Producer_Extra *self, moq_Error *err_, moq_status *status); -bool moq_mux_catalog_Producer_Extra_finish(moq_mux_catalog_Producer_Extra *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Extra_finish(moq_mux_catalog_Producer_Extra *self, moq_mux_Error **err, moq_status *status); void moq_mux_catalog_Producer_Ext_free(moq_mux_catalog_Producer_Ext *self); void moq_mux_catalog_Producer_Ext_drop(moq_mux_catalog_Producer_Ext *self, moq_status *status); -moq_mux_catalog_Producer_Ext *moq_mux_catalog_Producer_Ext_clone(const moq_mux_catalog_Producer_Ext *self, moq_status *status); -bool moq_mux_catalog_Producer_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Config_Ext *config, moq_mux_catalog_Producer_Ext **out, moq_mux_Error **err, moq_status *status); -moq_track_Info *moq_mux_catalog_Producer_Ext_track_info(const moq_mux_catalog_Producer_Ext *self, int8_t priority, moq_status *status); -bool moq_mux_catalog_Producer_Ext_timestamp(const moq_mux_catalog_Producer_Ext *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_mutate(moq_mux_catalog_Producer_Ext *self, void (*f)(void *data, moq_hang_Catalog_Ext *), void *f_data, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_modify(moq_mux_catalog_Producer_Ext *self, moq_mux_catalog_Guard_Ext **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_modify_homed(moq_mux_catalog_Producer_Ext *self, moq_mux_catalog_Guard_Ext **out, moq_mux_Error **err, moq_status *status); -moq_hang_Catalog_Ext *moq_mux_catalog_Producer_Ext_snapshot(const moq_mux_catalog_Producer_Ext *self, moq_status *status); -moq_mux_Clock *moq_mux_catalog_Producer_Ext_clock(const moq_mux_catalog_Producer_Ext *self, moq_status *status); -moq_mux_catalog_Timebase_Ext *moq_mux_catalog_Producer_Ext_timebase(const moq_mux_catalog_Producer_Ext *self, moq_status *status); -moq_mux_catalog_Reserved_Ext *moq_mux_catalog_Producer_Ext_reserve(const moq_mux_catalog_Producer_Ext *self, moq_status *status); -bool moq_mux_catalog_Producer_Ext_video_Container(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_video_fmp4_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_video_legacy_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_video_loc_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_audio_Container(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_audio_fmp4_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_audio_legacy_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_audio_loc_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_text_Container(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_text_fmp4_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_text_legacy_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_text_loc_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_Container_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_Container_BinaryConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_Container_VideoConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_Container_AudioConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_Container_TextConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_legacy_Wire_TextConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_loc_Wire_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_loc_Wire_VideoConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_loc_Wire_AudioConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_track_loc_Wire_TextConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Producer_Ext *moq_mux_catalog_Producer_Ext_clone(const moq_mux_catalog_Producer_Ext *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Config_Ext *config, moq_mux_catalog_Producer_Ext **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_catalog_Producer_Ext_track_info(const moq_mux_catalog_Producer_Ext *self, int8_t priority, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_timestamp(const moq_mux_catalog_Producer_Ext *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_mutate(moq_mux_catalog_Producer_Ext *self, void (*f)(void *data, moq_hang_Catalog_Ext *), void *f_data, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_modify(moq_mux_catalog_Producer_Ext *self, moq_mux_catalog_Guard_Ext **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_modify_homed(moq_mux_catalog_Producer_Ext *self, moq_mux_catalog_Guard_Ext **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog_Ext *moq_mux_catalog_Producer_Ext_snapshot(const moq_mux_catalog_Producer_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_Clock *moq_mux_catalog_Producer_Ext_clock(const moq_mux_catalog_Producer_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Timebase_Ext *moq_mux_catalog_Producer_Ext_timebase(const moq_mux_catalog_Producer_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Reserved_Ext *moq_mux_catalog_Producer_Ext_reserve(const moq_mux_catalog_Producer_Ext *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_video_Container(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_video_fmp4_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_video_legacy_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_video_loc_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_audio_Container(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_audio_fmp4_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_audio_legacy_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_audio_loc_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_text_Container(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_text_fmp4_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_text_legacy_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_text_loc_Wire(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_Container_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_Container_BinaryConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_Container_VideoConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_Container_AudioConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_Container_TextConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_legacy_Wire_TextConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_loc_Wire_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_loc_Wire_VideoConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_loc_Wire_AudioConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_track_loc_Wire_TextConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); bool moq_mux_catalog_Producer_Ext_is_claimed_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_Ext_is_claimed_BinaryConfig(const moq_mux_catalog_Producer_Ext *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_Ext_is_claimed_VideoConfig(const moq_mux_catalog_Producer_Ext *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_Ext_is_claimed_AudioConfig(const moq_mux_catalog_Producer_Ext *self, moq_buf name, moq_status *status); bool moq_mux_catalog_Producer_Ext_is_claimed_TextConfig(const moq_mux_catalog_Producer_Ext *self, moq_buf name, moq_status *status); -moq_vec_tuple_string_hang_stats_Rendition moq_mux_catalog_Producer_Ext_stats(const moq_mux_catalog_Producer_Ext *self, moq_status *status); -bool moq_mux_catalog_Producer_Ext_json_snapshot_Config(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_json_snapshot_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_json_stream_Config(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_json_stream_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Producer_Ext_consume(const moq_mux_catalog_Producer_Ext *self, moq_mux_catalog_hang_Consumer_Ext **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_hang_stats_Rendition moq_mux_catalog_Producer_Ext_stats(const moq_mux_catalog_Producer_Ext *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_json_snapshot_Config(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_json_snapshot_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Options *options, moq_mux_json_Snapshot_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_json_stream_Config(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_mux_json_Config *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_json_stream_JsonConfig(const moq_mux_catalog_Producer_Ext *self, moq_track_Producer *track, moq_hang_catalog_JsonConfig *config, moq_mux_json_Stream_Json **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_consume(const moq_mux_catalog_Producer_Ext *self, moq_mux_catalog_hang_Consumer_Ext **out, moq_Error **err, moq_status *status); void moq_mux_catalog_Producer_Ext_abort(moq_mux_catalog_Producer_Ext *self, moq_Error *err_, moq_status *status); -bool moq_mux_catalog_Producer_Ext_finish(moq_mux_catalog_Producer_Ext *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Producer_Ext_finish(moq_mux_catalog_Producer_Ext *self, moq_mux_Error **err, moq_status *status); void moq_mux_catalog_Timebase_free(moq_mux_catalog_Timebase *self); -moq_mux_catalog_Timebase *moq_mux_catalog_Timebase_clone(const moq_mux_catalog_Timebase *self); -moq_mux_catalog_Reserved *moq_mux_catalog_Timebase_reserve(const moq_mux_catalog_Timebase *self); -bool moq_mux_catalog_Timebase_place(const moq_mux_catalog_Timebase *self, moq_Timestamp pts, moq_clock_Wall wall, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_Timebase *moq_mux_catalog_Timebase_clone(const moq_mux_catalog_Timebase *self); +MOQ_MUST_USE moq_mux_catalog_Reserved *moq_mux_catalog_Timebase_reserve(const moq_mux_catalog_Timebase *self); +MOQ_MUST_USE bool moq_mux_catalog_Timebase_place(const moq_mux_catalog_Timebase *self, moq_Timestamp pts, moq_clock_Wall wall, moq_mux_Error **err); void moq_mux_catalog_Timebase_Extra_free(moq_mux_catalog_Timebase_Extra *self); -moq_mux_catalog_Timebase_Extra *moq_mux_catalog_Timebase_Extra_clone(const moq_mux_catalog_Timebase_Extra *self); -moq_mux_catalog_Reserved_Extra *moq_mux_catalog_Timebase_Extra_reserve(const moq_mux_catalog_Timebase_Extra *self); -bool moq_mux_catalog_Timebase_Extra_place(const moq_mux_catalog_Timebase_Extra *self, moq_Timestamp pts, moq_clock_Wall wall, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_Timebase_Extra *moq_mux_catalog_Timebase_Extra_clone(const moq_mux_catalog_Timebase_Extra *self); +MOQ_MUST_USE moq_mux_catalog_Reserved_Extra *moq_mux_catalog_Timebase_Extra_reserve(const moq_mux_catalog_Timebase_Extra *self); +MOQ_MUST_USE bool moq_mux_catalog_Timebase_Extra_place(const moq_mux_catalog_Timebase_Extra *self, moq_Timestamp pts, moq_clock_Wall wall, moq_mux_Error **err); void moq_mux_catalog_Timebase_Ext_free(moq_mux_catalog_Timebase_Ext *self); -moq_mux_catalog_Timebase_Ext *moq_mux_catalog_Timebase_Ext_clone(const moq_mux_catalog_Timebase_Ext *self); -moq_mux_catalog_Reserved_Ext *moq_mux_catalog_Timebase_Ext_reserve(const moq_mux_catalog_Timebase_Ext *self); -bool moq_mux_catalog_Timebase_Ext_place(const moq_mux_catalog_Timebase_Ext *self, moq_Timestamp pts, moq_clock_Wall wall, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_Timebase_Ext *moq_mux_catalog_Timebase_Ext_clone(const moq_mux_catalog_Timebase_Ext *self); +MOQ_MUST_USE moq_mux_catalog_Reserved_Ext *moq_mux_catalog_Timebase_Ext_reserve(const moq_mux_catalog_Timebase_Ext *self); +MOQ_MUST_USE bool moq_mux_catalog_Timebase_Ext_place(const moq_mux_catalog_Timebase_Ext *self, moq_Timestamp pts, moq_clock_Wall wall, moq_mux_Error **err); void moq_mux_catalog_Reserved_free(moq_mux_catalog_Reserved *self); void moq_mux_catalog_Reserved_drop(moq_mux_catalog_Reserved *self, moq_status *status); -moq_mux_catalog_Reserved *moq_mux_catalog_Reserved_clone(const moq_mux_catalog_Reserved *self, moq_status *status); -moq_mux_catalog_Reserved *moq_mux_catalog_Reserved_with_interval(moq_mux_catalog_Reserved *self, moq_option_duration interval, moq_status *status); -moq_track_Info *moq_mux_catalog_Reserved_track_info(const moq_mux_catalog_Reserved *self, int8_t priority, moq_status *status); -bool moq_mux_catalog_Reserved_video_Container(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_video_fmp4_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_video_legacy_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_video_loc_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_audio_Container(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_audio_fmp4_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_audio_legacy_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_audio_loc_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_text_Container(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_text_fmp4_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_text_legacy_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_text_loc_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_Container_JsonConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_Container_BinaryConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_Container_VideoConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_Container_AudioConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_Container_TextConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_legacy_Wire_TextConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_loc_Wire_JsonConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_loc_Wire_VideoConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_loc_Wire_AudioConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_track_loc_Wire_TextConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_timestamp(const moq_mux_catalog_Reserved *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Reserved *moq_mux_catalog_Reserved_clone(const moq_mux_catalog_Reserved *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Reserved *moq_mux_catalog_Reserved_with_interval(moq_mux_catalog_Reserved *self, moq_option_duration interval, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_catalog_Reserved_track_info(const moq_mux_catalog_Reserved *self, int8_t priority, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_video_Container(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_video_fmp4_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_video_legacy_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_video_loc_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_audio_Container(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_audio_fmp4_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_audio_legacy_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_audio_loc_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_text_Container(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_text_fmp4_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_text_legacy_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_text_loc_Wire(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_Container_JsonConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_Container_BinaryConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_Container_VideoConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_Container_AudioConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_Container_TextConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_legacy_Wire_TextConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_loc_Wire_JsonConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_loc_Wire_VideoConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_loc_Wire_AudioConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_track_loc_Wire_TextConfig(const moq_mux_catalog_Reserved *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_timestamp(const moq_mux_catalog_Reserved *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); void moq_mux_catalog_Reserved_Extra_free(moq_mux_catalog_Reserved_Extra *self); void moq_mux_catalog_Reserved_Extra_drop(moq_mux_catalog_Reserved_Extra *self, moq_status *status); -moq_mux_catalog_Reserved_Extra *moq_mux_catalog_Reserved_Extra_clone(const moq_mux_catalog_Reserved_Extra *self, moq_status *status); -moq_mux_catalog_Reserved_Extra *moq_mux_catalog_Reserved_Extra_with_interval(moq_mux_catalog_Reserved_Extra *self, moq_option_duration interval, moq_status *status); -moq_track_Info *moq_mux_catalog_Reserved_Extra_track_info(const moq_mux_catalog_Reserved_Extra *self, int8_t priority, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_video_Container(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_video_fmp4_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_video_legacy_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_video_loc_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_audio_Container(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_audio_fmp4_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_audio_legacy_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_audio_loc_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_text_Container(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_text_fmp4_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_text_legacy_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_text_loc_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_Container_JsonConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_Container_BinaryConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_Container_VideoConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_Container_AudioConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_Container_TextConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_legacy_Wire_TextConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_JsonConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_VideoConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_AudioConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_TextConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Extra_timestamp(const moq_mux_catalog_Reserved_Extra *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Reserved_Extra *moq_mux_catalog_Reserved_Extra_clone(const moq_mux_catalog_Reserved_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Reserved_Extra *moq_mux_catalog_Reserved_Extra_with_interval(moq_mux_catalog_Reserved_Extra *self, moq_option_duration interval, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_catalog_Reserved_Extra_track_info(const moq_mux_catalog_Reserved_Extra *self, int8_t priority, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_video_Container(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_video_fmp4_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_video_legacy_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_video_loc_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_audio_Container(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_audio_fmp4_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_audio_legacy_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_audio_loc_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_text_Container(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_text_fmp4_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_text_legacy_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_text_loc_Wire(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_Container_JsonConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_Container_BinaryConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_Container_VideoConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_Container_AudioConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_Container_TextConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_legacy_Wire_TextConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_JsonConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_VideoConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_AudioConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_track_loc_Wire_TextConfig(const moq_mux_catalog_Reserved_Extra *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Extra_timestamp(const moq_mux_catalog_Reserved_Extra *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); void moq_mux_catalog_Reserved_Ext_free(moq_mux_catalog_Reserved_Ext *self); void moq_mux_catalog_Reserved_Ext_drop(moq_mux_catalog_Reserved_Ext *self, moq_status *status); -moq_mux_catalog_Reserved_Ext *moq_mux_catalog_Reserved_Ext_clone(const moq_mux_catalog_Reserved_Ext *self, moq_status *status); -moq_mux_catalog_Reserved_Ext *moq_mux_catalog_Reserved_Ext_with_interval(moq_mux_catalog_Reserved_Ext *self, moq_option_duration interval, moq_status *status); -moq_track_Info *moq_mux_catalog_Reserved_Ext_track_info(const moq_mux_catalog_Reserved_Ext *self, int8_t priority, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_video_Container(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_video_fmp4_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_video_legacy_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_video_loc_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_audio_Container(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_audio_fmp4_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_audio_legacy_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_audio_loc_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_text_Container(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_text_fmp4_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_text_legacy_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_text_loc_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_Container_JsonConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_Container_BinaryConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_Container_VideoConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_Container_AudioConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_Container_TextConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_legacy_Wire_TextConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_JsonConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_VideoConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_AudioConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_TextConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_catalog_Reserved_Ext_timestamp(const moq_mux_catalog_Reserved_Ext *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Reserved_Ext *moq_mux_catalog_Reserved_Ext_clone(const moq_mux_catalog_Reserved_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Reserved_Ext *moq_mux_catalog_Reserved_Ext_with_interval(moq_mux_catalog_Reserved_Ext *self, moq_option_duration interval, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_catalog_Reserved_Ext_track_info(const moq_mux_catalog_Reserved_Ext *self, int8_t priority, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_video_Container(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_video_fmp4_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_video_legacy_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_video_loc_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_audio_Container(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_audio_fmp4_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_audio_legacy_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_audio_loc_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_text_Container(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_text_fmp4_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_text_legacy_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_text_loc_Wire(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_Container_JsonConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_Container_BinaryConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_Container_VideoConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_Container_AudioConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_Container_TextConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_fmp4_Wire_JsonConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_fmp4_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_fmp4_Wire_VideoConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_fmp4_Wire_AudioConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_fmp4_Wire_TextConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_legacy_Wire_JsonConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_legacy_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_legacy_Wire_VideoConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_legacy_Wire_AudioConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_legacy_Wire_TextConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_JsonConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_JsonConfig *config, moq_mux_container_Producer_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_BinaryConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_BinaryConfig *config, moq_mux_container_Producer_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_VideoConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_VideoConfig *config, moq_mux_container_Producer_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_AudioConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_AudioConfig *config, moq_mux_container_Producer_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_track_loc_Wire_TextConfig(const moq_mux_catalog_Reserved_Ext *self, moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_hang_catalog_TextConfig *config, moq_mux_container_Producer_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_Reserved_Ext_timestamp(const moq_mux_catalog_Reserved_Ext *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); void moq_mux_catalog_VideoHint_free(moq_mux_catalog_VideoHint *self); void moq_mux_catalog_VideoHint_drop(moq_mux_catalog_VideoHint *self, moq_status *status); -moq_mux_catalog_VideoHint *moq_mux_catalog_VideoHint_clone(const moq_mux_catalog_VideoHint *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_VideoHint *moq_mux_catalog_VideoHint_clone(const moq_mux_catalog_VideoHint *self, moq_status *status); bool moq_mux_catalog_VideoHint_eq(const moq_mux_catalog_VideoHint *a, const moq_mux_catalog_VideoHint *b, moq_status *status); -moq_buf moq_mux_catalog_VideoHint_debug(const moq_mux_catalog_VideoHint *self, moq_status *status); -moq_mux_catalog_VideoHint *moq_mux_catalog_VideoHint_default(void); -moq_option_hang_catalog_VideoCodec moq_mux_catalog_VideoHint_codec_get(const moq_mux_catalog_VideoHint *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_catalog_VideoHint_debug(const moq_mux_catalog_VideoHint *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_VideoHint *moq_mux_catalog_VideoHint_default(void); +MOQ_MUST_USE moq_option_hang_catalog_VideoCodec moq_mux_catalog_VideoHint_codec_get(const moq_mux_catalog_VideoHint *self, moq_status *status); void moq_mux_catalog_VideoHint_codec_set(moq_mux_catalog_VideoHint *self, moq_option_hang_catalog_VideoCodec value, moq_status *status); moq_option_u32 moq_mux_catalog_VideoHint_coded_width_get(const moq_mux_catalog_VideoHint *self, moq_status *status); void moq_mux_catalog_VideoHint_coded_width_set(moq_mux_catalog_VideoHint *self, moq_option_u32 value, moq_status *status); @@ -5785,7 +5795,7 @@ moq_option_u32 moq_mux_catalog_VideoHint_display_aspect_width_get(const moq_mux_ void moq_mux_catalog_VideoHint_display_aspect_width_set(moq_mux_catalog_VideoHint *self, moq_option_u32 value, moq_status *status); moq_option_u32 moq_mux_catalog_VideoHint_display_aspect_height_get(const moq_mux_catalog_VideoHint *self, moq_status *status); void moq_mux_catalog_VideoHint_display_aspect_height_set(moq_mux_catalog_VideoHint *self, moq_option_u32 value, moq_status *status); -moq_hang_catalog_Color *moq_mux_catalog_VideoHint_color_get(const moq_mux_catalog_VideoHint *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Color *moq_mux_catalog_VideoHint_color_get(const moq_mux_catalog_VideoHint *self, moq_status *status); void moq_mux_catalog_VideoHint_color_set(moq_mux_catalog_VideoHint *self, moq_hang_catalog_Color *value, moq_status *status); moq_option_u64 moq_mux_catalog_VideoHint_bitrate_get(const moq_mux_catalog_VideoHint *self, moq_status *status); void moq_mux_catalog_VideoHint_bitrate_set(moq_mux_catalog_VideoHint *self, moq_option_u64 value, moq_status *status); @@ -5799,320 +5809,320 @@ moq_option_duration moq_mux_catalog_VideoHint_jitter_get(const moq_mux_catalog_V void moq_mux_catalog_VideoHint_jitter_set(moq_mux_catalog_VideoHint *self, moq_option_duration value, moq_status *status); moq_option_duration moq_mux_catalog_VideoHint_delay_get(const moq_mux_catalog_VideoHint *self, moq_status *status); void moq_mux_catalog_VideoHint_delay_set(moq_mux_catalog_VideoHint *self, moq_option_duration value, moq_status *status); -moq_hang_catalog_Container *moq_mux_catalog_VideoHint_container_get(const moq_mux_catalog_VideoHint *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Container *moq_mux_catalog_VideoHint_container_get(const moq_mux_catalog_VideoHint *self, moq_status *status); void moq_mux_catalog_VideoHint_container_set(moq_mux_catalog_VideoHint *self, moq_hang_catalog_Container *value, moq_status *status); int32_t moq_mux_catalog_VideoHint_preference_get(const moq_mux_catalog_VideoHint *self, moq_status *status); void moq_mux_catalog_VideoHint_preference_set(moq_mux_catalog_VideoHint *self, int32_t value, moq_status *status); void moq_mux_catalog_VideoHint_apply(const moq_mux_catalog_VideoHint *self, moq_hang_catalog_VideoConfig *config, moq_status *status); void moq_mux_container_Consumer_Container_free(moq_mux_container_Consumer_Container *self); void moq_mux_container_Consumer_Container_drop(moq_mux_container_Consumer_Container *self, moq_status *status); -moq_mux_container_Consumer_Container *moq_mux_container_Consumer_Container_new(moq_track_Subscriber *track, moq_mux_catalog_hang_Container *format, moq_status *status); +MOQ_MUST_USE moq_mux_container_Consumer_Container *moq_mux_container_Consumer_Container_new(moq_track_Subscriber *track, moq_mux_catalog_hang_Container *format, moq_status *status); moq_option_clock_Instant moq_mux_container_Consumer_Container_arrival(const moq_mux_container_Consumer_Container *self, moq_status *status); moq_option_clock_Instant moq_mux_container_Consumer_Container_backlog(const moq_mux_container_Consumer_Container *self, moq_status *status); typedef struct moq_mux_container_Consumer_Container_read_future moq_mux_container_Consumer_Container_read_future; -moq_mux_container_Consumer_Container_read_future *moq_mux_container_Consumer_Container_read(moq_mux_container_Consumer_Container *self, moq_status *status); -moq_poll moq_mux_container_Consumer_Container_read_start(moq_mux_container_Consumer_Container *self, moq_option_mux_container_Read *out, moq_mux_Error **err, moq_mux_container_Consumer_Container_read_future **future, moq_status *status); -moq_poll moq_mux_container_Consumer_Container_read_poll(moq_mux_container_Consumer_Container_read_future *future, moq_waker waker, moq_option_mux_container_Read *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_Consumer_Container_read_future *moq_mux_container_Consumer_Container_read(moq_mux_container_Consumer_Container *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Consumer_Container_read_start(moq_mux_container_Consumer_Container *self, moq_option_mux_container_Read *out, moq_mux_Error **err, moq_mux_container_Consumer_Container_read_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Consumer_Container_read_poll(moq_mux_container_Consumer_Container_read_future *future, moq_waker waker, moq_option_mux_container_Read *out, moq_mux_Error **err); void moq_mux_container_Consumer_Container_read_future_free(moq_mux_container_Consumer_Container_read_future *future); bool moq_mux_container_Consumer_Container_is_skipped(const moq_mux_container_Consumer_Container *self, moq_range_u64 groups, moq_status *status); void moq_mux_container_Consumer_Container_set_delay(moq_mux_container_Consumer_Container *self, moq_track_Delay delay, moq_status *status); void moq_mux_container_Consumer_Container_set_playhead(moq_mux_container_Consumer_Container *self, moq_mux_sync_Consumer *playhead, moq_status *status); void moq_mux_container_Consumer_fmp4_Wire_free(moq_mux_container_Consumer_fmp4_Wire *self); void moq_mux_container_Consumer_fmp4_Wire_drop(moq_mux_container_Consumer_fmp4_Wire *self, moq_status *status); -moq_mux_container_Consumer_fmp4_Wire *moq_mux_container_Consumer_fmp4_Wire_new(moq_track_Subscriber *track, moq_mux_container_fmp4_Wire *format, moq_status *status); +MOQ_MUST_USE moq_mux_container_Consumer_fmp4_Wire *moq_mux_container_Consumer_fmp4_Wire_new(moq_track_Subscriber *track, moq_mux_container_fmp4_Wire *format, moq_status *status); moq_option_clock_Instant moq_mux_container_Consumer_fmp4_Wire_arrival(const moq_mux_container_Consumer_fmp4_Wire *self, moq_status *status); moq_option_clock_Instant moq_mux_container_Consumer_fmp4_Wire_backlog(const moq_mux_container_Consumer_fmp4_Wire *self, moq_status *status); typedef struct moq_mux_container_Consumer_fmp4_Wire_read_future moq_mux_container_Consumer_fmp4_Wire_read_future; -moq_mux_container_Consumer_fmp4_Wire_read_future *moq_mux_container_Consumer_fmp4_Wire_read(moq_mux_container_Consumer_fmp4_Wire *self, moq_status *status); -moq_poll moq_mux_container_Consumer_fmp4_Wire_read_start(moq_mux_container_Consumer_fmp4_Wire *self, moq_option_mux_container_Read *out, moq_mux_container_fmp4_Error **err, moq_mux_container_Consumer_fmp4_Wire_read_future **future, moq_status *status); -moq_poll moq_mux_container_Consumer_fmp4_Wire_read_poll(moq_mux_container_Consumer_fmp4_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Read *out, moq_mux_container_fmp4_Error **err); +MOQ_MUST_USE moq_mux_container_Consumer_fmp4_Wire_read_future *moq_mux_container_Consumer_fmp4_Wire_read(moq_mux_container_Consumer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Consumer_fmp4_Wire_read_start(moq_mux_container_Consumer_fmp4_Wire *self, moq_option_mux_container_Read *out, moq_mux_container_fmp4_Error **err, moq_mux_container_Consumer_fmp4_Wire_read_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Consumer_fmp4_Wire_read_poll(moq_mux_container_Consumer_fmp4_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Read *out, moq_mux_container_fmp4_Error **err); void moq_mux_container_Consumer_fmp4_Wire_read_future_free(moq_mux_container_Consumer_fmp4_Wire_read_future *future); bool moq_mux_container_Consumer_fmp4_Wire_is_skipped(const moq_mux_container_Consumer_fmp4_Wire *self, moq_range_u64 groups, moq_status *status); void moq_mux_container_Consumer_fmp4_Wire_set_delay(moq_mux_container_Consumer_fmp4_Wire *self, moq_track_Delay delay, moq_status *status); void moq_mux_container_Consumer_fmp4_Wire_set_playhead(moq_mux_container_Consumer_fmp4_Wire *self, moq_mux_sync_Consumer *playhead, moq_status *status); void moq_mux_container_Consumer_legacy_Wire_free(moq_mux_container_Consumer_legacy_Wire *self); void moq_mux_container_Consumer_legacy_Wire_drop(moq_mux_container_Consumer_legacy_Wire *self, moq_status *status); -moq_mux_container_Consumer_legacy_Wire *moq_mux_container_Consumer_legacy_Wire_new(moq_track_Subscriber *track, moq_mux_container_legacy_Wire format, moq_status *status); +MOQ_MUST_USE moq_mux_container_Consumer_legacy_Wire *moq_mux_container_Consumer_legacy_Wire_new(moq_track_Subscriber *track, moq_mux_container_legacy_Wire format, moq_status *status); moq_option_clock_Instant moq_mux_container_Consumer_legacy_Wire_arrival(const moq_mux_container_Consumer_legacy_Wire *self, moq_status *status); moq_option_clock_Instant moq_mux_container_Consumer_legacy_Wire_backlog(const moq_mux_container_Consumer_legacy_Wire *self, moq_status *status); typedef struct moq_mux_container_Consumer_legacy_Wire_read_future moq_mux_container_Consumer_legacy_Wire_read_future; -moq_mux_container_Consumer_legacy_Wire_read_future *moq_mux_container_Consumer_legacy_Wire_read(moq_mux_container_Consumer_legacy_Wire *self, moq_status *status); -moq_poll moq_mux_container_Consumer_legacy_Wire_read_start(moq_mux_container_Consumer_legacy_Wire *self, moq_option_mux_container_Read *out, moq_mux_Error **err, moq_mux_container_Consumer_legacy_Wire_read_future **future, moq_status *status); -moq_poll moq_mux_container_Consumer_legacy_Wire_read_poll(moq_mux_container_Consumer_legacy_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Read *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_Consumer_legacy_Wire_read_future *moq_mux_container_Consumer_legacy_Wire_read(moq_mux_container_Consumer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Consumer_legacy_Wire_read_start(moq_mux_container_Consumer_legacy_Wire *self, moq_option_mux_container_Read *out, moq_mux_Error **err, moq_mux_container_Consumer_legacy_Wire_read_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Consumer_legacy_Wire_read_poll(moq_mux_container_Consumer_legacy_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Read *out, moq_mux_Error **err); void moq_mux_container_Consumer_legacy_Wire_read_future_free(moq_mux_container_Consumer_legacy_Wire_read_future *future); bool moq_mux_container_Consumer_legacy_Wire_is_skipped(const moq_mux_container_Consumer_legacy_Wire *self, moq_range_u64 groups, moq_status *status); void moq_mux_container_Consumer_legacy_Wire_set_delay(moq_mux_container_Consumer_legacy_Wire *self, moq_track_Delay delay, moq_status *status); void moq_mux_container_Consumer_legacy_Wire_set_playhead(moq_mux_container_Consumer_legacy_Wire *self, moq_mux_sync_Consumer *playhead, moq_status *status); void moq_mux_container_Consumer_loc_Wire_free(moq_mux_container_Consumer_loc_Wire *self); void moq_mux_container_Consumer_loc_Wire_drop(moq_mux_container_Consumer_loc_Wire *self, moq_status *status); -moq_mux_container_Consumer_loc_Wire *moq_mux_container_Consumer_loc_Wire_new(moq_track_Subscriber *track, moq_mux_container_loc_Wire format, moq_status *status); +MOQ_MUST_USE moq_mux_container_Consumer_loc_Wire *moq_mux_container_Consumer_loc_Wire_new(moq_track_Subscriber *track, moq_mux_container_loc_Wire format, moq_status *status); moq_option_clock_Instant moq_mux_container_Consumer_loc_Wire_arrival(const moq_mux_container_Consumer_loc_Wire *self, moq_status *status); moq_option_clock_Instant moq_mux_container_Consumer_loc_Wire_backlog(const moq_mux_container_Consumer_loc_Wire *self, moq_status *status); typedef struct moq_mux_container_Consumer_loc_Wire_read_future moq_mux_container_Consumer_loc_Wire_read_future; -moq_mux_container_Consumer_loc_Wire_read_future *moq_mux_container_Consumer_loc_Wire_read(moq_mux_container_Consumer_loc_Wire *self, moq_status *status); -moq_poll moq_mux_container_Consumer_loc_Wire_read_start(moq_mux_container_Consumer_loc_Wire *self, moq_option_mux_container_Read *out, moq_mux_Error **err, moq_mux_container_Consumer_loc_Wire_read_future **future, moq_status *status); -moq_poll moq_mux_container_Consumer_loc_Wire_read_poll(moq_mux_container_Consumer_loc_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Read *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_Consumer_loc_Wire_read_future *moq_mux_container_Consumer_loc_Wire_read(moq_mux_container_Consumer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Consumer_loc_Wire_read_start(moq_mux_container_Consumer_loc_Wire *self, moq_option_mux_container_Read *out, moq_mux_Error **err, moq_mux_container_Consumer_loc_Wire_read_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Consumer_loc_Wire_read_poll(moq_mux_container_Consumer_loc_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Read *out, moq_mux_Error **err); void moq_mux_container_Consumer_loc_Wire_read_future_free(moq_mux_container_Consumer_loc_Wire_read_future *future); bool moq_mux_container_Consumer_loc_Wire_is_skipped(const moq_mux_container_Consumer_loc_Wire *self, moq_range_u64 groups, moq_status *status); void moq_mux_container_Consumer_loc_Wire_set_delay(moq_mux_container_Consumer_loc_Wire *self, moq_track_Delay delay, moq_status *status); void moq_mux_container_Consumer_loc_Wire_set_playhead(moq_mux_container_Consumer_loc_Wire *self, moq_mux_sync_Consumer *playhead, moq_status *status); void moq_mux_container_GroupConsumer_Container_free(moq_mux_container_GroupConsumer_Container *self); void moq_mux_container_GroupConsumer_Container_drop(moq_mux_container_GroupConsumer_Container *self, moq_status *status); -moq_mux_container_GroupConsumer_Container *moq_mux_container_GroupConsumer_Container_new(moq_group_Consumer *group, moq_mux_catalog_hang_Container *format, moq_status *status); +MOQ_MUST_USE moq_mux_container_GroupConsumer_Container *moq_mux_container_GroupConsumer_Container_new(moq_group_Consumer *group, moq_mux_catalog_hang_Container *format, moq_status *status); uint64_t moq_mux_container_GroupConsumer_Container_start(const moq_mux_container_GroupConsumer_Container *self, moq_status *status); typedef struct moq_mux_container_GroupConsumer_Container_read_future moq_mux_container_GroupConsumer_Container_read_future; -moq_mux_container_GroupConsumer_Container_read_future *moq_mux_container_GroupConsumer_Container_read(moq_mux_container_GroupConsumer_Container *self, moq_status *status); -moq_poll moq_mux_container_GroupConsumer_Container_read_start(moq_mux_container_GroupConsumer_Container *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_GroupConsumer_Container_read_future **future, moq_status *status); -moq_poll moq_mux_container_GroupConsumer_Container_read_poll(moq_mux_container_GroupConsumer_Container_read_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_GroupConsumer_Container_read_future *moq_mux_container_GroupConsumer_Container_read(moq_mux_container_GroupConsumer_Container *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_GroupConsumer_Container_read_start(moq_mux_container_GroupConsumer_Container *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_GroupConsumer_Container_read_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_GroupConsumer_Container_read_poll(moq_mux_container_GroupConsumer_Container_read_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); void moq_mux_container_GroupConsumer_Container_read_future_free(moq_mux_container_GroupConsumer_Container_read_future *future); void moq_mux_container_GroupConsumer_fmp4_Wire_free(moq_mux_container_GroupConsumer_fmp4_Wire *self); void moq_mux_container_GroupConsumer_fmp4_Wire_drop(moq_mux_container_GroupConsumer_fmp4_Wire *self, moq_status *status); -moq_mux_container_GroupConsumer_fmp4_Wire *moq_mux_container_GroupConsumer_fmp4_Wire_new(moq_group_Consumer *group, moq_mux_container_fmp4_Wire *format, moq_status *status); +MOQ_MUST_USE moq_mux_container_GroupConsumer_fmp4_Wire *moq_mux_container_GroupConsumer_fmp4_Wire_new(moq_group_Consumer *group, moq_mux_container_fmp4_Wire *format, moq_status *status); uint64_t moq_mux_container_GroupConsumer_fmp4_Wire_start(const moq_mux_container_GroupConsumer_fmp4_Wire *self, moq_status *status); typedef struct moq_mux_container_GroupConsumer_fmp4_Wire_read_future moq_mux_container_GroupConsumer_fmp4_Wire_read_future; -moq_mux_container_GroupConsumer_fmp4_Wire_read_future *moq_mux_container_GroupConsumer_fmp4_Wire_read(moq_mux_container_GroupConsumer_fmp4_Wire *self, moq_status *status); -moq_poll moq_mux_container_GroupConsumer_fmp4_Wire_read_start(moq_mux_container_GroupConsumer_fmp4_Wire *self, moq_option_mux_container_Frame *out, moq_mux_container_fmp4_Error **err, moq_mux_container_GroupConsumer_fmp4_Wire_read_future **future, moq_status *status); -moq_poll moq_mux_container_GroupConsumer_fmp4_Wire_read_poll(moq_mux_container_GroupConsumer_fmp4_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_container_fmp4_Error **err); +MOQ_MUST_USE moq_mux_container_GroupConsumer_fmp4_Wire_read_future *moq_mux_container_GroupConsumer_fmp4_Wire_read(moq_mux_container_GroupConsumer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_GroupConsumer_fmp4_Wire_read_start(moq_mux_container_GroupConsumer_fmp4_Wire *self, moq_option_mux_container_Frame *out, moq_mux_container_fmp4_Error **err, moq_mux_container_GroupConsumer_fmp4_Wire_read_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_GroupConsumer_fmp4_Wire_read_poll(moq_mux_container_GroupConsumer_fmp4_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_container_fmp4_Error **err); void moq_mux_container_GroupConsumer_fmp4_Wire_read_future_free(moq_mux_container_GroupConsumer_fmp4_Wire_read_future *future); void moq_mux_container_GroupConsumer_legacy_Wire_free(moq_mux_container_GroupConsumer_legacy_Wire *self); void moq_mux_container_GroupConsumer_legacy_Wire_drop(moq_mux_container_GroupConsumer_legacy_Wire *self, moq_status *status); -moq_mux_container_GroupConsumer_legacy_Wire *moq_mux_container_GroupConsumer_legacy_Wire_new(moq_group_Consumer *group, moq_mux_container_legacy_Wire format, moq_status *status); +MOQ_MUST_USE moq_mux_container_GroupConsumer_legacy_Wire *moq_mux_container_GroupConsumer_legacy_Wire_new(moq_group_Consumer *group, moq_mux_container_legacy_Wire format, moq_status *status); uint64_t moq_mux_container_GroupConsumer_legacy_Wire_start(const moq_mux_container_GroupConsumer_legacy_Wire *self, moq_status *status); typedef struct moq_mux_container_GroupConsumer_legacy_Wire_read_future moq_mux_container_GroupConsumer_legacy_Wire_read_future; -moq_mux_container_GroupConsumer_legacy_Wire_read_future *moq_mux_container_GroupConsumer_legacy_Wire_read(moq_mux_container_GroupConsumer_legacy_Wire *self, moq_status *status); -moq_poll moq_mux_container_GroupConsumer_legacy_Wire_read_start(moq_mux_container_GroupConsumer_legacy_Wire *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_GroupConsumer_legacy_Wire_read_future **future, moq_status *status); -moq_poll moq_mux_container_GroupConsumer_legacy_Wire_read_poll(moq_mux_container_GroupConsumer_legacy_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_GroupConsumer_legacy_Wire_read_future *moq_mux_container_GroupConsumer_legacy_Wire_read(moq_mux_container_GroupConsumer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_GroupConsumer_legacy_Wire_read_start(moq_mux_container_GroupConsumer_legacy_Wire *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_GroupConsumer_legacy_Wire_read_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_GroupConsumer_legacy_Wire_read_poll(moq_mux_container_GroupConsumer_legacy_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); void moq_mux_container_GroupConsumer_legacy_Wire_read_future_free(moq_mux_container_GroupConsumer_legacy_Wire_read_future *future); void moq_mux_container_GroupConsumer_loc_Wire_free(moq_mux_container_GroupConsumer_loc_Wire *self); void moq_mux_container_GroupConsumer_loc_Wire_drop(moq_mux_container_GroupConsumer_loc_Wire *self, moq_status *status); -moq_mux_container_GroupConsumer_loc_Wire *moq_mux_container_GroupConsumer_loc_Wire_new(moq_group_Consumer *group, moq_mux_container_loc_Wire format, moq_status *status); +MOQ_MUST_USE moq_mux_container_GroupConsumer_loc_Wire *moq_mux_container_GroupConsumer_loc_Wire_new(moq_group_Consumer *group, moq_mux_container_loc_Wire format, moq_status *status); uint64_t moq_mux_container_GroupConsumer_loc_Wire_start(const moq_mux_container_GroupConsumer_loc_Wire *self, moq_status *status); typedef struct moq_mux_container_GroupConsumer_loc_Wire_read_future moq_mux_container_GroupConsumer_loc_Wire_read_future; -moq_mux_container_GroupConsumer_loc_Wire_read_future *moq_mux_container_GroupConsumer_loc_Wire_read(moq_mux_container_GroupConsumer_loc_Wire *self, moq_status *status); -moq_poll moq_mux_container_GroupConsumer_loc_Wire_read_start(moq_mux_container_GroupConsumer_loc_Wire *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_GroupConsumer_loc_Wire_read_future **future, moq_status *status); -moq_poll moq_mux_container_GroupConsumer_loc_Wire_read_poll(moq_mux_container_GroupConsumer_loc_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_GroupConsumer_loc_Wire_read_future *moq_mux_container_GroupConsumer_loc_Wire_read(moq_mux_container_GroupConsumer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_GroupConsumer_loc_Wire_read_start(moq_mux_container_GroupConsumer_loc_Wire *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_GroupConsumer_loc_Wire_read_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_GroupConsumer_loc_Wire_read_poll(moq_mux_container_GroupConsumer_loc_Wire_read_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); void moq_mux_container_GroupConsumer_loc_Wire_read_future_free(moq_mux_container_GroupConsumer_loc_Wire_read_future *future); void moq_mux_container_Finished_Container_AudioConfig_free(moq_mux_container_Finished_Container_AudioConfig *self); void moq_mux_container_Finished_Container_AudioConfig_drop(moq_mux_container_Finished_Container_AudioConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_Container_AudioConfig_name(const moq_mux_container_Finished_Container_AudioConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_Container_AudioConfig_demand(const moq_mux_container_Finished_Container_AudioConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_Container_AudioConfig_info(const moq_mux_container_Finished_Container_AudioConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_Container_AudioConfig_consume(const moq_mux_container_Finished_Container_AudioConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_AudioConfig_estimate(const moq_mux_container_Finished_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_Container_AudioConfig_name(const moq_mux_container_Finished_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_Container_AudioConfig_demand(const moq_mux_container_Finished_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_Container_AudioConfig_info(const moq_mux_container_Finished_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_Container_AudioConfig_consume(const moq_mux_container_Finished_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_AudioConfig_estimate(const moq_mux_container_Finished_Container_AudioConfig *self, moq_status *status); void moq_mux_container_Finished_Container_AudioConfig_abort(moq_mux_container_Finished_Container_AudioConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_Container_BinaryConfig_free(moq_mux_container_Finished_Container_BinaryConfig *self); void moq_mux_container_Finished_Container_BinaryConfig_drop(moq_mux_container_Finished_Container_BinaryConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_Container_BinaryConfig_name(const moq_mux_container_Finished_Container_BinaryConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_Container_BinaryConfig_demand(const moq_mux_container_Finished_Container_BinaryConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_Container_BinaryConfig_info(const moq_mux_container_Finished_Container_BinaryConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_Container_BinaryConfig_consume(const moq_mux_container_Finished_Container_BinaryConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_BinaryConfig_estimate(const moq_mux_container_Finished_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_Container_BinaryConfig_name(const moq_mux_container_Finished_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_Container_BinaryConfig_demand(const moq_mux_container_Finished_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_Container_BinaryConfig_info(const moq_mux_container_Finished_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_Container_BinaryConfig_consume(const moq_mux_container_Finished_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_BinaryConfig_estimate(const moq_mux_container_Finished_Container_BinaryConfig *self, moq_status *status); void moq_mux_container_Finished_Container_BinaryConfig_abort(moq_mux_container_Finished_Container_BinaryConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_Container_JsonConfig_free(moq_mux_container_Finished_Container_JsonConfig *self); void moq_mux_container_Finished_Container_JsonConfig_drop(moq_mux_container_Finished_Container_JsonConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_Container_JsonConfig_name(const moq_mux_container_Finished_Container_JsonConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_Container_JsonConfig_demand(const moq_mux_container_Finished_Container_JsonConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_Container_JsonConfig_info(const moq_mux_container_Finished_Container_JsonConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_Container_JsonConfig_consume(const moq_mux_container_Finished_Container_JsonConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_JsonConfig_estimate(const moq_mux_container_Finished_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_Container_JsonConfig_name(const moq_mux_container_Finished_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_Container_JsonConfig_demand(const moq_mux_container_Finished_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_Container_JsonConfig_info(const moq_mux_container_Finished_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_Container_JsonConfig_consume(const moq_mux_container_Finished_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_JsonConfig_estimate(const moq_mux_container_Finished_Container_JsonConfig *self, moq_status *status); void moq_mux_container_Finished_Container_JsonConfig_abort(moq_mux_container_Finished_Container_JsonConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_Container_TextConfig_free(moq_mux_container_Finished_Container_TextConfig *self); void moq_mux_container_Finished_Container_TextConfig_drop(moq_mux_container_Finished_Container_TextConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_Container_TextConfig_name(const moq_mux_container_Finished_Container_TextConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_Container_TextConfig_demand(const moq_mux_container_Finished_Container_TextConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_Container_TextConfig_info(const moq_mux_container_Finished_Container_TextConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_Container_TextConfig_consume(const moq_mux_container_Finished_Container_TextConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_TextConfig_estimate(const moq_mux_container_Finished_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_Container_TextConfig_name(const moq_mux_container_Finished_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_Container_TextConfig_demand(const moq_mux_container_Finished_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_Container_TextConfig_info(const moq_mux_container_Finished_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_Container_TextConfig_consume(const moq_mux_container_Finished_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_TextConfig_estimate(const moq_mux_container_Finished_Container_TextConfig *self, moq_status *status); void moq_mux_container_Finished_Container_TextConfig_abort(moq_mux_container_Finished_Container_TextConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_Container_VideoConfig_free(moq_mux_container_Finished_Container_VideoConfig *self); void moq_mux_container_Finished_Container_VideoConfig_drop(moq_mux_container_Finished_Container_VideoConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_Container_VideoConfig_name(const moq_mux_container_Finished_Container_VideoConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_Container_VideoConfig_demand(const moq_mux_container_Finished_Container_VideoConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_Container_VideoConfig_info(const moq_mux_container_Finished_Container_VideoConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_Container_VideoConfig_consume(const moq_mux_container_Finished_Container_VideoConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_VideoConfig_estimate(const moq_mux_container_Finished_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_Container_VideoConfig_name(const moq_mux_container_Finished_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_Container_VideoConfig_demand(const moq_mux_container_Finished_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_Container_VideoConfig_info(const moq_mux_container_Finished_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_Container_VideoConfig_consume(const moq_mux_container_Finished_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_VideoConfig_estimate(const moq_mux_container_Finished_Container_VideoConfig *self, moq_status *status); void moq_mux_container_Finished_Container_VideoConfig_abort(moq_mux_container_Finished_Container_VideoConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_Container_free(moq_mux_container_Finished_Container *self); void moq_mux_container_Finished_Container_drop(moq_mux_container_Finished_Container *self, moq_status *status); -moq_buf moq_mux_container_Finished_Container_name(const moq_mux_container_Finished_Container *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_Container_demand(const moq_mux_container_Finished_Container *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_Container_info(const moq_mux_container_Finished_Container *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_Container_consume(const moq_mux_container_Finished_Container *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_estimate(const moq_mux_container_Finished_Container *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_Container_name(const moq_mux_container_Finished_Container *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_Container_demand(const moq_mux_container_Finished_Container *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_Container_info(const moq_mux_container_Finished_Container *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_Container_consume(const moq_mux_container_Finished_Container *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_Container_estimate(const moq_mux_container_Finished_Container *self, moq_status *status); void moq_mux_container_Finished_Container_abort(moq_mux_container_Finished_Container *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_AudioConfig_free(moq_mux_container_Finished_fmp4_Wire_AudioConfig *self); void moq_mux_container_Finished_fmp4_Wire_AudioConfig_drop(moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_fmp4_Wire_AudioConfig_name(const moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_AudioConfig_demand(const moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_fmp4_Wire_AudioConfig_info(const moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_AudioConfig_consume(const moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_AudioConfig_estimate(const moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_fmp4_Wire_AudioConfig_name(const moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_AudioConfig_demand(const moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_fmp4_Wire_AudioConfig_info(const moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_AudioConfig_consume(const moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_AudioConfig_estimate(const moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_AudioConfig_abort(moq_mux_container_Finished_fmp4_Wire_AudioConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_BinaryConfig_free(moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self); void moq_mux_container_Finished_fmp4_Wire_BinaryConfig_drop(moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_fmp4_Wire_BinaryConfig_name(const moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_BinaryConfig_demand(const moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_fmp4_Wire_BinaryConfig_info(const moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_BinaryConfig_consume(const moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_BinaryConfig_estimate(const moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_fmp4_Wire_BinaryConfig_name(const moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_BinaryConfig_demand(const moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_fmp4_Wire_BinaryConfig_info(const moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_BinaryConfig_consume(const moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_BinaryConfig_estimate(const moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_BinaryConfig_abort(moq_mux_container_Finished_fmp4_Wire_BinaryConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_JsonConfig_free(moq_mux_container_Finished_fmp4_Wire_JsonConfig *self); void moq_mux_container_Finished_fmp4_Wire_JsonConfig_drop(moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_fmp4_Wire_JsonConfig_name(const moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_JsonConfig_demand(const moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_fmp4_Wire_JsonConfig_info(const moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_JsonConfig_consume(const moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_JsonConfig_estimate(const moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_fmp4_Wire_JsonConfig_name(const moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_JsonConfig_demand(const moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_fmp4_Wire_JsonConfig_info(const moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_JsonConfig_consume(const moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_JsonConfig_estimate(const moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_JsonConfig_abort(moq_mux_container_Finished_fmp4_Wire_JsonConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_TextConfig_free(moq_mux_container_Finished_fmp4_Wire_TextConfig *self); void moq_mux_container_Finished_fmp4_Wire_TextConfig_drop(moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_fmp4_Wire_TextConfig_name(const moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_TextConfig_demand(const moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_fmp4_Wire_TextConfig_info(const moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_TextConfig_consume(const moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_TextConfig_estimate(const moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_fmp4_Wire_TextConfig_name(const moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_TextConfig_demand(const moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_fmp4_Wire_TextConfig_info(const moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_TextConfig_consume(const moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_TextConfig_estimate(const moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_TextConfig_abort(moq_mux_container_Finished_fmp4_Wire_TextConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_VideoConfig_free(moq_mux_container_Finished_fmp4_Wire_VideoConfig *self); void moq_mux_container_Finished_fmp4_Wire_VideoConfig_drop(moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_fmp4_Wire_VideoConfig_name(const moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_VideoConfig_demand(const moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_fmp4_Wire_VideoConfig_info(const moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_VideoConfig_consume(const moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_VideoConfig_estimate(const moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_fmp4_Wire_VideoConfig_name(const moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_VideoConfig_demand(const moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_fmp4_Wire_VideoConfig_info(const moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_VideoConfig_consume(const moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_VideoConfig_estimate(const moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_VideoConfig_abort(moq_mux_container_Finished_fmp4_Wire_VideoConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_free(moq_mux_container_Finished_fmp4_Wire *self); void moq_mux_container_Finished_fmp4_Wire_drop(moq_mux_container_Finished_fmp4_Wire *self, moq_status *status); -moq_buf moq_mux_container_Finished_fmp4_Wire_name(const moq_mux_container_Finished_fmp4_Wire *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_demand(const moq_mux_container_Finished_fmp4_Wire *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_fmp4_Wire_info(const moq_mux_container_Finished_fmp4_Wire *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_consume(const moq_mux_container_Finished_fmp4_Wire *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_estimate(const moq_mux_container_Finished_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_fmp4_Wire_name(const moq_mux_container_Finished_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_fmp4_Wire_demand(const moq_mux_container_Finished_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_fmp4_Wire_info(const moq_mux_container_Finished_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_fmp4_Wire_consume(const moq_mux_container_Finished_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_fmp4_Wire_estimate(const moq_mux_container_Finished_fmp4_Wire *self, moq_status *status); void moq_mux_container_Finished_fmp4_Wire_abort(moq_mux_container_Finished_fmp4_Wire *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_legacy_Wire_AudioConfig_free(moq_mux_container_Finished_legacy_Wire_AudioConfig *self); void moq_mux_container_Finished_legacy_Wire_AudioConfig_drop(moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_legacy_Wire_AudioConfig_name(const moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_legacy_Wire_AudioConfig_demand(const moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_legacy_Wire_AudioConfig_info(const moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_AudioConfig_consume(const moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_AudioConfig_estimate(const moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_legacy_Wire_AudioConfig_name(const moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_legacy_Wire_AudioConfig_demand(const moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_legacy_Wire_AudioConfig_info(const moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_AudioConfig_consume(const moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_AudioConfig_estimate(const moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_status *status); void moq_mux_container_Finished_legacy_Wire_AudioConfig_abort(moq_mux_container_Finished_legacy_Wire_AudioConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_legacy_Wire_BinaryConfig_free(moq_mux_container_Finished_legacy_Wire_BinaryConfig *self); void moq_mux_container_Finished_legacy_Wire_BinaryConfig_drop(moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_legacy_Wire_BinaryConfig_name(const moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_legacy_Wire_BinaryConfig_demand(const moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_legacy_Wire_BinaryConfig_info(const moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_BinaryConfig_consume(const moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_BinaryConfig_estimate(const moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_legacy_Wire_BinaryConfig_name(const moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_legacy_Wire_BinaryConfig_demand(const moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_legacy_Wire_BinaryConfig_info(const moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_BinaryConfig_consume(const moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_BinaryConfig_estimate(const moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_status *status); void moq_mux_container_Finished_legacy_Wire_BinaryConfig_abort(moq_mux_container_Finished_legacy_Wire_BinaryConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_legacy_Wire_JsonConfig_free(moq_mux_container_Finished_legacy_Wire_JsonConfig *self); void moq_mux_container_Finished_legacy_Wire_JsonConfig_drop(moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_legacy_Wire_JsonConfig_name(const moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_legacy_Wire_JsonConfig_demand(const moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_legacy_Wire_JsonConfig_info(const moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_JsonConfig_consume(const moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_JsonConfig_estimate(const moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_legacy_Wire_JsonConfig_name(const moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_legacy_Wire_JsonConfig_demand(const moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_legacy_Wire_JsonConfig_info(const moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_JsonConfig_consume(const moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_JsonConfig_estimate(const moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_status *status); void moq_mux_container_Finished_legacy_Wire_JsonConfig_abort(moq_mux_container_Finished_legacy_Wire_JsonConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_legacy_Wire_TextConfig_free(moq_mux_container_Finished_legacy_Wire_TextConfig *self); void moq_mux_container_Finished_legacy_Wire_TextConfig_drop(moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_legacy_Wire_TextConfig_name(const moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_legacy_Wire_TextConfig_demand(const moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_legacy_Wire_TextConfig_info(const moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_TextConfig_consume(const moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_TextConfig_estimate(const moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_legacy_Wire_TextConfig_name(const moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_legacy_Wire_TextConfig_demand(const moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_legacy_Wire_TextConfig_info(const moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_TextConfig_consume(const moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_TextConfig_estimate(const moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_status *status); void moq_mux_container_Finished_legacy_Wire_TextConfig_abort(moq_mux_container_Finished_legacy_Wire_TextConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_legacy_Wire_VideoConfig_free(moq_mux_container_Finished_legacy_Wire_VideoConfig *self); void moq_mux_container_Finished_legacy_Wire_VideoConfig_drop(moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_legacy_Wire_VideoConfig_name(const moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_legacy_Wire_VideoConfig_demand(const moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_legacy_Wire_VideoConfig_info(const moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_VideoConfig_consume(const moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_VideoConfig_estimate(const moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_legacy_Wire_VideoConfig_name(const moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_legacy_Wire_VideoConfig_demand(const moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_legacy_Wire_VideoConfig_info(const moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_VideoConfig_consume(const moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_VideoConfig_estimate(const moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_status *status); void moq_mux_container_Finished_legacy_Wire_VideoConfig_abort(moq_mux_container_Finished_legacy_Wire_VideoConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_legacy_Wire_free(moq_mux_container_Finished_legacy_Wire *self); void moq_mux_container_Finished_legacy_Wire_drop(moq_mux_container_Finished_legacy_Wire *self, moq_status *status); -moq_buf moq_mux_container_Finished_legacy_Wire_name(const moq_mux_container_Finished_legacy_Wire *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_legacy_Wire_demand(const moq_mux_container_Finished_legacy_Wire *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_legacy_Wire_info(const moq_mux_container_Finished_legacy_Wire *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_consume(const moq_mux_container_Finished_legacy_Wire *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_estimate(const moq_mux_container_Finished_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_legacy_Wire_name(const moq_mux_container_Finished_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_legacy_Wire_demand(const moq_mux_container_Finished_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_legacy_Wire_info(const moq_mux_container_Finished_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_legacy_Wire_consume(const moq_mux_container_Finished_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_legacy_Wire_estimate(const moq_mux_container_Finished_legacy_Wire *self, moq_status *status); void moq_mux_container_Finished_legacy_Wire_abort(moq_mux_container_Finished_legacy_Wire *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_loc_Wire_AudioConfig_free(moq_mux_container_Finished_loc_Wire_AudioConfig *self); void moq_mux_container_Finished_loc_Wire_AudioConfig_drop(moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_loc_Wire_AudioConfig_name(const moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_loc_Wire_AudioConfig_demand(const moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_loc_Wire_AudioConfig_info(const moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_AudioConfig_consume(const moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_AudioConfig_estimate(const moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_loc_Wire_AudioConfig_name(const moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_loc_Wire_AudioConfig_demand(const moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_loc_Wire_AudioConfig_info(const moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_AudioConfig_consume(const moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_AudioConfig_estimate(const moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_status *status); void moq_mux_container_Finished_loc_Wire_AudioConfig_abort(moq_mux_container_Finished_loc_Wire_AudioConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_loc_Wire_BinaryConfig_free(moq_mux_container_Finished_loc_Wire_BinaryConfig *self); void moq_mux_container_Finished_loc_Wire_BinaryConfig_drop(moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_loc_Wire_BinaryConfig_name(const moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_loc_Wire_BinaryConfig_demand(const moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_loc_Wire_BinaryConfig_info(const moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_BinaryConfig_consume(const moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_BinaryConfig_estimate(const moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_loc_Wire_BinaryConfig_name(const moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_loc_Wire_BinaryConfig_demand(const moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_loc_Wire_BinaryConfig_info(const moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_BinaryConfig_consume(const moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_BinaryConfig_estimate(const moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_status *status); void moq_mux_container_Finished_loc_Wire_BinaryConfig_abort(moq_mux_container_Finished_loc_Wire_BinaryConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_loc_Wire_JsonConfig_free(moq_mux_container_Finished_loc_Wire_JsonConfig *self); void moq_mux_container_Finished_loc_Wire_JsonConfig_drop(moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_loc_Wire_JsonConfig_name(const moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_loc_Wire_JsonConfig_demand(const moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_loc_Wire_JsonConfig_info(const moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_JsonConfig_consume(const moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_JsonConfig_estimate(const moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_loc_Wire_JsonConfig_name(const moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_loc_Wire_JsonConfig_demand(const moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_loc_Wire_JsonConfig_info(const moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_JsonConfig_consume(const moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_JsonConfig_estimate(const moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_status *status); void moq_mux_container_Finished_loc_Wire_JsonConfig_abort(moq_mux_container_Finished_loc_Wire_JsonConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_loc_Wire_TextConfig_free(moq_mux_container_Finished_loc_Wire_TextConfig *self); void moq_mux_container_Finished_loc_Wire_TextConfig_drop(moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_loc_Wire_TextConfig_name(const moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_loc_Wire_TextConfig_demand(const moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_loc_Wire_TextConfig_info(const moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_TextConfig_consume(const moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_TextConfig_estimate(const moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_loc_Wire_TextConfig_name(const moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_loc_Wire_TextConfig_demand(const moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_loc_Wire_TextConfig_info(const moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_TextConfig_consume(const moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_TextConfig_estimate(const moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_status *status); void moq_mux_container_Finished_loc_Wire_TextConfig_abort(moq_mux_container_Finished_loc_Wire_TextConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_loc_Wire_VideoConfig_free(moq_mux_container_Finished_loc_Wire_VideoConfig *self); void moq_mux_container_Finished_loc_Wire_VideoConfig_drop(moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_status *status); -moq_buf moq_mux_container_Finished_loc_Wire_VideoConfig_name(const moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_loc_Wire_VideoConfig_demand(const moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_loc_Wire_VideoConfig_info(const moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_VideoConfig_consume(const moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_VideoConfig_estimate(const moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_loc_Wire_VideoConfig_name(const moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_loc_Wire_VideoConfig_demand(const moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_loc_Wire_VideoConfig_info(const moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_VideoConfig_consume(const moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_VideoConfig_estimate(const moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_status *status); void moq_mux_container_Finished_loc_Wire_VideoConfig_abort(moq_mux_container_Finished_loc_Wire_VideoConfig *self, moq_Error *err_, moq_status *status); void moq_mux_container_Finished_loc_Wire_free(moq_mux_container_Finished_loc_Wire *self); void moq_mux_container_Finished_loc_Wire_drop(moq_mux_container_Finished_loc_Wire *self, moq_status *status); -moq_buf moq_mux_container_Finished_loc_Wire_name(const moq_mux_container_Finished_loc_Wire *self, moq_status *status); -moq_track_Demand *moq_mux_container_Finished_loc_Wire_demand(const moq_mux_container_Finished_loc_Wire *self, moq_status *status); -moq_track_Info *moq_mux_container_Finished_loc_Wire_info(const moq_mux_container_Finished_loc_Wire *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_consume(const moq_mux_container_Finished_loc_Wire *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_estimate(const moq_mux_container_Finished_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Finished_loc_Wire_name(const moq_mux_container_Finished_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Finished_loc_Wire_demand(const moq_mux_container_Finished_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Finished_loc_Wire_info(const moq_mux_container_Finished_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Finished_loc_Wire_consume(const moq_mux_container_Finished_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Finished_loc_Wire_estimate(const moq_mux_container_Finished_loc_Wire *self, moq_status *status); void moq_mux_container_Finished_loc_Wire_abort(moq_mux_container_Finished_loc_Wire *self, moq_Error *err_, moq_status *status); void moq_mux_container_Guard_unit_free(moq_mux_container_Guard_unit *self); void moq_mux_container_Guard_unit_drop(moq_mux_container_Guard_unit *self, moq_status *status); -bool moq_mux_container_Guard_unit_commit(moq_mux_container_Guard_unit *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Guard_unit_commit(moq_mux_container_Guard_unit *self, moq_mux_Error **err, moq_status *status); void moq_mux_container_Guard_AudioConfig_free(moq_mux_container_Guard_AudioConfig *self); void moq_mux_container_Guard_AudioConfig_drop(moq_mux_container_Guard_AudioConfig *self, moq_status *status); -bool moq_mux_container_Guard_AudioConfig_commit(moq_mux_container_Guard_AudioConfig *self, moq_mux_Error **err, moq_status *status); -moq_path_Relative *moq_mux_container_Guard_AudioConfig_broadcast_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Guard_AudioConfig_commit(moq_mux_container_Guard_AudioConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_mux_container_Guard_AudioConfig_broadcast_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_broadcast_set(moq_mux_container_Guard_AudioConfig *self, moq_path_Relative *value, moq_status *status); -moq_buf moq_mux_container_Guard_AudioConfig_track_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_AudioConfig_track_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_track_set(moq_mux_container_Guard_AudioConfig *self, moq_buf value, moq_status *status); -moq_Instance *moq_mux_container_Guard_AudioConfig_instance_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_mux_container_Guard_AudioConfig_instance_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_instance_set(moq_mux_container_Guard_AudioConfig *self, moq_Instance *value, moq_status *status); -moq_buf moq_mux_container_Guard_AudioConfig_label_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_AudioConfig_label_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_label_set(moq_mux_container_Guard_AudioConfig *self, moq_buf value, moq_status *status); -moq_hang_catalog_AudioCodec moq_mux_container_Guard_AudioConfig_codec_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_AudioCodec moq_mux_container_Guard_AudioConfig_codec_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_codec_set(moq_mux_container_Guard_AudioConfig *self, moq_hang_catalog_AudioCodec value, moq_status *status); uint32_t moq_mux_container_Guard_AudioConfig_sample_rate_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_sample_rate_set(moq_mux_container_Guard_AudioConfig *self, uint32_t value, moq_status *status); uint32_t moq_mux_container_Guard_AudioConfig_channel_count_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_channel_count_set(moq_mux_container_Guard_AudioConfig *self, uint32_t value, moq_status *status); -moq_option_hang_catalog_AudioLayout moq_mux_container_Guard_AudioConfig_layout_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_option_hang_catalog_AudioLayout moq_mux_container_Guard_AudioConfig_layout_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_layout_set(moq_mux_container_Guard_AudioConfig *self, moq_option_hang_catalog_AudioLayout value, moq_status *status); moq_option_u64 moq_mux_container_Guard_AudioConfig_bitrate_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_bitrate_set(moq_mux_container_Guard_AudioConfig *self, moq_option_u64 value, moq_status *status); bool moq_mux_container_Guard_AudioConfig_enabled_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_enabled_set(moq_mux_container_Guard_AudioConfig *self, bool value, moq_status *status); -moq_buf moq_mux_container_Guard_AudioConfig_description_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_AudioConfig_description_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_description_set(moq_mux_container_Guard_AudioConfig *self, moq_buf value, moq_status *status); -moq_hang_catalog_Container *moq_mux_container_Guard_AudioConfig_container_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Container *moq_mux_container_Guard_AudioConfig_container_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_container_set(moq_mux_container_Guard_AudioConfig *self, moq_hang_catalog_Container *value, moq_status *status); moq_option_duration moq_mux_container_Guard_AudioConfig_jitter_get(const moq_mux_container_Guard_AudioConfig *self, moq_status *status); void moq_mux_container_Guard_AudioConfig_jitter_set(moq_mux_container_Guard_AudioConfig *self, moq_option_duration value, moq_status *status); @@ -6123,16 +6133,16 @@ void moq_mux_container_Guard_AudioConfig_delay_set(moq_mux_container_Guard_Audio bool moq_mux_container_Guard_AudioConfig_same_identity(const moq_mux_container_Guard_AudioConfig *self, const moq_hang_catalog_AudioConfig *other, moq_status *status); void moq_mux_container_Guard_BinaryConfig_free(moq_mux_container_Guard_BinaryConfig *self); void moq_mux_container_Guard_BinaryConfig_drop(moq_mux_container_Guard_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Guard_BinaryConfig_commit(moq_mux_container_Guard_BinaryConfig *self, moq_mux_Error **err, moq_status *status); -moq_path_Relative *moq_mux_container_Guard_BinaryConfig_broadcast_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Guard_BinaryConfig_commit(moq_mux_container_Guard_BinaryConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_mux_container_Guard_BinaryConfig_broadcast_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); void moq_mux_container_Guard_BinaryConfig_broadcast_set(moq_mux_container_Guard_BinaryConfig *self, moq_path_Relative *value, moq_status *status); -moq_buf moq_mux_container_Guard_BinaryConfig_track_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_BinaryConfig_track_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); void moq_mux_container_Guard_BinaryConfig_track_set(moq_mux_container_Guard_BinaryConfig *self, moq_buf value, moq_status *status); -moq_Instance *moq_mux_container_Guard_BinaryConfig_instance_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_mux_container_Guard_BinaryConfig_instance_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); void moq_mux_container_Guard_BinaryConfig_instance_set(moq_mux_container_Guard_BinaryConfig *self, moq_Instance *value, moq_status *status); -moq_hang_catalog_Mode moq_mux_container_Guard_BinaryConfig_mode_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Mode moq_mux_container_Guard_BinaryConfig_mode_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); void moq_mux_container_Guard_BinaryConfig_mode_set(moq_mux_container_Guard_BinaryConfig *self, moq_hang_catalog_Mode value, moq_status *status); -moq_buf moq_mux_container_Guard_BinaryConfig_mime_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_BinaryConfig_mime_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); void moq_mux_container_Guard_BinaryConfig_mime_set(moq_mux_container_Guard_BinaryConfig *self, moq_buf value, moq_status *status); moq_option_u64 moq_mux_container_Guard_BinaryConfig_bitrate_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); void moq_mux_container_Guard_BinaryConfig_bitrate_set(moq_mux_container_Guard_BinaryConfig *self, moq_option_u64 value, moq_status *status); @@ -6140,20 +6150,20 @@ moq_option_duration moq_mux_container_Guard_BinaryConfig_jitter_get(const moq_mu void moq_mux_container_Guard_BinaryConfig_jitter_set(moq_mux_container_Guard_BinaryConfig *self, moq_option_duration value, moq_status *status); moq_option_duration moq_mux_container_Guard_BinaryConfig_delay_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); void moq_mux_container_Guard_BinaryConfig_delay_set(moq_mux_container_Guard_BinaryConfig *self, moq_option_duration value, moq_status *status); -moq_vec_tuple_string_Json moq_mux_container_Guard_BinaryConfig_extra_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_Json moq_mux_container_Guard_BinaryConfig_extra_get(const moq_mux_container_Guard_BinaryConfig *self, moq_status *status); void moq_mux_container_Guard_BinaryConfig_extra_set(moq_mux_container_Guard_BinaryConfig *self, moq_vec_tuple_string_Json value, moq_status *status); void moq_mux_container_Guard_JsonConfig_free(moq_mux_container_Guard_JsonConfig *self); void moq_mux_container_Guard_JsonConfig_drop(moq_mux_container_Guard_JsonConfig *self, moq_status *status); -bool moq_mux_container_Guard_JsonConfig_commit(moq_mux_container_Guard_JsonConfig *self, moq_mux_Error **err, moq_status *status); -moq_path_Relative *moq_mux_container_Guard_JsonConfig_broadcast_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Guard_JsonConfig_commit(moq_mux_container_Guard_JsonConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_mux_container_Guard_JsonConfig_broadcast_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); void moq_mux_container_Guard_JsonConfig_broadcast_set(moq_mux_container_Guard_JsonConfig *self, moq_path_Relative *value, moq_status *status); -moq_buf moq_mux_container_Guard_JsonConfig_track_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_JsonConfig_track_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); void moq_mux_container_Guard_JsonConfig_track_set(moq_mux_container_Guard_JsonConfig *self, moq_buf value, moq_status *status); -moq_Instance *moq_mux_container_Guard_JsonConfig_instance_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_mux_container_Guard_JsonConfig_instance_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); void moq_mux_container_Guard_JsonConfig_instance_set(moq_mux_container_Guard_JsonConfig *self, moq_Instance *value, moq_status *status); -moq_hang_catalog_Mode moq_mux_container_Guard_JsonConfig_mode_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Mode moq_mux_container_Guard_JsonConfig_mode_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); void moq_mux_container_Guard_JsonConfig_mode_set(moq_mux_container_Guard_JsonConfig *self, moq_hang_catalog_Mode value, moq_status *status); -moq_buf moq_mux_container_Guard_JsonConfig_schema_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_JsonConfig_schema_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); void moq_mux_container_Guard_JsonConfig_schema_set(moq_mux_container_Guard_JsonConfig *self, moq_buf value, moq_status *status); moq_option_u64 moq_mux_container_Guard_JsonConfig_bitrate_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); void moq_mux_container_Guard_JsonConfig_bitrate_set(moq_mux_container_Guard_JsonConfig *self, moq_option_u64 value, moq_status *status); @@ -6161,26 +6171,26 @@ moq_option_duration moq_mux_container_Guard_JsonConfig_jitter_get(const moq_mux_ void moq_mux_container_Guard_JsonConfig_jitter_set(moq_mux_container_Guard_JsonConfig *self, moq_option_duration value, moq_status *status); moq_option_duration moq_mux_container_Guard_JsonConfig_delay_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); void moq_mux_container_Guard_JsonConfig_delay_set(moq_mux_container_Guard_JsonConfig *self, moq_option_duration value, moq_status *status); -moq_vec_tuple_string_Json moq_mux_container_Guard_JsonConfig_extra_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_Json moq_mux_container_Guard_JsonConfig_extra_get(const moq_mux_container_Guard_JsonConfig *self, moq_status *status); void moq_mux_container_Guard_JsonConfig_extra_set(moq_mux_container_Guard_JsonConfig *self, moq_vec_tuple_string_Json value, moq_status *status); void moq_mux_container_Guard_TextConfig_free(moq_mux_container_Guard_TextConfig *self); void moq_mux_container_Guard_TextConfig_drop(moq_mux_container_Guard_TextConfig *self, moq_status *status); -bool moq_mux_container_Guard_TextConfig_commit(moq_mux_container_Guard_TextConfig *self, moq_mux_Error **err, moq_status *status); -moq_path_Relative *moq_mux_container_Guard_TextConfig_broadcast_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Guard_TextConfig_commit(moq_mux_container_Guard_TextConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_mux_container_Guard_TextConfig_broadcast_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); void moq_mux_container_Guard_TextConfig_broadcast_set(moq_mux_container_Guard_TextConfig *self, moq_path_Relative *value, moq_status *status); -moq_buf moq_mux_container_Guard_TextConfig_track_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_TextConfig_track_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); void moq_mux_container_Guard_TextConfig_track_set(moq_mux_container_Guard_TextConfig *self, moq_buf value, moq_status *status); -moq_Instance *moq_mux_container_Guard_TextConfig_instance_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_mux_container_Guard_TextConfig_instance_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); void moq_mux_container_Guard_TextConfig_instance_set(moq_mux_container_Guard_TextConfig *self, moq_Instance *value, moq_status *status); -moq_hang_catalog_TextFormat moq_mux_container_Guard_TextConfig_format_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_TextFormat moq_mux_container_Guard_TextConfig_format_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); void moq_mux_container_Guard_TextConfig_format_set(moq_mux_container_Guard_TextConfig *self, moq_hang_catalog_TextFormat value, moq_status *status); -moq_hang_catalog_TextRole moq_mux_container_Guard_TextConfig_role_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_TextRole moq_mux_container_Guard_TextConfig_role_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); void moq_mux_container_Guard_TextConfig_role_set(moq_mux_container_Guard_TextConfig *self, moq_hang_catalog_TextRole value, moq_status *status); -moq_buf moq_mux_container_Guard_TextConfig_lang_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_TextConfig_lang_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); void moq_mux_container_Guard_TextConfig_lang_set(moq_mux_container_Guard_TextConfig *self, moq_buf value, moq_status *status); -moq_buf moq_mux_container_Guard_TextConfig_label_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_TextConfig_label_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); void moq_mux_container_Guard_TextConfig_label_set(moq_mux_container_Guard_TextConfig *self, moq_buf value, moq_status *status); -moq_hang_catalog_Container *moq_mux_container_Guard_TextConfig_container_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Container *moq_mux_container_Guard_TextConfig_container_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); void moq_mux_container_Guard_TextConfig_container_set(moq_mux_container_Guard_TextConfig *self, moq_hang_catalog_Container *value, moq_status *status); moq_option_duration moq_mux_container_Guard_TextConfig_jitter_get(const moq_mux_container_Guard_TextConfig *self, moq_status *status); void moq_mux_container_Guard_TextConfig_jitter_set(moq_mux_container_Guard_TextConfig *self, moq_option_duration value, moq_status *status); @@ -6188,18 +6198,18 @@ moq_option_duration moq_mux_container_Guard_TextConfig_delay_get(const moq_mux_c void moq_mux_container_Guard_TextConfig_delay_set(moq_mux_container_Guard_TextConfig *self, moq_option_duration value, moq_status *status); void moq_mux_container_Guard_VideoConfig_free(moq_mux_container_Guard_VideoConfig *self); void moq_mux_container_Guard_VideoConfig_drop(moq_mux_container_Guard_VideoConfig *self, moq_status *status); -bool moq_mux_container_Guard_VideoConfig_commit(moq_mux_container_Guard_VideoConfig *self, moq_mux_Error **err, moq_status *status); -moq_path_Relative *moq_mux_container_Guard_VideoConfig_broadcast_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Guard_VideoConfig_commit(moq_mux_container_Guard_VideoConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_path_Relative *moq_mux_container_Guard_VideoConfig_broadcast_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_broadcast_set(moq_mux_container_Guard_VideoConfig *self, moq_path_Relative *value, moq_status *status); -moq_buf moq_mux_container_Guard_VideoConfig_track_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_VideoConfig_track_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_track_set(moq_mux_container_Guard_VideoConfig *self, moq_buf value, moq_status *status); -moq_Instance *moq_mux_container_Guard_VideoConfig_instance_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_mux_container_Guard_VideoConfig_instance_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_instance_set(moq_mux_container_Guard_VideoConfig *self, moq_Instance *value, moq_status *status); -moq_buf moq_mux_container_Guard_VideoConfig_label_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_VideoConfig_label_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_label_set(moq_mux_container_Guard_VideoConfig *self, moq_buf value, moq_status *status); -moq_hang_catalog_VideoCodec moq_mux_container_Guard_VideoConfig_codec_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_VideoCodec moq_mux_container_Guard_VideoConfig_codec_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_codec_set(moq_mux_container_Guard_VideoConfig *self, moq_hang_catalog_VideoCodec value, moq_status *status); -moq_buf moq_mux_container_Guard_VideoConfig_description_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Guard_VideoConfig_description_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_description_set(moq_mux_container_Guard_VideoConfig *self, moq_buf value, moq_status *status); moq_option_u32 moq_mux_container_Guard_VideoConfig_coded_width_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_coded_width_set(moq_mux_container_Guard_VideoConfig *self, moq_option_u32 value, moq_status *status); @@ -6209,11 +6219,11 @@ moq_option_u32 moq_mux_container_Guard_VideoConfig_display_aspect_width_get(cons void moq_mux_container_Guard_VideoConfig_display_aspect_width_set(moq_mux_container_Guard_VideoConfig *self, moq_option_u32 value, moq_status *status); moq_option_u32 moq_mux_container_Guard_VideoConfig_display_aspect_height_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_display_aspect_height_set(moq_mux_container_Guard_VideoConfig *self, moq_option_u32 value, moq_status *status); -moq_hang_catalog_Color *moq_mux_container_Guard_VideoConfig_color_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Color *moq_mux_container_Guard_VideoConfig_color_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_color_set(moq_mux_container_Guard_VideoConfig *self, moq_hang_catalog_Color *value, moq_status *status); -moq_hang_catalog_Projection *moq_mux_container_Guard_VideoConfig_projection_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Projection *moq_mux_container_Guard_VideoConfig_projection_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_projection_set(moq_mux_container_Guard_VideoConfig *self, moq_hang_catalog_Projection *value, moq_status *status); -moq_option_hang_catalog_Stereo moq_mux_container_Guard_VideoConfig_stereo_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_option_hang_catalog_Stereo moq_mux_container_Guard_VideoConfig_stereo_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_stereo_set(moq_mux_container_Guard_VideoConfig *self, moq_option_hang_catalog_Stereo value, moq_status *status); bool moq_mux_container_Guard_VideoConfig_interlaced_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_interlaced_set(moq_mux_container_Guard_VideoConfig *self, bool value, moq_status *status); @@ -6229,7 +6239,7 @@ moq_option_u8 moq_mux_container_Guard_VideoConfig_reorder_get(const moq_mux_cont void moq_mux_container_Guard_VideoConfig_reorder_set(moq_mux_container_Guard_VideoConfig *self, moq_option_u8 value, moq_status *status); moq_option_bool moq_mux_container_Guard_VideoConfig_optimize_for_latency_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_optimize_for_latency_set(moq_mux_container_Guard_VideoConfig *self, moq_option_bool value, moq_status *status); -moq_hang_catalog_Container *moq_mux_container_Guard_VideoConfig_container_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Container *moq_mux_container_Guard_VideoConfig_container_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_container_set(moq_mux_container_Guard_VideoConfig *self, moq_hang_catalog_Container *value, moq_status *status); moq_option_duration moq_mux_container_Guard_VideoConfig_jitter_get(const moq_mux_container_Guard_VideoConfig *self, moq_status *status); void moq_mux_container_Guard_VideoConfig_jitter_set(moq_mux_container_Guard_VideoConfig *self, moq_option_duration value, moq_status *status); @@ -6238,1291 +6248,1291 @@ void moq_mux_container_Guard_VideoConfig_delay_set(moq_mux_container_Guard_Video bool moq_mux_container_Guard_VideoConfig_same_identity(const moq_mux_container_Guard_VideoConfig *self, const moq_hang_catalog_VideoConfig *other, moq_status *status); void moq_mux_container_Producer_Container_AudioConfig_free(moq_mux_container_Producer_Container_AudioConfig *self); void moq_mux_container_Producer_Container_AudioConfig_drop(moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_set(moq_mux_container_Producer_Container_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_set_bitrate(moq_mux_container_Producer_Container_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_modify(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_timestamp(const moq_mux_container_Producer_Container_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_Container_AudioConfig_name(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_Container_AudioConfig_demand(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_AudioConfig_estimate(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_set(moq_mux_container_Producer_Container_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_set_bitrate(moq_mux_container_Producer_Container_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_modify(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_timestamp(const moq_mux_container_Producer_Container_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_Container_AudioConfig_name(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_Container_AudioConfig_demand(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_AudioConfig_estimate(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); void moq_mux_container_Producer_Container_AudioConfig_reorder(moq_mux_container_Producer_Container_AudioConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_Container_AudioConfig_history(moq_mux_container_Producer_Container_AudioConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_AudioConfig_needs_keyframe(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -moq_mux_container_Producer_Container_AudioConfig *moq_mux_container_Producer_Container_AudioConfig_with_buffer(moq_mux_container_Producer_Container_AudioConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_Container_AudioConfig *moq_mux_container_Producer_Container_AudioConfig_with_bandwidth(moq_mux_container_Producer_Container_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container_AudioConfig *moq_mux_container_Producer_Container_AudioConfig_with_buffer(moq_mux_container_Producer_Container_AudioConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container_AudioConfig *moq_mux_container_Producer_Container_AudioConfig_with_bandwidth(moq_mux_container_Producer_Container_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_AudioConfig_report_skipped(const moq_mux_container_Producer_Container_AudioConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_AudioConfig_report_bitrate(const moq_mux_container_Producer_Container_AudioConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_Container_AudioConfig_track(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_Container_AudioConfig_track(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_Container_AudioConfig_live_edge(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_write(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_cut(moq_mux_container_Producer_Container_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_seek(moq_mux_container_Producer_Container_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_discontinuity(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_finish(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_fail(moq_mux_container_Producer_Container_AudioConfig *self, moq_Error *err_, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_write(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_cut(moq_mux_container_Producer_Container_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_seek(moq_mux_container_Producer_Container_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_discontinuity(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_finish(moq_mux_container_Producer_Container_AudioConfig *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_fail(moq_mux_container_Producer_Container_AudioConfig *self, moq_Error *err_, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_Container_AudioConfig_abort(moq_mux_container_Producer_Container_AudioConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_abort_unwanted(moq_mux_container_Producer_Container_AudioConfig *self, moq_Error *err_, moq_mux_container_Producer_Container_AudioConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_AudioConfig_consume(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_Container_AudioConfig_broadcast(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_Container_AudioConfig_info(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_create_group(const moq_mux_container_Producer_Container_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_AudioConfig_append_group(const moq_mux_container_Producer_Container_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_abort_unwanted(moq_mux_container_Producer_Container_AudioConfig *self, moq_Error *err_, moq_mux_container_Producer_Container_AudioConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_AudioConfig_consume(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_Container_AudioConfig_broadcast(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_Container_AudioConfig_info(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_create_group(const moq_mux_container_Producer_Container_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_AudioConfig_append_group(const moq_mux_container_Producer_Container_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_AudioConfig_skip_groups(const moq_mux_container_Producer_Container_AudioConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_AudioConfig_finished(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_AudioConfig_closed_future moq_mux_container_Producer_Container_AudioConfig_closed_future; -moq_mux_container_Producer_Container_AudioConfig_closed_future *moq_mux_container_Producer_Container_AudioConfig_closed(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_Container_AudioConfig_closed_start(const moq_mux_container_Producer_Container_AudioConfig *self, moq_Error **err, moq_mux_container_Producer_Container_AudioConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_Container_AudioConfig_closed_poll(moq_mux_container_Producer_Container_AudioConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_Container_AudioConfig_closed_future *moq_mux_container_Producer_Container_AudioConfig_closed(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_AudioConfig_closed_start(const moq_mux_container_Producer_Container_AudioConfig *self, moq_Error **err, moq_mux_container_Producer_Container_AudioConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_AudioConfig_closed_poll(moq_mux_container_Producer_Container_AudioConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_Container_AudioConfig_closed_future_free(moq_mux_container_Producer_Container_AudioConfig_closed_future *future); bool moq_mux_container_Producer_Container_AudioConfig_is_closed(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_AudioConfig_largest(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_AudioConfig_is_clone(const moq_mux_container_Producer_Container_AudioConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_Container_AudioConfig_abort_handle(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_AudioConfig_subscribe(const moq_mux_container_Producer_Container_AudioConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_Container_AudioConfig_subscription(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_Container_AudioConfig_requests(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_Container_AudioConfig_abort_handle(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_AudioConfig_subscribe(const moq_mux_container_Producer_Container_AudioConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_Container_AudioConfig_subscription(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_Container_AudioConfig_requests(const moq_mux_container_Producer_Container_AudioConfig *self, moq_status *status); void moq_mux_container_Producer_Container_BinaryConfig_free(moq_mux_container_Producer_Container_BinaryConfig *self); void moq_mux_container_Producer_Container_BinaryConfig_drop(moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_set(moq_mux_container_Producer_Container_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_set_bitrate(moq_mux_container_Producer_Container_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_modify(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_timestamp(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_Container_BinaryConfig_name(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_Container_BinaryConfig_demand(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_BinaryConfig_estimate(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_set(moq_mux_container_Producer_Container_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_set_bitrate(moq_mux_container_Producer_Container_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_modify(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_timestamp(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_Container_BinaryConfig_name(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_Container_BinaryConfig_demand(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_BinaryConfig_estimate(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); void moq_mux_container_Producer_Container_BinaryConfig_reorder(moq_mux_container_Producer_Container_BinaryConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_Container_BinaryConfig_history(moq_mux_container_Producer_Container_BinaryConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_BinaryConfig_needs_keyframe(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -moq_mux_container_Producer_Container_BinaryConfig *moq_mux_container_Producer_Container_BinaryConfig_with_buffer(moq_mux_container_Producer_Container_BinaryConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_Container_BinaryConfig *moq_mux_container_Producer_Container_BinaryConfig_with_bandwidth(moq_mux_container_Producer_Container_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container_BinaryConfig *moq_mux_container_Producer_Container_BinaryConfig_with_buffer(moq_mux_container_Producer_Container_BinaryConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container_BinaryConfig *moq_mux_container_Producer_Container_BinaryConfig_with_bandwidth(moq_mux_container_Producer_Container_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_BinaryConfig_report_skipped(const moq_mux_container_Producer_Container_BinaryConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_BinaryConfig_report_bitrate(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_Container_BinaryConfig_track(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_Container_BinaryConfig_track(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_Container_BinaryConfig_live_edge(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_write(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_cut(moq_mux_container_Producer_Container_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_seek(moq_mux_container_Producer_Container_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_discontinuity(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_finish(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_container_Finished_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_fail(moq_mux_container_Producer_Container_BinaryConfig *self, moq_Error *err_, moq_mux_container_Finished_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_write(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_cut(moq_mux_container_Producer_Container_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_seek(moq_mux_container_Producer_Container_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_discontinuity(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_finish(moq_mux_container_Producer_Container_BinaryConfig *self, moq_mux_container_Finished_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_fail(moq_mux_container_Producer_Container_BinaryConfig *self, moq_Error *err_, moq_mux_container_Finished_Container_BinaryConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_Container_BinaryConfig_abort(moq_mux_container_Producer_Container_BinaryConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_abort_unwanted(moq_mux_container_Producer_Container_BinaryConfig *self, moq_Error *err_, moq_mux_container_Producer_Container_BinaryConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_BinaryConfig_consume(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_Container_BinaryConfig_broadcast(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_Container_BinaryConfig_info(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_create_group(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_BinaryConfig_append_group(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_abort_unwanted(moq_mux_container_Producer_Container_BinaryConfig *self, moq_Error *err_, moq_mux_container_Producer_Container_BinaryConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_BinaryConfig_consume(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_Container_BinaryConfig_broadcast(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_Container_BinaryConfig_info(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_create_group(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_BinaryConfig_append_group(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_BinaryConfig_skip_groups(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_BinaryConfig_finished(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_BinaryConfig_closed_future moq_mux_container_Producer_Container_BinaryConfig_closed_future; -moq_mux_container_Producer_Container_BinaryConfig_closed_future *moq_mux_container_Producer_Container_BinaryConfig_closed(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_Container_BinaryConfig_closed_start(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_Error **err, moq_mux_container_Producer_Container_BinaryConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_Container_BinaryConfig_closed_poll(moq_mux_container_Producer_Container_BinaryConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_Container_BinaryConfig_closed_future *moq_mux_container_Producer_Container_BinaryConfig_closed(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_BinaryConfig_closed_start(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_Error **err, moq_mux_container_Producer_Container_BinaryConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_BinaryConfig_closed_poll(moq_mux_container_Producer_Container_BinaryConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_Container_BinaryConfig_closed_future_free(moq_mux_container_Producer_Container_BinaryConfig_closed_future *future); bool moq_mux_container_Producer_Container_BinaryConfig_is_closed(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_BinaryConfig_largest(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_BinaryConfig_is_clone(const moq_mux_container_Producer_Container_BinaryConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_Container_BinaryConfig_abort_handle(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_BinaryConfig_subscribe(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_Container_BinaryConfig_subscription(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_Container_BinaryConfig_requests(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_Container_BinaryConfig_abort_handle(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_BinaryConfig_subscribe(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_Container_BinaryConfig_subscription(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_Container_BinaryConfig_requests(const moq_mux_container_Producer_Container_BinaryConfig *self, moq_status *status); void moq_mux_container_Producer_Container_JsonConfig_free(moq_mux_container_Producer_Container_JsonConfig *self); void moq_mux_container_Producer_Container_JsonConfig_drop(moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_set(moq_mux_container_Producer_Container_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_set_bitrate(moq_mux_container_Producer_Container_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_modify(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_timestamp(const moq_mux_container_Producer_Container_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_Container_JsonConfig_name(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_Container_JsonConfig_demand(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_JsonConfig_estimate(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_set(moq_mux_container_Producer_Container_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_set_bitrate(moq_mux_container_Producer_Container_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_modify(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_timestamp(const moq_mux_container_Producer_Container_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_Container_JsonConfig_name(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_Container_JsonConfig_demand(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_JsonConfig_estimate(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); void moq_mux_container_Producer_Container_JsonConfig_reorder(moq_mux_container_Producer_Container_JsonConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_Container_JsonConfig_history(moq_mux_container_Producer_Container_JsonConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_JsonConfig_needs_keyframe(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -moq_mux_container_Producer_Container_JsonConfig *moq_mux_container_Producer_Container_JsonConfig_with_buffer(moq_mux_container_Producer_Container_JsonConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_Container_JsonConfig *moq_mux_container_Producer_Container_JsonConfig_with_bandwidth(moq_mux_container_Producer_Container_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container_JsonConfig *moq_mux_container_Producer_Container_JsonConfig_with_buffer(moq_mux_container_Producer_Container_JsonConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container_JsonConfig *moq_mux_container_Producer_Container_JsonConfig_with_bandwidth(moq_mux_container_Producer_Container_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_JsonConfig_report_skipped(const moq_mux_container_Producer_Container_JsonConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_JsonConfig_report_bitrate(const moq_mux_container_Producer_Container_JsonConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_Container_JsonConfig_track(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_Container_JsonConfig_track(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_Container_JsonConfig_live_edge(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_write(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_cut(moq_mux_container_Producer_Container_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_seek(moq_mux_container_Producer_Container_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_discontinuity(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_finish(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_container_Finished_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_fail(moq_mux_container_Producer_Container_JsonConfig *self, moq_Error *err_, moq_mux_container_Finished_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_write(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_cut(moq_mux_container_Producer_Container_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_seek(moq_mux_container_Producer_Container_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_discontinuity(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_finish(moq_mux_container_Producer_Container_JsonConfig *self, moq_mux_container_Finished_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_fail(moq_mux_container_Producer_Container_JsonConfig *self, moq_Error *err_, moq_mux_container_Finished_Container_JsonConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_Container_JsonConfig_abort(moq_mux_container_Producer_Container_JsonConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_abort_unwanted(moq_mux_container_Producer_Container_JsonConfig *self, moq_Error *err_, moq_mux_container_Producer_Container_JsonConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_JsonConfig_consume(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_Container_JsonConfig_broadcast(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_Container_JsonConfig_info(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_create_group(const moq_mux_container_Producer_Container_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_JsonConfig_append_group(const moq_mux_container_Producer_Container_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_abort_unwanted(moq_mux_container_Producer_Container_JsonConfig *self, moq_Error *err_, moq_mux_container_Producer_Container_JsonConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_JsonConfig_consume(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_Container_JsonConfig_broadcast(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_Container_JsonConfig_info(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_create_group(const moq_mux_container_Producer_Container_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_JsonConfig_append_group(const moq_mux_container_Producer_Container_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_JsonConfig_skip_groups(const moq_mux_container_Producer_Container_JsonConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_JsonConfig_finished(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_JsonConfig_closed_future moq_mux_container_Producer_Container_JsonConfig_closed_future; -moq_mux_container_Producer_Container_JsonConfig_closed_future *moq_mux_container_Producer_Container_JsonConfig_closed(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_Container_JsonConfig_closed_start(const moq_mux_container_Producer_Container_JsonConfig *self, moq_Error **err, moq_mux_container_Producer_Container_JsonConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_Container_JsonConfig_closed_poll(moq_mux_container_Producer_Container_JsonConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_Container_JsonConfig_closed_future *moq_mux_container_Producer_Container_JsonConfig_closed(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_JsonConfig_closed_start(const moq_mux_container_Producer_Container_JsonConfig *self, moq_Error **err, moq_mux_container_Producer_Container_JsonConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_JsonConfig_closed_poll(moq_mux_container_Producer_Container_JsonConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_Container_JsonConfig_closed_future_free(moq_mux_container_Producer_Container_JsonConfig_closed_future *future); bool moq_mux_container_Producer_Container_JsonConfig_is_closed(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_JsonConfig_largest(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_JsonConfig_is_clone(const moq_mux_container_Producer_Container_JsonConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_Container_JsonConfig_abort_handle(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_JsonConfig_subscribe(const moq_mux_container_Producer_Container_JsonConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_Container_JsonConfig_subscription(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_Container_JsonConfig_requests(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_Container_JsonConfig_abort_handle(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_JsonConfig_subscribe(const moq_mux_container_Producer_Container_JsonConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_Container_JsonConfig_subscription(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_Container_JsonConfig_requests(const moq_mux_container_Producer_Container_JsonConfig *self, moq_status *status); void moq_mux_container_Producer_Container_TextConfig_free(moq_mux_container_Producer_Container_TextConfig *self); void moq_mux_container_Producer_Container_TextConfig_drop(moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_set(moq_mux_container_Producer_Container_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_set_bitrate(moq_mux_container_Producer_Container_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_modify(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_timestamp(const moq_mux_container_Producer_Container_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_Container_TextConfig_name(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_Container_TextConfig_demand(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_TextConfig_estimate(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_set(moq_mux_container_Producer_Container_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_set_bitrate(moq_mux_container_Producer_Container_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_modify(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_timestamp(const moq_mux_container_Producer_Container_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_Container_TextConfig_name(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_Container_TextConfig_demand(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_TextConfig_estimate(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); void moq_mux_container_Producer_Container_TextConfig_reorder(moq_mux_container_Producer_Container_TextConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_Container_TextConfig_history(moq_mux_container_Producer_Container_TextConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_TextConfig_needs_keyframe(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -moq_mux_container_Producer_Container_TextConfig *moq_mux_container_Producer_Container_TextConfig_with_buffer(moq_mux_container_Producer_Container_TextConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_Container_TextConfig *moq_mux_container_Producer_Container_TextConfig_with_bandwidth(moq_mux_container_Producer_Container_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container_TextConfig *moq_mux_container_Producer_Container_TextConfig_with_buffer(moq_mux_container_Producer_Container_TextConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container_TextConfig *moq_mux_container_Producer_Container_TextConfig_with_bandwidth(moq_mux_container_Producer_Container_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_TextConfig_report_skipped(const moq_mux_container_Producer_Container_TextConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_TextConfig_report_bitrate(const moq_mux_container_Producer_Container_TextConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_Container_TextConfig_track(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_Container_TextConfig_track(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_Container_TextConfig_live_edge(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_write(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_cut(moq_mux_container_Producer_Container_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_seek(moq_mux_container_Producer_Container_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_discontinuity(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_finish(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_container_Finished_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_fail(moq_mux_container_Producer_Container_TextConfig *self, moq_Error *err_, moq_mux_container_Finished_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_write(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_cut(moq_mux_container_Producer_Container_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_seek(moq_mux_container_Producer_Container_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_discontinuity(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_finish(moq_mux_container_Producer_Container_TextConfig *self, moq_mux_container_Finished_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_fail(moq_mux_container_Producer_Container_TextConfig *self, moq_Error *err_, moq_mux_container_Finished_Container_TextConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_Container_TextConfig_abort(moq_mux_container_Producer_Container_TextConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_abort_unwanted(moq_mux_container_Producer_Container_TextConfig *self, moq_Error *err_, moq_mux_container_Producer_Container_TextConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_TextConfig_consume(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_Container_TextConfig_broadcast(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_Container_TextConfig_info(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_create_group(const moq_mux_container_Producer_Container_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_TextConfig_append_group(const moq_mux_container_Producer_Container_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_abort_unwanted(moq_mux_container_Producer_Container_TextConfig *self, moq_Error *err_, moq_mux_container_Producer_Container_TextConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_TextConfig_consume(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_Container_TextConfig_broadcast(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_Container_TextConfig_info(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_create_group(const moq_mux_container_Producer_Container_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_TextConfig_append_group(const moq_mux_container_Producer_Container_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_TextConfig_skip_groups(const moq_mux_container_Producer_Container_TextConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_TextConfig_finished(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_TextConfig_closed_future moq_mux_container_Producer_Container_TextConfig_closed_future; -moq_mux_container_Producer_Container_TextConfig_closed_future *moq_mux_container_Producer_Container_TextConfig_closed(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_Container_TextConfig_closed_start(const moq_mux_container_Producer_Container_TextConfig *self, moq_Error **err, moq_mux_container_Producer_Container_TextConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_Container_TextConfig_closed_poll(moq_mux_container_Producer_Container_TextConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_Container_TextConfig_closed_future *moq_mux_container_Producer_Container_TextConfig_closed(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_TextConfig_closed_start(const moq_mux_container_Producer_Container_TextConfig *self, moq_Error **err, moq_mux_container_Producer_Container_TextConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_TextConfig_closed_poll(moq_mux_container_Producer_Container_TextConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_Container_TextConfig_closed_future_free(moq_mux_container_Producer_Container_TextConfig_closed_future *future); bool moq_mux_container_Producer_Container_TextConfig_is_closed(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_TextConfig_largest(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_TextConfig_is_clone(const moq_mux_container_Producer_Container_TextConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_Container_TextConfig_abort_handle(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_TextConfig_subscribe(const moq_mux_container_Producer_Container_TextConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_Container_TextConfig_subscription(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_Container_TextConfig_requests(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_Container_TextConfig_abort_handle(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_TextConfig_subscribe(const moq_mux_container_Producer_Container_TextConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_Container_TextConfig_subscription(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_Container_TextConfig_requests(const moq_mux_container_Producer_Container_TextConfig *self, moq_status *status); void moq_mux_container_Producer_Container_VideoConfig_free(moq_mux_container_Producer_Container_VideoConfig *self); void moq_mux_container_Producer_Container_VideoConfig_drop(moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_set(moq_mux_container_Producer_Container_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_set_bitrate(moq_mux_container_Producer_Container_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_modify(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_timestamp(const moq_mux_container_Producer_Container_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_Container_VideoConfig_name(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_Container_VideoConfig_demand(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_VideoConfig_estimate(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_set(moq_mux_container_Producer_Container_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_set_bitrate(moq_mux_container_Producer_Container_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_modify(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_timestamp(const moq_mux_container_Producer_Container_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_Container_VideoConfig_name(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_Container_VideoConfig_demand(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_VideoConfig_estimate(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); void moq_mux_container_Producer_Container_VideoConfig_reorder(moq_mux_container_Producer_Container_VideoConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_Container_VideoConfig_history(moq_mux_container_Producer_Container_VideoConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_VideoConfig_needs_keyframe(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -moq_mux_container_Producer_Container_VideoConfig *moq_mux_container_Producer_Container_VideoConfig_with_buffer(moq_mux_container_Producer_Container_VideoConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_Container_VideoConfig *moq_mux_container_Producer_Container_VideoConfig_with_bandwidth(moq_mux_container_Producer_Container_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container_VideoConfig *moq_mux_container_Producer_Container_VideoConfig_with_buffer(moq_mux_container_Producer_Container_VideoConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container_VideoConfig *moq_mux_container_Producer_Container_VideoConfig_with_bandwidth(moq_mux_container_Producer_Container_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_VideoConfig_report_skipped(const moq_mux_container_Producer_Container_VideoConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_VideoConfig_report_bitrate(const moq_mux_container_Producer_Container_VideoConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_Container_VideoConfig_track(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_Container_VideoConfig_track(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_Container_VideoConfig_live_edge(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_write(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_cut(moq_mux_container_Producer_Container_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_seek(moq_mux_container_Producer_Container_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_discontinuity(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_finish(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_fail(moq_mux_container_Producer_Container_VideoConfig *self, moq_Error *err_, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_write(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_cut(moq_mux_container_Producer_Container_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_seek(moq_mux_container_Producer_Container_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_discontinuity(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_finish(moq_mux_container_Producer_Container_VideoConfig *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_fail(moq_mux_container_Producer_Container_VideoConfig *self, moq_Error *err_, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_Container_VideoConfig_abort(moq_mux_container_Producer_Container_VideoConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_abort_unwanted(moq_mux_container_Producer_Container_VideoConfig *self, moq_Error *err_, moq_mux_container_Producer_Container_VideoConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_VideoConfig_consume(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_Container_VideoConfig_broadcast(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_Container_VideoConfig_info(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_create_group(const moq_mux_container_Producer_Container_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_VideoConfig_append_group(const moq_mux_container_Producer_Container_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_abort_unwanted(moq_mux_container_Producer_Container_VideoConfig *self, moq_Error *err_, moq_mux_container_Producer_Container_VideoConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_VideoConfig_consume(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_Container_VideoConfig_broadcast(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_Container_VideoConfig_info(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_create_group(const moq_mux_container_Producer_Container_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_VideoConfig_append_group(const moq_mux_container_Producer_Container_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_VideoConfig_skip_groups(const moq_mux_container_Producer_Container_VideoConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_VideoConfig_finished(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_VideoConfig_closed_future moq_mux_container_Producer_Container_VideoConfig_closed_future; -moq_mux_container_Producer_Container_VideoConfig_closed_future *moq_mux_container_Producer_Container_VideoConfig_closed(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_Container_VideoConfig_closed_start(const moq_mux_container_Producer_Container_VideoConfig *self, moq_Error **err, moq_mux_container_Producer_Container_VideoConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_Container_VideoConfig_closed_poll(moq_mux_container_Producer_Container_VideoConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_Container_VideoConfig_closed_future *moq_mux_container_Producer_Container_VideoConfig_closed(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_VideoConfig_closed_start(const moq_mux_container_Producer_Container_VideoConfig *self, moq_Error **err, moq_mux_container_Producer_Container_VideoConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_VideoConfig_closed_poll(moq_mux_container_Producer_Container_VideoConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_Container_VideoConfig_closed_future_free(moq_mux_container_Producer_Container_VideoConfig_closed_future *future); bool moq_mux_container_Producer_Container_VideoConfig_is_closed(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_VideoConfig_largest(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_Container_VideoConfig_is_clone(const moq_mux_container_Producer_Container_VideoConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_Container_VideoConfig_abort_handle(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_VideoConfig_subscribe(const moq_mux_container_Producer_Container_VideoConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_Container_VideoConfig_subscription(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_Container_VideoConfig_requests(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_Container_VideoConfig_abort_handle(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_VideoConfig_subscribe(const moq_mux_container_Producer_Container_VideoConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_Container_VideoConfig_subscription(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_Container_VideoConfig_requests(const moq_mux_container_Producer_Container_VideoConfig *self, moq_status *status); void moq_mux_container_Producer_Container_free(moq_mux_container_Producer_Container *self); void moq_mux_container_Producer_Container_drop(moq_mux_container_Producer_Container *self, moq_status *status); -moq_mux_container_Producer_Container *moq_mux_container_Producer_Container_new(moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_status *status); -bool moq_mux_container_Producer_Container_set(moq_mux_container_Producer_Container *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_set_bitrate(moq_mux_container_Producer_Container *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_modify(moq_mux_container_Producer_Container *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_timestamp(const moq_mux_container_Producer_Container *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_Container_name(const moq_mux_container_Producer_Container *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_Container_demand(const moq_mux_container_Producer_Container *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_estimate(const moq_mux_container_Producer_Container *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container *moq_mux_container_Producer_Container_new(moq_track_Producer *track, moq_mux_catalog_hang_Container *container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_set(moq_mux_container_Producer_Container *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_set_bitrate(moq_mux_container_Producer_Container *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_modify(moq_mux_container_Producer_Container *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_timestamp(const moq_mux_container_Producer_Container *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_Container_name(const moq_mux_container_Producer_Container *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_Container_demand(const moq_mux_container_Producer_Container *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_Container_estimate(const moq_mux_container_Producer_Container *self, moq_status *status); void moq_mux_container_Producer_Container_reorder(moq_mux_container_Producer_Container *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_Container_history(moq_mux_container_Producer_Container *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_Container_needs_keyframe(const moq_mux_container_Producer_Container *self, moq_status *status); -moq_mux_container_Producer_Container *moq_mux_container_Producer_Container_with_buffer(moq_mux_container_Producer_Container *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_Container *moq_mux_container_Producer_Container_with_bandwidth(moq_mux_container_Producer_Container *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container *moq_mux_container_Producer_Container_with_buffer(moq_mux_container_Producer_Container *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_Container *moq_mux_container_Producer_Container_with_bandwidth(moq_mux_container_Producer_Container *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_Container_report_skipped(const moq_mux_container_Producer_Container *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_Container_report_bitrate(const moq_mux_container_Producer_Container *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_Container_track(const moq_mux_container_Producer_Container *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_Container_track(const moq_mux_container_Producer_Container *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_Container_live_edge(const moq_mux_container_Producer_Container *self, moq_status *status); -bool moq_mux_container_Producer_Container_write(moq_mux_container_Producer_Container *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_cut(moq_mux_container_Producer_Container *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_seek(moq_mux_container_Producer_Container *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_discontinuity(moq_mux_container_Producer_Container *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_finish(moq_mux_container_Producer_Container *self, moq_mux_container_Finished_Container **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_fail(moq_mux_container_Producer_Container *self, moq_Error *err_, moq_mux_container_Finished_Container **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_write(moq_mux_container_Producer_Container *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_cut(moq_mux_container_Producer_Container *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_seek(moq_mux_container_Producer_Container *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_discontinuity(moq_mux_container_Producer_Container *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_finish(moq_mux_container_Producer_Container *self, moq_mux_container_Finished_Container **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_fail(moq_mux_container_Producer_Container *self, moq_Error *err_, moq_mux_container_Finished_Container **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_Container_abort(moq_mux_container_Producer_Container *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_Container_abort_unwanted(moq_mux_container_Producer_Container *self, moq_Error *err_, moq_mux_container_Producer_Container **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_consume(const moq_mux_container_Producer_Container *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_Container_broadcast(const moq_mux_container_Producer_Container *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_Container_info(const moq_mux_container_Producer_Container *self, moq_status *status); -bool moq_mux_container_Producer_Container_create_group(const moq_mux_container_Producer_Container *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_Container_append_group(const moq_mux_container_Producer_Container *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_abort_unwanted(moq_mux_container_Producer_Container *self, moq_Error *err_, moq_mux_container_Producer_Container **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_consume(const moq_mux_container_Producer_Container *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_Container_broadcast(const moq_mux_container_Producer_Container *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_Container_info(const moq_mux_container_Producer_Container *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_create_group(const moq_mux_container_Producer_Container *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_Container_append_group(const moq_mux_container_Producer_Container *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_Container_skip_groups(const moq_mux_container_Producer_Container *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_finished(const moq_mux_container_Producer_Container *self, moq_status *status); typedef struct moq_mux_container_Producer_Container_closed_future moq_mux_container_Producer_Container_closed_future; -moq_mux_container_Producer_Container_closed_future *moq_mux_container_Producer_Container_closed(const moq_mux_container_Producer_Container *self, moq_status *status); -moq_poll moq_mux_container_Producer_Container_closed_start(const moq_mux_container_Producer_Container *self, moq_Error **err, moq_mux_container_Producer_Container_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_Container_closed_poll(moq_mux_container_Producer_Container_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_Container_closed_future *moq_mux_container_Producer_Container_closed(const moq_mux_container_Producer_Container *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_closed_start(const moq_mux_container_Producer_Container *self, moq_Error **err, moq_mux_container_Producer_Container_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_Container_closed_poll(moq_mux_container_Producer_Container_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_Container_closed_future_free(moq_mux_container_Producer_Container_closed_future *future); bool moq_mux_container_Producer_Container_is_closed(const moq_mux_container_Producer_Container *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_Container_largest(const moq_mux_container_Producer_Container *self, moq_status *status); bool moq_mux_container_Producer_Container_is_clone(const moq_mux_container_Producer_Container *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_Container_abort_handle(const moq_mux_container_Producer_Container *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_Container_subscribe(const moq_mux_container_Producer_Container *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_Container_subscription(const moq_mux_container_Producer_Container *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_Container_requests(const moq_mux_container_Producer_Container *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_Container_abort_handle(const moq_mux_container_Producer_Container *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_Container_subscribe(const moq_mux_container_Producer_Container *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_Container_subscription(const moq_mux_container_Producer_Container *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_Container_requests(const moq_mux_container_Producer_Container *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_free(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_drop(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_set(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_modify(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_fmp4_Wire_AudioConfig_name(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_AudioConfig_demand(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_AudioConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_set(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_modify(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_fmp4_Wire_AudioConfig_name(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_AudioConfig_demand(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_AudioConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_reorder(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_history(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_mux_container_Producer_fmp4_Wire_AudioConfig *moq_mux_container_Producer_fmp4_Wire_AudioConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_fmp4_Wire_AudioConfig *moq_mux_container_Producer_fmp4_Wire_AudioConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_AudioConfig *moq_mux_container_Producer_fmp4_Wire_AudioConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_AudioConfig *moq_mux_container_Producer_fmp4_Wire_AudioConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_report_skipped(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_report_bitrate(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_AudioConfig_track(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_AudioConfig_track(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_AudioConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_write(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_cut(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_seek(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_finish(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_container_Finished_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_fail(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_write(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_cut(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_seek(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_finish(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_mux_container_Finished_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_fail(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_abort(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_abort_unwanted(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire_AudioConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_AudioConfig_consume(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_AudioConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_fmp4_Wire_AudioConfig_info(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_abort_unwanted(moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire_AudioConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_AudioConfig_consume(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_AudioConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_fmp4_Wire_AudioConfig_info(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_skip_groups(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_AudioConfig_finished(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future; -moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future *moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_start(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_poll(moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future *moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_start(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_poll(moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future_free(moq_mux_container_Producer_fmp4_Wire_AudioConfig_closed_future *future); bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_is_closed(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_AudioConfig_largest(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_AudioConfig_is_clone(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_AudioConfig_abort_handle(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_AudioConfig_subscribe(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_AudioConfig_subscription(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_AudioConfig_requests(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_AudioConfig_abort_handle(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_AudioConfig_subscribe(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_AudioConfig_subscription(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_AudioConfig_requests(const moq_mux_container_Producer_fmp4_Wire_AudioConfig *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_free(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_drop(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_set(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_modify(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_fmp4_Wire_BinaryConfig_name(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_demand(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_set(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_modify(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_fmp4_Wire_BinaryConfig_name(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_demand(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_reorder(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_history(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_mux_container_Producer_fmp4_Wire_BinaryConfig *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_fmp4_Wire_BinaryConfig *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_BinaryConfig *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_BinaryConfig *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_report_skipped(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_report_bitrate(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_track(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_track(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_BinaryConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_write(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_cut(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_seek(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_finish(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_container_Finished_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_fail(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_write(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_cut(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_seek(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_finish(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_mux_container_Finished_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_fail(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_abort(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_abort_unwanted(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_consume(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_info(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_abort_unwanted(moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire_BinaryConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_consume(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_info(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_skip_groups(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_BinaryConfig_finished(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future; -moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_start(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_poll(moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_start(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_poll(moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future_free(moq_mux_container_Producer_fmp4_Wire_BinaryConfig_closed_future *future); bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_is_closed(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_BinaryConfig_largest(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_BinaryConfig_is_clone(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_abort_handle(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_subscribe(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_subscription(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_requests(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_abort_handle(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_subscribe(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_subscription(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_BinaryConfig_requests(const moq_mux_container_Producer_fmp4_Wire_BinaryConfig *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_free(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_drop(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_set(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_modify(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_fmp4_Wire_JsonConfig_name(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_JsonConfig_demand(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_JsonConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_set(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_modify(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_fmp4_Wire_JsonConfig_name(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_JsonConfig_demand(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_JsonConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_reorder(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_history(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_mux_container_Producer_fmp4_Wire_JsonConfig *moq_mux_container_Producer_fmp4_Wire_JsonConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_fmp4_Wire_JsonConfig *moq_mux_container_Producer_fmp4_Wire_JsonConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_JsonConfig *moq_mux_container_Producer_fmp4_Wire_JsonConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_JsonConfig *moq_mux_container_Producer_fmp4_Wire_JsonConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_report_skipped(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_report_bitrate(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_JsonConfig_track(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_JsonConfig_track(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_JsonConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_write(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_cut(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_seek(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_finish(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_container_Finished_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_fail(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_write(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_cut(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_seek(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_finish(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_mux_container_Finished_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_fail(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_abort(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_abort_unwanted(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire_JsonConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_JsonConfig_consume(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_JsonConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_fmp4_Wire_JsonConfig_info(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_abort_unwanted(moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire_JsonConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_JsonConfig_consume(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_JsonConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_fmp4_Wire_JsonConfig_info(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_skip_groups(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_JsonConfig_finished(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future; -moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future *moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_start(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_poll(moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future *moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_start(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_poll(moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future_free(moq_mux_container_Producer_fmp4_Wire_JsonConfig_closed_future *future); bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_is_closed(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_JsonConfig_largest(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_JsonConfig_is_clone(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_JsonConfig_abort_handle(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_JsonConfig_subscribe(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_JsonConfig_subscription(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_JsonConfig_requests(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_JsonConfig_abort_handle(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_JsonConfig_subscribe(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_JsonConfig_subscription(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_JsonConfig_requests(const moq_mux_container_Producer_fmp4_Wire_JsonConfig *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_TextConfig_free(moq_mux_container_Producer_fmp4_Wire_TextConfig *self); void moq_mux_container_Producer_fmp4_Wire_TextConfig_drop(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_set(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_modify(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_fmp4_Wire_TextConfig_name(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_TextConfig_demand(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_TextConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_set(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_modify(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_fmp4_Wire_TextConfig_name(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_TextConfig_demand(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_TextConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_TextConfig_reorder(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_TextConfig_history(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_TextConfig_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -moq_mux_container_Producer_fmp4_Wire_TextConfig *moq_mux_container_Producer_fmp4_Wire_TextConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_fmp4_Wire_TextConfig *moq_mux_container_Producer_fmp4_Wire_TextConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_TextConfig *moq_mux_container_Producer_fmp4_Wire_TextConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_TextConfig *moq_mux_container_Producer_fmp4_Wire_TextConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_TextConfig_report_skipped(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_TextConfig_report_bitrate(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_TextConfig_track(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_TextConfig_track(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_TextConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_write(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_cut(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_seek(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_finish(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_container_Finished_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_fail(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_write(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_cut(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_seek(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_finish(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_mux_container_Finished_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_fail(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_TextConfig_abort(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_abort_unwanted(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire_TextConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_TextConfig_consume(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_TextConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_fmp4_Wire_TextConfig_info(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_TextConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_abort_unwanted(moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire_TextConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_TextConfig_consume(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_TextConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_fmp4_Wire_TextConfig_info(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_TextConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_TextConfig_skip_groups(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_TextConfig_finished(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future; -moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future *moq_mux_container_Producer_fmp4_Wire_TextConfig_closed(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_start(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_poll(moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future *moq_mux_container_Producer_fmp4_Wire_TextConfig_closed(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_start(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_poll(moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future_free(moq_mux_container_Producer_fmp4_Wire_TextConfig_closed_future *future); bool moq_mux_container_Producer_fmp4_Wire_TextConfig_is_closed(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_TextConfig_largest(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_TextConfig_is_clone(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_TextConfig_abort_handle(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_TextConfig_subscribe(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_TextConfig_subscription(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_TextConfig_requests(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_TextConfig_abort_handle(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_TextConfig_subscribe(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_TextConfig_subscription(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_TextConfig_requests(const moq_mux_container_Producer_fmp4_Wire_TextConfig *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_free(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_drop(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_set(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_modify(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_fmp4_Wire_VideoConfig_name(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_VideoConfig_demand(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_VideoConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_set(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_set_bitrate(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_modify(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_fmp4_Wire_VideoConfig_name(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_VideoConfig_demand(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_VideoConfig_estimate(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_reorder(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_history(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_mux_container_Producer_fmp4_Wire_VideoConfig *moq_mux_container_Producer_fmp4_Wire_VideoConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_fmp4_Wire_VideoConfig *moq_mux_container_Producer_fmp4_Wire_VideoConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_VideoConfig *moq_mux_container_Producer_fmp4_Wire_VideoConfig_with_buffer(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_VideoConfig *moq_mux_container_Producer_fmp4_Wire_VideoConfig_with_bandwidth(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_report_skipped(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_report_bitrate(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_VideoConfig_track(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_VideoConfig_track(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_VideoConfig_live_edge(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_write(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_cut(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_seek(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_finish(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_container_Finished_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_fail(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_write(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_cut(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_seek(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_discontinuity(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_finish(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_mux_container_Finished_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_fail(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_abort(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_abort_unwanted(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire_VideoConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_VideoConfig_consume(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_VideoConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_fmp4_Wire_VideoConfig_info(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_abort_unwanted(moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire_VideoConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_VideoConfig_consume(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_VideoConfig_broadcast(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_fmp4_Wire_VideoConfig_info(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_create_group(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_append_group(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_skip_groups(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_VideoConfig_finished(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future; -moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future *moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_start(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_poll(moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future *moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_start(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_poll(moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future_free(moq_mux_container_Producer_fmp4_Wire_VideoConfig_closed_future *future); bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_is_closed(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_VideoConfig_largest(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_VideoConfig_is_clone(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_VideoConfig_abort_handle(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_VideoConfig_subscribe(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_VideoConfig_subscription(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_VideoConfig_requests(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_VideoConfig_abort_handle(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_VideoConfig_subscribe(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_VideoConfig_subscription(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_VideoConfig_requests(const moq_mux_container_Producer_fmp4_Wire_VideoConfig *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_free(moq_mux_container_Producer_fmp4_Wire *self); void moq_mux_container_Producer_fmp4_Wire_drop(moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -moq_mux_container_Producer_fmp4_Wire *moq_mux_container_Producer_fmp4_Wire_new(moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_set(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_set_bitrate(moq_mux_container_Producer_fmp4_Wire *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_modify(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_timestamp(const moq_mux_container_Producer_fmp4_Wire *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_fmp4_Wire_name(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_demand(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_estimate(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire *moq_mux_container_Producer_fmp4_Wire_new(moq_track_Producer *track, moq_mux_container_fmp4_Wire *container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_set(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_set_bitrate(moq_mux_container_Producer_fmp4_Wire *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_modify(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_timestamp(const moq_mux_container_Producer_fmp4_Wire *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_fmp4_Wire_name(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_fmp4_Wire_demand(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_fmp4_Wire_estimate(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_reorder(moq_mux_container_Producer_fmp4_Wire *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_history(moq_mux_container_Producer_fmp4_Wire *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_needs_keyframe(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -moq_mux_container_Producer_fmp4_Wire *moq_mux_container_Producer_fmp4_Wire_with_buffer(moq_mux_container_Producer_fmp4_Wire *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_fmp4_Wire *moq_mux_container_Producer_fmp4_Wire_with_bandwidth(moq_mux_container_Producer_fmp4_Wire *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire *moq_mux_container_Producer_fmp4_Wire_with_buffer(moq_mux_container_Producer_fmp4_Wire *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire *moq_mux_container_Producer_fmp4_Wire_with_bandwidth(moq_mux_container_Producer_fmp4_Wire *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_report_skipped(const moq_mux_container_Producer_fmp4_Wire *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_report_bitrate(const moq_mux_container_Producer_fmp4_Wire *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_track(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_fmp4_Wire_track(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_fmp4_Wire_live_edge(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_write(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_cut(moq_mux_container_Producer_fmp4_Wire *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_seek(moq_mux_container_Producer_fmp4_Wire *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_discontinuity(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_finish(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_container_Finished_fmp4_Wire **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_fail(moq_mux_container_Producer_fmp4_Wire *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_write(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_cut(moq_mux_container_Producer_fmp4_Wire *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_seek(moq_mux_container_Producer_fmp4_Wire *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_discontinuity(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_finish(moq_mux_container_Producer_fmp4_Wire *self, moq_mux_container_Finished_fmp4_Wire **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_fail(moq_mux_container_Producer_fmp4_Wire *self, moq_Error *err_, moq_mux_container_Finished_fmp4_Wire **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_abort(moq_mux_container_Producer_fmp4_Wire *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_abort_unwanted(moq_mux_container_Producer_fmp4_Wire *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_consume(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_broadcast(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_fmp4_Wire_info(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_create_group(const moq_mux_container_Producer_fmp4_Wire *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_fmp4_Wire_append_group(const moq_mux_container_Producer_fmp4_Wire *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_abort_unwanted(moq_mux_container_Producer_fmp4_Wire *self, moq_Error *err_, moq_mux_container_Producer_fmp4_Wire **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_consume(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_fmp4_Wire_broadcast(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_fmp4_Wire_info(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_create_group(const moq_mux_container_Producer_fmp4_Wire *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_fmp4_Wire_append_group(const moq_mux_container_Producer_fmp4_Wire *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_fmp4_Wire_skip_groups(const moq_mux_container_Producer_fmp4_Wire *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_finished(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); typedef struct moq_mux_container_Producer_fmp4_Wire_closed_future moq_mux_container_Producer_fmp4_Wire_closed_future; -moq_mux_container_Producer_fmp4_Wire_closed_future *moq_mux_container_Producer_fmp4_Wire_closed(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_closed_start(const moq_mux_container_Producer_fmp4_Wire *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_fmp4_Wire_closed_poll(moq_mux_container_Producer_fmp4_Wire_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_fmp4_Wire_closed_future *moq_mux_container_Producer_fmp4_Wire_closed(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_closed_start(const moq_mux_container_Producer_fmp4_Wire *self, moq_Error **err, moq_mux_container_Producer_fmp4_Wire_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_fmp4_Wire_closed_poll(moq_mux_container_Producer_fmp4_Wire_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_fmp4_Wire_closed_future_free(moq_mux_container_Producer_fmp4_Wire_closed_future *future); bool moq_mux_container_Producer_fmp4_Wire_is_closed(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_fmp4_Wire_largest(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); bool moq_mux_container_Producer_fmp4_Wire_is_clone(const moq_mux_container_Producer_fmp4_Wire *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_abort_handle(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_subscribe(const moq_mux_container_Producer_fmp4_Wire *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_subscription(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_requests(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_fmp4_Wire_abort_handle(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_fmp4_Wire_subscribe(const moq_mux_container_Producer_fmp4_Wire *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_fmp4_Wire_subscription(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_fmp4_Wire_requests(const moq_mux_container_Producer_fmp4_Wire *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_AudioConfig_free(moq_mux_container_Producer_legacy_Wire_AudioConfig *self); void moq_mux_container_Producer_legacy_Wire_AudioConfig_drop(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_set(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_modify(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_legacy_Wire_AudioConfig_name(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_legacy_Wire_AudioConfig_demand(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_AudioConfig_estimate(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_set(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_modify(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_legacy_Wire_AudioConfig_name(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_legacy_Wire_AudioConfig_demand(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_AudioConfig_estimate(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_AudioConfig_reorder(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_legacy_Wire_AudioConfig_history(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_AudioConfig_needs_keyframe(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -moq_mux_container_Producer_legacy_Wire_AudioConfig *moq_mux_container_Producer_legacy_Wire_AudioConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_legacy_Wire_AudioConfig *moq_mux_container_Producer_legacy_Wire_AudioConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_AudioConfig *moq_mux_container_Producer_legacy_Wire_AudioConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_AudioConfig *moq_mux_container_Producer_legacy_Wire_AudioConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_AudioConfig_report_skipped(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_AudioConfig_report_bitrate(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_legacy_Wire_AudioConfig_track(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_legacy_Wire_AudioConfig_track(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_AudioConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_write(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_cut(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_seek(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_finish(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_container_Finished_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_fail(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_write(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_cut(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_seek(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_finish(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_mux_container_Finished_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_fail(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_AudioConfig_abort(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_abort_unwanted(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire_AudioConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_AudioConfig_consume(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_AudioConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_legacy_Wire_AudioConfig_info(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_create_group(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_AudioConfig_append_group(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_abort_unwanted(moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire_AudioConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_AudioConfig_consume(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_AudioConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_legacy_Wire_AudioConfig_info(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_create_group(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_AudioConfig_append_group(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_AudioConfig_skip_groups(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_AudioConfig_finished(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future; -moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future *moq_mux_container_Producer_legacy_Wire_AudioConfig_closed(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_start(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_poll(moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future *moq_mux_container_Producer_legacy_Wire_AudioConfig_closed(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_start(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_poll(moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future_free(moq_mux_container_Producer_legacy_Wire_AudioConfig_closed_future *future); bool moq_mux_container_Producer_legacy_Wire_AudioConfig_is_closed(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_AudioConfig_largest(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_AudioConfig_is_clone(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_AudioConfig_abort_handle(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_AudioConfig_subscribe(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_AudioConfig_subscription(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_legacy_Wire_AudioConfig_requests(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_AudioConfig_abort_handle(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_AudioConfig_subscribe(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_AudioConfig_subscription(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_legacy_Wire_AudioConfig_requests(const moq_mux_container_Producer_legacy_Wire_AudioConfig *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_free(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_drop(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_set(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_modify(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_legacy_Wire_BinaryConfig_name(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_legacy_Wire_BinaryConfig_demand(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_BinaryConfig_estimate(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_set(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_modify(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_legacy_Wire_BinaryConfig_name(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_legacy_Wire_BinaryConfig_demand(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_BinaryConfig_estimate(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_reorder(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_history(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_needs_keyframe(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_mux_container_Producer_legacy_Wire_BinaryConfig *moq_mux_container_Producer_legacy_Wire_BinaryConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_legacy_Wire_BinaryConfig *moq_mux_container_Producer_legacy_Wire_BinaryConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_BinaryConfig *moq_mux_container_Producer_legacy_Wire_BinaryConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_BinaryConfig *moq_mux_container_Producer_legacy_Wire_BinaryConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_report_skipped(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_report_bitrate(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_legacy_Wire_BinaryConfig_track(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_legacy_Wire_BinaryConfig_track(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_BinaryConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_write(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_cut(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_seek(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_finish(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_container_Finished_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_fail(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_write(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_cut(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_seek(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_finish(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_mux_container_Finished_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_fail(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_abort(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_abort_unwanted(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire_BinaryConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_BinaryConfig_consume(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_BinaryConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_legacy_Wire_BinaryConfig_info(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_create_group(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_abort_unwanted(moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire_BinaryConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_BinaryConfig_consume(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_BinaryConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_legacy_Wire_BinaryConfig_info(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_create_group(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_skip_groups(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_BinaryConfig_finished(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future; -moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future *moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_start(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_poll(moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future *moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_start(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_poll(moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future_free(moq_mux_container_Producer_legacy_Wire_BinaryConfig_closed_future *future); bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_is_closed(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_BinaryConfig_largest(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_BinaryConfig_is_clone(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_BinaryConfig_abort_handle(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_BinaryConfig_subscribe(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_BinaryConfig_subscription(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_legacy_Wire_BinaryConfig_requests(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_BinaryConfig_abort_handle(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_BinaryConfig_subscribe(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_BinaryConfig_subscription(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_legacy_Wire_BinaryConfig_requests(const moq_mux_container_Producer_legacy_Wire_BinaryConfig *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_JsonConfig_free(moq_mux_container_Producer_legacy_Wire_JsonConfig *self); void moq_mux_container_Producer_legacy_Wire_JsonConfig_drop(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_set(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_modify(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_legacy_Wire_JsonConfig_name(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_legacy_Wire_JsonConfig_demand(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_JsonConfig_estimate(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_set(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_modify(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_legacy_Wire_JsonConfig_name(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_legacy_Wire_JsonConfig_demand(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_JsonConfig_estimate(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_JsonConfig_reorder(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_legacy_Wire_JsonConfig_history(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_JsonConfig_needs_keyframe(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -moq_mux_container_Producer_legacy_Wire_JsonConfig *moq_mux_container_Producer_legacy_Wire_JsonConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_legacy_Wire_JsonConfig *moq_mux_container_Producer_legacy_Wire_JsonConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_JsonConfig *moq_mux_container_Producer_legacy_Wire_JsonConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_JsonConfig *moq_mux_container_Producer_legacy_Wire_JsonConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_JsonConfig_report_skipped(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_JsonConfig_report_bitrate(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_legacy_Wire_JsonConfig_track(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_legacy_Wire_JsonConfig_track(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_JsonConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_write(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_cut(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_seek(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_finish(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_container_Finished_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_fail(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_write(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_cut(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_seek(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_finish(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_mux_container_Finished_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_fail(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_JsonConfig_abort(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_abort_unwanted(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire_JsonConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_JsonConfig_consume(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_JsonConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_legacy_Wire_JsonConfig_info(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_create_group(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_JsonConfig_append_group(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_abort_unwanted(moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire_JsonConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_JsonConfig_consume(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_JsonConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_legacy_Wire_JsonConfig_info(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_create_group(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_JsonConfig_append_group(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_JsonConfig_skip_groups(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_JsonConfig_finished(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future; -moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future *moq_mux_container_Producer_legacy_Wire_JsonConfig_closed(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_start(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_poll(moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future *moq_mux_container_Producer_legacy_Wire_JsonConfig_closed(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_start(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_poll(moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future_free(moq_mux_container_Producer_legacy_Wire_JsonConfig_closed_future *future); bool moq_mux_container_Producer_legacy_Wire_JsonConfig_is_closed(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_JsonConfig_largest(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_JsonConfig_is_clone(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_JsonConfig_abort_handle(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_JsonConfig_subscribe(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_JsonConfig_subscription(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_legacy_Wire_JsonConfig_requests(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_JsonConfig_abort_handle(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_JsonConfig_subscribe(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_JsonConfig_subscription(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_legacy_Wire_JsonConfig_requests(const moq_mux_container_Producer_legacy_Wire_JsonConfig *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_TextConfig_free(moq_mux_container_Producer_legacy_Wire_TextConfig *self); void moq_mux_container_Producer_legacy_Wire_TextConfig_drop(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_set(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_modify(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_legacy_Wire_TextConfig_name(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_legacy_Wire_TextConfig_demand(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_TextConfig_estimate(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_set(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_modify(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_legacy_Wire_TextConfig_name(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_legacy_Wire_TextConfig_demand(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_TextConfig_estimate(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_TextConfig_reorder(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_legacy_Wire_TextConfig_history(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_TextConfig_needs_keyframe(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -moq_mux_container_Producer_legacy_Wire_TextConfig *moq_mux_container_Producer_legacy_Wire_TextConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_legacy_Wire_TextConfig *moq_mux_container_Producer_legacy_Wire_TextConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_TextConfig *moq_mux_container_Producer_legacy_Wire_TextConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_TextConfig *moq_mux_container_Producer_legacy_Wire_TextConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_TextConfig_report_skipped(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_TextConfig_report_bitrate(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_legacy_Wire_TextConfig_track(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_legacy_Wire_TextConfig_track(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_TextConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_write(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_cut(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_seek(moq_mux_container_Producer_legacy_Wire_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_finish(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_container_Finished_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_fail(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_write(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_cut(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_seek(moq_mux_container_Producer_legacy_Wire_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_finish(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_mux_container_Finished_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_fail(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_TextConfig_abort(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_abort_unwanted(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire_TextConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_TextConfig_consume(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_TextConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_legacy_Wire_TextConfig_info(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_create_group(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_TextConfig_append_group(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_abort_unwanted(moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire_TextConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_TextConfig_consume(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_TextConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_legacy_Wire_TextConfig_info(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_create_group(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_TextConfig_append_group(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_TextConfig_skip_groups(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_TextConfig_finished(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future; -moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future *moq_mux_container_Producer_legacy_Wire_TextConfig_closed(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_TextConfig_closed_start(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_TextConfig_closed_poll(moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future *moq_mux_container_Producer_legacy_Wire_TextConfig_closed(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_TextConfig_closed_start(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_TextConfig_closed_poll(moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future_free(moq_mux_container_Producer_legacy_Wire_TextConfig_closed_future *future); bool moq_mux_container_Producer_legacy_Wire_TextConfig_is_closed(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_TextConfig_largest(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_TextConfig_is_clone(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_TextConfig_abort_handle(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_TextConfig_subscribe(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_TextConfig_subscription(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_legacy_Wire_TextConfig_requests(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_TextConfig_abort_handle(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_TextConfig_subscribe(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_TextConfig_subscription(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_legacy_Wire_TextConfig_requests(const moq_mux_container_Producer_legacy_Wire_TextConfig *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_VideoConfig_free(moq_mux_container_Producer_legacy_Wire_VideoConfig *self); void moq_mux_container_Producer_legacy_Wire_VideoConfig_drop(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_set(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_modify(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_legacy_Wire_VideoConfig_name(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_legacy_Wire_VideoConfig_demand(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_VideoConfig_estimate(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_set(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_set_bitrate(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_modify(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_legacy_Wire_VideoConfig_name(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_legacy_Wire_VideoConfig_demand(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_VideoConfig_estimate(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_VideoConfig_reorder(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_legacy_Wire_VideoConfig_history(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_VideoConfig_needs_keyframe(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -moq_mux_container_Producer_legacy_Wire_VideoConfig *moq_mux_container_Producer_legacy_Wire_VideoConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_legacy_Wire_VideoConfig *moq_mux_container_Producer_legacy_Wire_VideoConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_VideoConfig *moq_mux_container_Producer_legacy_Wire_VideoConfig_with_buffer(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_VideoConfig *moq_mux_container_Producer_legacy_Wire_VideoConfig_with_bandwidth(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_VideoConfig_report_skipped(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_VideoConfig_report_bitrate(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_legacy_Wire_VideoConfig_track(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_legacy_Wire_VideoConfig_track(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_VideoConfig_live_edge(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_write(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_cut(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_seek(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_finish(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_container_Finished_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_fail(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_write(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_cut(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_seek(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_discontinuity(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_finish(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_mux_container_Finished_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_fail(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_VideoConfig_abort(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_abort_unwanted(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire_VideoConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_VideoConfig_consume(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_VideoConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_legacy_Wire_VideoConfig_info(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_create_group(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_VideoConfig_append_group(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_abort_unwanted(moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire_VideoConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_VideoConfig_consume(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_VideoConfig_broadcast(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_legacy_Wire_VideoConfig_info(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_create_group(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_VideoConfig_append_group(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_VideoConfig_skip_groups(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_VideoConfig_finished(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future; -moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future *moq_mux_container_Producer_legacy_Wire_VideoConfig_closed(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_start(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_poll(moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future *moq_mux_container_Producer_legacy_Wire_VideoConfig_closed(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_start(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_poll(moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future_free(moq_mux_container_Producer_legacy_Wire_VideoConfig_closed_future *future); bool moq_mux_container_Producer_legacy_Wire_VideoConfig_is_closed(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_VideoConfig_largest(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_VideoConfig_is_clone(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_VideoConfig_abort_handle(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_VideoConfig_subscribe(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_VideoConfig_subscription(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_legacy_Wire_VideoConfig_requests(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_VideoConfig_abort_handle(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_VideoConfig_subscribe(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_VideoConfig_subscription(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_legacy_Wire_VideoConfig_requests(const moq_mux_container_Producer_legacy_Wire_VideoConfig *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_free(moq_mux_container_Producer_legacy_Wire *self); void moq_mux_container_Producer_legacy_Wire_drop(moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -moq_mux_container_Producer_legacy_Wire *moq_mux_container_Producer_legacy_Wire_new(moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_set(moq_mux_container_Producer_legacy_Wire *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_set_bitrate(moq_mux_container_Producer_legacy_Wire *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_modify(moq_mux_container_Producer_legacy_Wire *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_timestamp(const moq_mux_container_Producer_legacy_Wire *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_legacy_Wire_name(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_legacy_Wire_demand(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_estimate(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire *moq_mux_container_Producer_legacy_Wire_new(moq_track_Producer *track, moq_mux_container_legacy_Wire container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_set(moq_mux_container_Producer_legacy_Wire *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_set_bitrate(moq_mux_container_Producer_legacy_Wire *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_modify(moq_mux_container_Producer_legacy_Wire *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_timestamp(const moq_mux_container_Producer_legacy_Wire *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_legacy_Wire_name(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_legacy_Wire_demand(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_legacy_Wire_estimate(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); void moq_mux_container_Producer_legacy_Wire_reorder(moq_mux_container_Producer_legacy_Wire *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_legacy_Wire_history(moq_mux_container_Producer_legacy_Wire *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_needs_keyframe(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -moq_mux_container_Producer_legacy_Wire *moq_mux_container_Producer_legacy_Wire_with_buffer(moq_mux_container_Producer_legacy_Wire *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_legacy_Wire *moq_mux_container_Producer_legacy_Wire_with_bandwidth(moq_mux_container_Producer_legacy_Wire *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire *moq_mux_container_Producer_legacy_Wire_with_buffer(moq_mux_container_Producer_legacy_Wire *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire *moq_mux_container_Producer_legacy_Wire_with_bandwidth(moq_mux_container_Producer_legacy_Wire *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_legacy_Wire_report_skipped(const moq_mux_container_Producer_legacy_Wire *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_legacy_Wire_report_bitrate(const moq_mux_container_Producer_legacy_Wire *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_legacy_Wire_track(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_legacy_Wire_track(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_legacy_Wire_live_edge(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_write(moq_mux_container_Producer_legacy_Wire *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_cut(moq_mux_container_Producer_legacy_Wire *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_seek(moq_mux_container_Producer_legacy_Wire *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_discontinuity(moq_mux_container_Producer_legacy_Wire *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_finish(moq_mux_container_Producer_legacy_Wire *self, moq_mux_container_Finished_legacy_Wire **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_fail(moq_mux_container_Producer_legacy_Wire *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_write(moq_mux_container_Producer_legacy_Wire *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_cut(moq_mux_container_Producer_legacy_Wire *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_seek(moq_mux_container_Producer_legacy_Wire *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_discontinuity(moq_mux_container_Producer_legacy_Wire *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_finish(moq_mux_container_Producer_legacy_Wire *self, moq_mux_container_Finished_legacy_Wire **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_fail(moq_mux_container_Producer_legacy_Wire *self, moq_Error *err_, moq_mux_container_Finished_legacy_Wire **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_abort(moq_mux_container_Producer_legacy_Wire *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_abort_unwanted(moq_mux_container_Producer_legacy_Wire *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_consume(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_broadcast(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_legacy_Wire_info(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_create_group(const moq_mux_container_Producer_legacy_Wire *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_legacy_Wire_append_group(const moq_mux_container_Producer_legacy_Wire *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_abort_unwanted(moq_mux_container_Producer_legacy_Wire *self, moq_Error *err_, moq_mux_container_Producer_legacy_Wire **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_consume(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_legacy_Wire_broadcast(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_legacy_Wire_info(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_create_group(const moq_mux_container_Producer_legacy_Wire *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_legacy_Wire_append_group(const moq_mux_container_Producer_legacy_Wire *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_legacy_Wire_skip_groups(const moq_mux_container_Producer_legacy_Wire *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_finished(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); typedef struct moq_mux_container_Producer_legacy_Wire_closed_future moq_mux_container_Producer_legacy_Wire_closed_future; -moq_mux_container_Producer_legacy_Wire_closed_future *moq_mux_container_Producer_legacy_Wire_closed(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_closed_start(const moq_mux_container_Producer_legacy_Wire *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_legacy_Wire_closed_poll(moq_mux_container_Producer_legacy_Wire_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_legacy_Wire_closed_future *moq_mux_container_Producer_legacy_Wire_closed(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_closed_start(const moq_mux_container_Producer_legacy_Wire *self, moq_Error **err, moq_mux_container_Producer_legacy_Wire_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_legacy_Wire_closed_poll(moq_mux_container_Producer_legacy_Wire_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_legacy_Wire_closed_future_free(moq_mux_container_Producer_legacy_Wire_closed_future *future); bool moq_mux_container_Producer_legacy_Wire_is_closed(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_legacy_Wire_largest(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); bool moq_mux_container_Producer_legacy_Wire_is_clone(const moq_mux_container_Producer_legacy_Wire *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_abort_handle(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_subscribe(const moq_mux_container_Producer_legacy_Wire *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_subscription(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_legacy_Wire_requests(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_legacy_Wire_abort_handle(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_legacy_Wire_subscribe(const moq_mux_container_Producer_legacy_Wire *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_legacy_Wire_subscription(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_legacy_Wire_requests(const moq_mux_container_Producer_legacy_Wire *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_AudioConfig_free(moq_mux_container_Producer_loc_Wire_AudioConfig *self); void moq_mux_container_Producer_loc_Wire_AudioConfig_drop(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_set(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_modify(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_loc_Wire_AudioConfig_name(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_loc_Wire_AudioConfig_demand(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_AudioConfig_estimate(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_set(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_hang_catalog_AudioConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_AudioConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_modify(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_container_Guard_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_timestamp(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_loc_Wire_AudioConfig_name(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_loc_Wire_AudioConfig_demand(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_AudioConfig_estimate(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_AudioConfig_reorder(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_loc_Wire_AudioConfig_history(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_AudioConfig_needs_keyframe(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -moq_mux_container_Producer_loc_Wire_AudioConfig *moq_mux_container_Producer_loc_Wire_AudioConfig_with_buffer(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_loc_Wire_AudioConfig *moq_mux_container_Producer_loc_Wire_AudioConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_AudioConfig *moq_mux_container_Producer_loc_Wire_AudioConfig_with_buffer(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_AudioConfig *moq_mux_container_Producer_loc_Wire_AudioConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_AudioConfig_report_skipped(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_AudioConfig_report_bitrate(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_loc_Wire_AudioConfig_track(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_loc_Wire_AudioConfig_track(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_loc_Wire_AudioConfig_live_edge(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_write(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_cut(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_seek(moq_mux_container_Producer_loc_Wire_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_discontinuity(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_finish(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_container_Finished_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_fail(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_write(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_cut(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_seek(moq_mux_container_Producer_loc_Wire_AudioConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_discontinuity(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_finish(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_mux_container_Finished_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_fail(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_AudioConfig_abort(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_abort_unwanted(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire_AudioConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_AudioConfig_consume(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_AudioConfig_broadcast(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_loc_Wire_AudioConfig_info(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_create_group(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_AudioConfig_append_group(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_abort_unwanted(moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire_AudioConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_AudioConfig_consume(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_AudioConfig_broadcast(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_loc_Wire_AudioConfig_info(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_create_group(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_AudioConfig_append_group(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_AudioConfig_skip_groups(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_AudioConfig_finished(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future; -moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future *moq_mux_container_Producer_loc_Wire_AudioConfig_closed(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_AudioConfig_closed_start(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_AudioConfig_closed_poll(moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future *moq_mux_container_Producer_loc_Wire_AudioConfig_closed(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_AudioConfig_closed_start(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_AudioConfig_closed_poll(moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future_free(moq_mux_container_Producer_loc_Wire_AudioConfig_closed_future *future); bool moq_mux_container_Producer_loc_Wire_AudioConfig_is_closed(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_AudioConfig_largest(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_AudioConfig_is_clone(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_AudioConfig_abort_handle(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_AudioConfig_subscribe(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_loc_Wire_AudioConfig_subscription(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_loc_Wire_AudioConfig_requests(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_AudioConfig_abort_handle(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_AudioConfig_subscribe(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_loc_Wire_AudioConfig_subscription(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_loc_Wire_AudioConfig_requests(const moq_mux_container_Producer_loc_Wire_AudioConfig *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_BinaryConfig_free(moq_mux_container_Producer_loc_Wire_BinaryConfig *self); void moq_mux_container_Producer_loc_Wire_BinaryConfig_drop(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_set(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_modify(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_loc_Wire_BinaryConfig_name(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_loc_Wire_BinaryConfig_demand(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_BinaryConfig_estimate(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_set(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_hang_catalog_BinaryConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_modify(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_container_Guard_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_timestamp(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_loc_Wire_BinaryConfig_name(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_loc_Wire_BinaryConfig_demand(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_BinaryConfig_estimate(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_BinaryConfig_reorder(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_loc_Wire_BinaryConfig_history(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_BinaryConfig_needs_keyframe(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -moq_mux_container_Producer_loc_Wire_BinaryConfig *moq_mux_container_Producer_loc_Wire_BinaryConfig_with_buffer(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_loc_Wire_BinaryConfig *moq_mux_container_Producer_loc_Wire_BinaryConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_BinaryConfig *moq_mux_container_Producer_loc_Wire_BinaryConfig_with_buffer(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_BinaryConfig *moq_mux_container_Producer_loc_Wire_BinaryConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_BinaryConfig_report_skipped(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_BinaryConfig_report_bitrate(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_loc_Wire_BinaryConfig_track(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_loc_Wire_BinaryConfig_track(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_loc_Wire_BinaryConfig_live_edge(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_write(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_cut(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_seek(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_discontinuity(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_finish(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_container_Finished_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_fail(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_write(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_cut(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_seek(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_discontinuity(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_finish(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_mux_container_Finished_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_fail(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire_BinaryConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_BinaryConfig_abort(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_abort_unwanted(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire_BinaryConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_BinaryConfig_consume(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_BinaryConfig_broadcast(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_loc_Wire_BinaryConfig_info(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_create_group(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_abort_unwanted(moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire_BinaryConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_BinaryConfig_consume(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_BinaryConfig_broadcast(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_loc_Wire_BinaryConfig_info(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_create_group(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_BinaryConfig_append_group(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_BinaryConfig_skip_groups(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_BinaryConfig_finished(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future; -moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future *moq_mux_container_Producer_loc_Wire_BinaryConfig_closed(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_start(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_poll(moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future *moq_mux_container_Producer_loc_Wire_BinaryConfig_closed(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_start(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_poll(moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future_free(moq_mux_container_Producer_loc_Wire_BinaryConfig_closed_future *future); bool moq_mux_container_Producer_loc_Wire_BinaryConfig_is_closed(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_BinaryConfig_largest(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_BinaryConfig_is_clone(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_BinaryConfig_abort_handle(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_BinaryConfig_subscribe(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_loc_Wire_BinaryConfig_subscription(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_loc_Wire_BinaryConfig_requests(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_BinaryConfig_abort_handle(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_BinaryConfig_subscribe(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_loc_Wire_BinaryConfig_subscription(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_loc_Wire_BinaryConfig_requests(const moq_mux_container_Producer_loc_Wire_BinaryConfig *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_JsonConfig_free(moq_mux_container_Producer_loc_Wire_JsonConfig *self); void moq_mux_container_Producer_loc_Wire_JsonConfig_drop(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_set(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_modify(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_loc_Wire_JsonConfig_name(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_loc_Wire_JsonConfig_demand(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_JsonConfig_estimate(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_set(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_hang_catalog_JsonConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_JsonConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_modify(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_container_Guard_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_timestamp(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_loc_Wire_JsonConfig_name(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_loc_Wire_JsonConfig_demand(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_JsonConfig_estimate(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_JsonConfig_reorder(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_loc_Wire_JsonConfig_history(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_JsonConfig_needs_keyframe(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -moq_mux_container_Producer_loc_Wire_JsonConfig *moq_mux_container_Producer_loc_Wire_JsonConfig_with_buffer(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_loc_Wire_JsonConfig *moq_mux_container_Producer_loc_Wire_JsonConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_JsonConfig *moq_mux_container_Producer_loc_Wire_JsonConfig_with_buffer(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_JsonConfig *moq_mux_container_Producer_loc_Wire_JsonConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_JsonConfig_report_skipped(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_JsonConfig_report_bitrate(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_loc_Wire_JsonConfig_track(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_loc_Wire_JsonConfig_track(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_loc_Wire_JsonConfig_live_edge(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_write(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_cut(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_seek(moq_mux_container_Producer_loc_Wire_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_discontinuity(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_finish(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_container_Finished_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_fail(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_write(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_cut(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_seek(moq_mux_container_Producer_loc_Wire_JsonConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_discontinuity(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_finish(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_mux_container_Finished_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_fail(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire_JsonConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_JsonConfig_abort(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_abort_unwanted(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire_JsonConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_JsonConfig_consume(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_JsonConfig_broadcast(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_loc_Wire_JsonConfig_info(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_create_group(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_JsonConfig_append_group(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_abort_unwanted(moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire_JsonConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_JsonConfig_consume(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_JsonConfig_broadcast(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_loc_Wire_JsonConfig_info(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_create_group(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_JsonConfig_append_group(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_JsonConfig_skip_groups(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_JsonConfig_finished(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future; -moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future *moq_mux_container_Producer_loc_Wire_JsonConfig_closed(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_JsonConfig_closed_start(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_JsonConfig_closed_poll(moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future *moq_mux_container_Producer_loc_Wire_JsonConfig_closed(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_JsonConfig_closed_start(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_JsonConfig_closed_poll(moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future_free(moq_mux_container_Producer_loc_Wire_JsonConfig_closed_future *future); bool moq_mux_container_Producer_loc_Wire_JsonConfig_is_closed(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_JsonConfig_largest(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_JsonConfig_is_clone(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_JsonConfig_abort_handle(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_JsonConfig_subscribe(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_loc_Wire_JsonConfig_subscription(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_loc_Wire_JsonConfig_requests(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_JsonConfig_abort_handle(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_JsonConfig_subscribe(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_loc_Wire_JsonConfig_subscription(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_loc_Wire_JsonConfig_requests(const moq_mux_container_Producer_loc_Wire_JsonConfig *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_TextConfig_free(moq_mux_container_Producer_loc_Wire_TextConfig *self); void moq_mux_container_Producer_loc_Wire_TextConfig_drop(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_set(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_modify(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_timestamp(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_loc_Wire_TextConfig_name(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_loc_Wire_TextConfig_demand(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_TextConfig_estimate(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_set(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_hang_catalog_TextConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_TextConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_modify(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_container_Guard_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_timestamp(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_loc_Wire_TextConfig_name(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_loc_Wire_TextConfig_demand(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_TextConfig_estimate(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_TextConfig_reorder(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_loc_Wire_TextConfig_history(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_TextConfig_needs_keyframe(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -moq_mux_container_Producer_loc_Wire_TextConfig *moq_mux_container_Producer_loc_Wire_TextConfig_with_buffer(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_loc_Wire_TextConfig *moq_mux_container_Producer_loc_Wire_TextConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_TextConfig *moq_mux_container_Producer_loc_Wire_TextConfig_with_buffer(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_TextConfig *moq_mux_container_Producer_loc_Wire_TextConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_TextConfig_report_skipped(const moq_mux_container_Producer_loc_Wire_TextConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_TextConfig_report_bitrate(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_loc_Wire_TextConfig_track(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_loc_Wire_TextConfig_track(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_loc_Wire_TextConfig_live_edge(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_write(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_cut(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_seek(moq_mux_container_Producer_loc_Wire_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_discontinuity(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_finish(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_container_Finished_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_fail(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_write(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_cut(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_seek(moq_mux_container_Producer_loc_Wire_TextConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_discontinuity(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_finish(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_mux_container_Finished_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_fail(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire_TextConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_TextConfig_abort(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_abort_unwanted(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire_TextConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_TextConfig_consume(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_TextConfig_broadcast(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_loc_Wire_TextConfig_info(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_create_group(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_TextConfig_append_group(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_abort_unwanted(moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire_TextConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_TextConfig_consume(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_TextConfig_broadcast(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_loc_Wire_TextConfig_info(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_create_group(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_TextConfig_append_group(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_TextConfig_skip_groups(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_TextConfig_finished(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_TextConfig_closed_future moq_mux_container_Producer_loc_Wire_TextConfig_closed_future; -moq_mux_container_Producer_loc_Wire_TextConfig_closed_future *moq_mux_container_Producer_loc_Wire_TextConfig_closed(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_TextConfig_closed_start(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_TextConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_TextConfig_closed_poll(moq_mux_container_Producer_loc_Wire_TextConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_TextConfig_closed_future *moq_mux_container_Producer_loc_Wire_TextConfig_closed(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_TextConfig_closed_start(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_TextConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_TextConfig_closed_poll(moq_mux_container_Producer_loc_Wire_TextConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_loc_Wire_TextConfig_closed_future_free(moq_mux_container_Producer_loc_Wire_TextConfig_closed_future *future); bool moq_mux_container_Producer_loc_Wire_TextConfig_is_closed(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_TextConfig_largest(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_TextConfig_is_clone(const moq_mux_container_Producer_loc_Wire_TextConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_TextConfig_abort_handle(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_TextConfig_subscribe(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_loc_Wire_TextConfig_subscription(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_loc_Wire_TextConfig_requests(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_TextConfig_abort_handle(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_TextConfig_subscribe(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_loc_Wire_TextConfig_subscription(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_loc_Wire_TextConfig_requests(const moq_mux_container_Producer_loc_Wire_TextConfig *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_VideoConfig_free(moq_mux_container_Producer_loc_Wire_VideoConfig *self); void moq_mux_container_Producer_loc_Wire_VideoConfig_drop(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_set(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_modify(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_loc_Wire_VideoConfig_name(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_loc_Wire_VideoConfig_demand(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_VideoConfig_estimate(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_set(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_hang_catalog_VideoConfig *config, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_set_bitrate(moq_mux_container_Producer_loc_Wire_VideoConfig *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_modify(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_container_Guard_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_timestamp(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_loc_Wire_VideoConfig_name(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_loc_Wire_VideoConfig_demand(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_VideoConfig_estimate(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_VideoConfig_reorder(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_loc_Wire_VideoConfig_history(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_VideoConfig_needs_keyframe(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -moq_mux_container_Producer_loc_Wire_VideoConfig *moq_mux_container_Producer_loc_Wire_VideoConfig_with_buffer(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_loc_Wire_VideoConfig *moq_mux_container_Producer_loc_Wire_VideoConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_VideoConfig *moq_mux_container_Producer_loc_Wire_VideoConfig_with_buffer(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_VideoConfig *moq_mux_container_Producer_loc_Wire_VideoConfig_with_bandwidth(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_VideoConfig_report_skipped(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_VideoConfig_report_bitrate(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_loc_Wire_VideoConfig_track(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_loc_Wire_VideoConfig_track(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_loc_Wire_VideoConfig_live_edge(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_write(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_cut(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_seek(moq_mux_container_Producer_loc_Wire_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_discontinuity(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_finish(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_container_Finished_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_fail(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_write(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_cut(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_seek(moq_mux_container_Producer_loc_Wire_VideoConfig *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_discontinuity(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_finish(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_mux_container_Finished_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_fail(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_VideoConfig_abort(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_abort_unwanted(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire_VideoConfig **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_VideoConfig_consume(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_VideoConfig_broadcast(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_loc_Wire_VideoConfig_info(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_create_group(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_VideoConfig_append_group(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_abort_unwanted(moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire_VideoConfig **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_VideoConfig_consume(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_VideoConfig_broadcast(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_loc_Wire_VideoConfig_info(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_create_group(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_VideoConfig_append_group(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_VideoConfig_skip_groups(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_VideoConfig_finished(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future; -moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future *moq_mux_container_Producer_loc_Wire_VideoConfig_closed(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_VideoConfig_closed_start(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_VideoConfig_closed_poll(moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future *moq_mux_container_Producer_loc_Wire_VideoConfig_closed(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_VideoConfig_closed_start(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_VideoConfig_closed_poll(moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future_free(moq_mux_container_Producer_loc_Wire_VideoConfig_closed_future *future); bool moq_mux_container_Producer_loc_Wire_VideoConfig_is_closed(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_VideoConfig_largest(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_VideoConfig_is_clone(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_VideoConfig_abort_handle(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_VideoConfig_subscribe(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_loc_Wire_VideoConfig_subscription(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_loc_Wire_VideoConfig_requests(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_VideoConfig_abort_handle(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_VideoConfig_subscribe(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_loc_Wire_VideoConfig_subscription(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_loc_Wire_VideoConfig_requests(const moq_mux_container_Producer_loc_Wire_VideoConfig *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_free(moq_mux_container_Producer_loc_Wire *self); void moq_mux_container_Producer_loc_Wire_drop(moq_mux_container_Producer_loc_Wire *self, moq_status *status); -moq_mux_container_Producer_loc_Wire *moq_mux_container_Producer_loc_Wire_new(moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_set(moq_mux_container_Producer_loc_Wire *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_set_bitrate(moq_mux_container_Producer_loc_Wire *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_modify(moq_mux_container_Producer_loc_Wire *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_timestamp(const moq_mux_container_Producer_loc_Wire *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_container_Producer_loc_Wire_name(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -moq_track_Demand *moq_mux_container_Producer_loc_Wire_demand(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_estimate(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire *moq_mux_container_Producer_loc_Wire_new(moq_track_Producer *track, moq_mux_container_loc_Wire container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_set(moq_mux_container_Producer_loc_Wire *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_set_bitrate(moq_mux_container_Producer_loc_Wire *self, uint64_t bitrate, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_modify(moq_mux_container_Producer_loc_Wire *self, moq_mux_container_Guard_unit **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_timestamp(const moq_mux_container_Producer_loc_Wire *self, moq_option_Timestamp hint, moq_Timestamp *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_Producer_loc_Wire_name(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_container_Producer_loc_Wire_demand(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Estimate *moq_mux_container_Producer_loc_Wire_estimate(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); void moq_mux_container_Producer_loc_Wire_reorder(moq_mux_container_Producer_loc_Wire *self, moq_Timestamp delay, moq_status *status); void moq_mux_container_Producer_loc_Wire_history(moq_mux_container_Producer_loc_Wire *self, moq_Timestamp until, moq_status *status); bool moq_mux_container_Producer_loc_Wire_needs_keyframe(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -moq_mux_container_Producer_loc_Wire *moq_mux_container_Producer_loc_Wire_with_buffer(moq_mux_container_Producer_loc_Wire *self, moq_duration duration, moq_status *status); -moq_mux_container_Producer_loc_Wire *moq_mux_container_Producer_loc_Wire_with_bandwidth(moq_mux_container_Producer_loc_Wire *self, moq_bandwidth_Allocator *allocator, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire *moq_mux_container_Producer_loc_Wire_with_buffer(moq_mux_container_Producer_loc_Wire *self, moq_duration duration, moq_status *status); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire *moq_mux_container_Producer_loc_Wire_with_bandwidth(moq_mux_container_Producer_loc_Wire *self, moq_bandwidth_Allocator *allocator, moq_status *status); void moq_mux_container_Producer_loc_Wire_report_skipped(const moq_mux_container_Producer_loc_Wire *self, uint64_t frames, moq_status *status); void moq_mux_container_Producer_loc_Wire_report_bitrate(const moq_mux_container_Producer_loc_Wire *self, moq_bandwidth_Rate bitrate, moq_status *status); -moq_track_Producer *moq_mux_container_Producer_loc_Wire_track(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_container_Producer_loc_Wire_track(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); moq_option_Timestamp moq_mux_container_Producer_loc_Wire_live_edge(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_write(moq_mux_container_Producer_loc_Wire *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_cut(moq_mux_container_Producer_loc_Wire *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_seek(moq_mux_container_Producer_loc_Wire *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_discontinuity(moq_mux_container_Producer_loc_Wire *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_finish(moq_mux_container_Producer_loc_Wire *self, moq_mux_container_Finished_loc_Wire **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_fail(moq_mux_container_Producer_loc_Wire *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_write(moq_mux_container_Producer_loc_Wire *self, moq_mux_container_Frame frame, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_cut(moq_mux_container_Producer_loc_Wire *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_seek(moq_mux_container_Producer_loc_Wire *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_discontinuity(moq_mux_container_Producer_loc_Wire *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_finish(moq_mux_container_Producer_loc_Wire *self, moq_mux_container_Finished_loc_Wire **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_fail(moq_mux_container_Producer_loc_Wire *self, moq_Error *err_, moq_mux_container_Finished_loc_Wire **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_abort(moq_mux_container_Producer_loc_Wire *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_abort_unwanted(moq_mux_container_Producer_loc_Wire *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire **err, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_consume(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_broadcast(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -moq_track_Info *moq_mux_container_Producer_loc_Wire_info(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_create_group(const moq_mux_container_Producer_loc_Wire *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); -bool moq_mux_container_Producer_loc_Wire_append_group(const moq_mux_container_Producer_loc_Wire *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_abort_unwanted(moq_mux_container_Producer_loc_Wire *self, moq_Error *err_, moq_mux_container_Producer_loc_Wire **err, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_consume(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Info *moq_mux_container_Producer_loc_Wire_broadcast(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Info *moq_mux_container_Producer_loc_Wire_info(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_create_group(const moq_mux_container_Producer_loc_Wire *self, moq_group_Info group, moq_group_Producer **out, moq_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_Producer_loc_Wire_append_group(const moq_mux_container_Producer_loc_Wire *self, moq_Timestamp start, moq_group_Producer **out, moq_Error **err, moq_status *status); void moq_mux_container_Producer_loc_Wire_skip_groups(const moq_mux_container_Producer_loc_Wire *self, moq_range_u64 groups, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_finished(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); typedef struct moq_mux_container_Producer_loc_Wire_closed_future moq_mux_container_Producer_loc_Wire_closed_future; -moq_mux_container_Producer_loc_Wire_closed_future *moq_mux_container_Producer_loc_Wire_closed(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_closed_start(const moq_mux_container_Producer_loc_Wire *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_closed_future **future, moq_status *status); -moq_poll moq_mux_container_Producer_loc_Wire_closed_poll(moq_mux_container_Producer_loc_Wire_closed_future *future, moq_waker waker, moq_Error **err); +MOQ_MUST_USE moq_mux_container_Producer_loc_Wire_closed_future *moq_mux_container_Producer_loc_Wire_closed(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_closed_start(const moq_mux_container_Producer_loc_Wire *self, moq_Error **err, moq_mux_container_Producer_loc_Wire_closed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_Producer_loc_Wire_closed_poll(moq_mux_container_Producer_loc_Wire_closed_future *future, moq_waker waker, moq_Error **err); void moq_mux_container_Producer_loc_Wire_closed_future_free(moq_mux_container_Producer_loc_Wire_closed_future *future); bool moq_mux_container_Producer_loc_Wire_is_closed(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); moq_option_track_Position moq_mux_container_Producer_loc_Wire_largest(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); bool moq_mux_container_Producer_loc_Wire_is_clone(const moq_mux_container_Producer_loc_Wire *self, const moq_track_Producer *other, moq_status *status); -moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_abort_handle(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_subscribe(const moq_mux_container_Producer_loc_Wire *self, moq_track_Subscription *subscription, moq_status *status); -moq_track_Subscription *moq_mux_container_Producer_loc_Wire_subscription(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); -moq_track_Requests *moq_mux_container_Producer_loc_Wire_requests(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_AbortHandle *moq_mux_container_Producer_loc_Wire_abort_handle(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_container_Producer_loc_Wire_subscribe(const moq_mux_container_Producer_loc_Wire *self, moq_track_Subscription *subscription, moq_status *status); +MOQ_MUST_USE moq_track_Subscription *moq_mux_container_Producer_loc_Wire_subscription(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); +MOQ_MUST_USE moq_track_Requests *moq_mux_container_Producer_loc_Wire_requests(const moq_mux_container_Producer_loc_Wire *self, moq_status *status); void moq_mux_follow_Instances_free(moq_mux_follow_Instances *self); void moq_mux_follow_Instances_drop(moq_mux_follow_Instances *self, moq_status *status); typedef struct moq_mux_follow_Instances_next_future moq_mux_follow_Instances_next_future; -moq_mux_follow_Instances_next_future *moq_mux_follow_Instances_next(moq_mux_follow_Instances *self, moq_status *status); -moq_poll moq_mux_follow_Instances_next_start(moq_mux_follow_Instances *self, moq_broadcast_Consumer **out, moq_mux_Error **err, moq_mux_follow_Instances_next_future **future, moq_status *status); -moq_poll moq_mux_follow_Instances_next_poll(moq_mux_follow_Instances_next_future *future, moq_waker waker, moq_broadcast_Consumer **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_follow_Instances_next_future *moq_mux_follow_Instances_next(moq_mux_follow_Instances *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_follow_Instances_next_start(moq_mux_follow_Instances *self, moq_broadcast_Consumer **out, moq_mux_Error **err, moq_mux_follow_Instances_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_follow_Instances_next_poll(moq_mux_follow_Instances_next_future *future, moq_waker waker, moq_broadcast_Consumer **out, moq_mux_Error **err); void moq_mux_follow_Instances_next_future_free(moq_mux_follow_Instances_next_future *future); void moq_mux_import_Container_free(moq_mux_import_Container *self); void moq_mux_import_Container_drop(moq_mux_import_Container *self, moq_status *status); -bool moq_mux_import_Container_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, const moq_mux_import_ContainerInit *init, moq_mux_import_Container **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Container_decode(moq_mux_import_Container *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Container_finish(moq_mux_import_Container *self, moq_mux_import_container_Finished **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, const moq_mux_import_ContainerInit *init, moq_mux_import_Container **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_decode(moq_mux_import_Container *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_finish(moq_mux_import_Container *self, moq_mux_import_container_Finished **out, moq_mux_Error **err, moq_status *status); void moq_mux_import_Container_abort(moq_mux_import_Container *self, moq_Error *err_, moq_status *status); -bool moq_mux_import_Container_cut(moq_mux_import_Container *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Container_seek(moq_mux_import_Container *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_cut(moq_mux_import_Container *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_seek(moq_mux_import_Container *self, uint64_t start, moq_mux_Error **err, moq_status *status); void moq_mux_import_Container_Extra_free(moq_mux_import_Container_Extra *self); void moq_mux_import_Container_Extra_drop(moq_mux_import_Container_Extra *self, moq_status *status); -bool moq_mux_import_Container_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, const moq_mux_import_ContainerInit *init, moq_mux_import_Container_Extra **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Container_Extra_decode(moq_mux_import_Container_Extra *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Container_Extra_finish(moq_mux_import_Container_Extra *self, moq_mux_import_container_Finished_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, const moq_mux_import_ContainerInit *init, moq_mux_import_Container_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_Extra_decode(moq_mux_import_Container_Extra *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_Extra_finish(moq_mux_import_Container_Extra *self, moq_mux_import_container_Finished_Extra **out, moq_mux_Error **err, moq_status *status); void moq_mux_import_Container_Extra_abort(moq_mux_import_Container_Extra *self, moq_Error *err_, moq_status *status); -bool moq_mux_import_Container_Extra_cut(moq_mux_import_Container_Extra *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Container_Extra_seek(moq_mux_import_Container_Extra *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_Extra_cut(moq_mux_import_Container_Extra *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_Extra_seek(moq_mux_import_Container_Extra *self, uint64_t start, moq_mux_Error **err, moq_status *status); void moq_mux_import_Container_Ext_free(moq_mux_import_Container_Ext *self); void moq_mux_import_Container_Ext_drop(moq_mux_import_Container_Ext *self, moq_status *status); -bool moq_mux_import_Container_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, const moq_mux_import_ContainerInit *init, moq_mux_import_Container_Ext **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Container_Ext_decode(moq_mux_import_Container_Ext *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Container_Ext_finish(moq_mux_import_Container_Ext *self, moq_mux_import_container_Finished_Ext **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, const moq_mux_import_ContainerInit *init, moq_mux_import_Container_Ext **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_Ext_decode(moq_mux_import_Container_Ext *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_Ext_finish(moq_mux_import_Container_Ext *self, moq_mux_import_container_Finished_Ext **out, moq_mux_Error **err, moq_status *status); void moq_mux_import_Container_Ext_abort(moq_mux_import_Container_Ext *self, moq_Error *err_, moq_status *status); -bool moq_mux_import_Container_Ext_cut(moq_mux_import_Container_Ext *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Container_Ext_seek(moq_mux_import_Container_Ext *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_Ext_cut(moq_mux_import_Container_Ext *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Container_Ext_seek(moq_mux_import_Container_Ext *self, uint64_t start, moq_mux_Error **err, moq_status *status); void moq_mux_import_AudioInit_free(moq_mux_import_AudioInit *self); void moq_mux_import_AudioInit_drop(moq_mux_import_AudioInit *self, moq_status *status); -moq_mux_import_AudioInit *moq_mux_import_AudioInit_clone(const moq_mux_import_AudioInit *self, moq_status *status); +MOQ_MUST_USE moq_mux_import_AudioInit *moq_mux_import_AudioInit_clone(const moq_mux_import_AudioInit *self, moq_status *status); bool moq_mux_import_AudioInit_eq(const moq_mux_import_AudioInit *a, const moq_mux_import_AudioInit *b, moq_status *status); -moq_buf moq_mux_import_AudioInit_debug(const moq_mux_import_AudioInit *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_import_AudioInit_debug(const moq_mux_import_AudioInit *self, moq_status *status); moq_mux_import_AudioFormat moq_mux_import_AudioInit_format_get(const moq_mux_import_AudioInit *self, moq_status *status); void moq_mux_import_AudioInit_format_set(moq_mux_import_AudioInit *self, moq_mux_import_AudioFormat value, moq_status *status); -moq_buf moq_mux_import_AudioInit_data_get(const moq_mux_import_AudioInit *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_import_AudioInit_data_get(const moq_mux_import_AudioInit *self, moq_status *status); void moq_mux_import_AudioInit_data_set(moq_mux_import_AudioInit *self, moq_buf value, moq_status *status); -moq_buf moq_mux_import_AudioInit_label_get(const moq_mux_import_AudioInit *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_import_AudioInit_label_get(const moq_mux_import_AudioInit *self, moq_status *status); void moq_mux_import_AudioInit_label_set(moq_mux_import_AudioInit *self, moq_buf value, moq_status *status); -moq_hang_catalog_Container *moq_mux_import_AudioInit_container_get(const moq_mux_import_AudioInit *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Container *moq_mux_import_AudioInit_container_get(const moq_mux_import_AudioInit *self, moq_status *status); void moq_mux_import_AudioInit_container_set(moq_mux_import_AudioInit *self, moq_hang_catalog_Container *value, moq_status *status); moq_option_u64 moq_mux_import_AudioInit_bitrate_get(const moq_mux_import_AudioInit *self, moq_status *status); void moq_mux_import_AudioInit_bitrate_set(moq_mux_import_AudioInit *self, moq_option_u64 value, moq_status *status); -moq_mux_import_AudioInit *moq_mux_import_AudioInit_new(moq_mux_import_AudioFormat format, moq_buf data_); +MOQ_MUST_USE moq_mux_import_AudioInit *moq_mux_import_AudioInit_new(moq_mux_import_AudioFormat format, moq_buf data_); void moq_mux_import_ContainerInit_free(moq_mux_import_ContainerInit *self); void moq_mux_import_ContainerInit_drop(moq_mux_import_ContainerInit *self, moq_status *status); -moq_mux_import_ContainerInit *moq_mux_import_ContainerInit_clone(const moq_mux_import_ContainerInit *self, moq_status *status); +MOQ_MUST_USE moq_mux_import_ContainerInit *moq_mux_import_ContainerInit_clone(const moq_mux_import_ContainerInit *self, moq_status *status); bool moq_mux_import_ContainerInit_eq(const moq_mux_import_ContainerInit *a, const moq_mux_import_ContainerInit *b, moq_status *status); -moq_buf moq_mux_import_ContainerInit_debug(const moq_mux_import_ContainerInit *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_import_ContainerInit_debug(const moq_mux_import_ContainerInit *self, moq_status *status); moq_mux_import_ContainerFormat moq_mux_import_ContainerInit_format_get(const moq_mux_import_ContainerInit *self, moq_status *status); void moq_mux_import_ContainerInit_format_set(moq_mux_import_ContainerInit *self, moq_mux_import_ContainerFormat value, moq_status *status); -moq_buf moq_mux_import_ContainerInit_data_get(const moq_mux_import_ContainerInit *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_import_ContainerInit_data_get(const moq_mux_import_ContainerInit *self, moq_status *status); void moq_mux_import_ContainerInit_data_set(moq_mux_import_ContainerInit *self, moq_buf value, moq_status *status); -moq_mux_import_ContainerInit *moq_mux_import_ContainerInit_new(moq_mux_import_ContainerFormat format, moq_buf data_); +MOQ_MUST_USE moq_mux_import_ContainerInit *moq_mux_import_ContainerInit_new(moq_mux_import_ContainerFormat format, moq_buf data_); void moq_mux_import_VideoInit_free(moq_mux_import_VideoInit *self); void moq_mux_import_VideoInit_drop(moq_mux_import_VideoInit *self, moq_status *status); -moq_mux_import_VideoInit *moq_mux_import_VideoInit_clone(const moq_mux_import_VideoInit *self, moq_status *status); +MOQ_MUST_USE moq_mux_import_VideoInit *moq_mux_import_VideoInit_clone(const moq_mux_import_VideoInit *self, moq_status *status); bool moq_mux_import_VideoInit_eq(const moq_mux_import_VideoInit *a, const moq_mux_import_VideoInit *b, moq_status *status); -moq_buf moq_mux_import_VideoInit_debug(const moq_mux_import_VideoInit *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_import_VideoInit_debug(const moq_mux_import_VideoInit *self, moq_status *status); moq_mux_import_VideoFormat moq_mux_import_VideoInit_format_get(const moq_mux_import_VideoInit *self, moq_status *status); void moq_mux_import_VideoInit_format_set(moq_mux_import_VideoInit *self, moq_mux_import_VideoFormat value, moq_status *status); -moq_buf moq_mux_import_VideoInit_data_get(const moq_mux_import_VideoInit *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_import_VideoInit_data_get(const moq_mux_import_VideoInit *self, moq_status *status); void moq_mux_import_VideoInit_data_set(moq_mux_import_VideoInit *self, moq_buf value, moq_status *status); -moq_buf moq_mux_import_VideoInit_label_get(const moq_mux_import_VideoInit *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_import_VideoInit_label_get(const moq_mux_import_VideoInit *self, moq_status *status); void moq_mux_import_VideoInit_label_set(moq_mux_import_VideoInit *self, moq_buf value, moq_status *status); -moq_mux_catalog_VideoHint *moq_mux_import_VideoInit_hint_get(const moq_mux_import_VideoInit *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_VideoHint *moq_mux_import_VideoInit_hint_get(const moq_mux_import_VideoInit *self, moq_status *status); void moq_mux_import_VideoInit_hint_set(moq_mux_import_VideoInit *self, moq_mux_catalog_VideoHint *value, moq_status *status); int8_t moq_mux_import_VideoInit_priority_get(const moq_mux_import_VideoInit *self, moq_status *status); void moq_mux_import_VideoInit_priority_set(moq_mux_import_VideoInit *self, int8_t value, moq_status *status); -moq_mux_import_VideoInit *moq_mux_import_VideoInit_new(moq_mux_import_VideoFormat format, moq_buf data_); +MOQ_MUST_USE moq_mux_import_VideoInit *moq_mux_import_VideoInit_new(moq_mux_import_VideoFormat format, moq_buf data_); void moq_mux_import_Track_free(moq_mux_import_Track *self); void moq_mux_import_Track_drop(moq_mux_import_Track *self, moq_status *status); -bool moq_mux_import_Track_audio_Extra(moq_track_Request *request, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_import_AudioInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Track_audio_Ext(moq_track_Request *request, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_import_AudioInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Track_audio_unit(moq_track_Request *request, moq_mux_catalog_Reserved *reserved, moq_mux_import_AudioInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Track_video_Extra(moq_track_Request *request, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_import_VideoInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Track_video_Ext(moq_track_Request *request, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_import_VideoInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Track_video_unit(moq_track_Request *request, moq_mux_catalog_Reserved *reserved, moq_mux_import_VideoInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Track_decode(moq_mux_import_Track *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Track_finish(moq_mux_import_Track *self, moq_mux_import_track_Finished **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_audio_Extra(moq_track_Request *request, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_import_AudioInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_audio_Ext(moq_track_Request *request, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_import_AudioInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_audio_unit(moq_track_Request *request, moq_mux_catalog_Reserved *reserved, moq_mux_import_AudioInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_video_Extra(moq_track_Request *request, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_import_VideoInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_video_Ext(moq_track_Request *request, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_import_VideoInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_video_unit(moq_track_Request *request, moq_mux_catalog_Reserved *reserved, moq_mux_import_VideoInit *init, moq_mux_import_Track **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_decode(moq_mux_import_Track *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_finish(moq_mux_import_Track *self, moq_mux_import_track_Finished **out, moq_mux_Error **err, moq_status *status); void moq_mux_import_Track_abort(moq_mux_import_Track *self, moq_Error *err_, moq_status *status); -bool moq_mux_import_Track_abort_unwanted(moq_mux_import_Track *self, moq_Error *err_, moq_mux_import_Track **err, moq_status *status); -bool moq_mux_import_Track_cut(moq_mux_import_Track *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Track_discontinuity(moq_mux_import_Track *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Track_set_enabled(moq_mux_import_Track *self, bool enabled, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_Track_seek(moq_mux_import_Track *self, uint64_t start, moq_mux_Error **err, moq_status *status); -moq_track_Demand *moq_mux_import_Track_demand(const moq_mux_import_Track *self, moq_status *status); -moq_buf moq_mux_import_Track_name(const moq_mux_import_Track *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_abort_unwanted(moq_mux_import_Track *self, moq_Error *err_, moq_mux_import_Track **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_cut(moq_mux_import_Track *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_discontinuity(moq_mux_import_Track *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_set_enabled(moq_mux_import_Track *self, bool enabled, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_Track_seek(moq_mux_import_Track *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_import_Track_demand(const moq_mux_import_Track *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_import_Track_name(const moq_mux_import_Track *self, moq_status *status); void moq_mux_import_TrackStream_free(moq_mux_import_TrackStream *self); void moq_mux_import_TrackStream_drop(moq_mux_import_TrackStream *self, moq_status *status); -bool moq_mux_import_TrackStream_video_Extra(moq_track_Request *request, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_import_VideoInit *init, moq_mux_import_TrackStream **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_TrackStream_video_Ext(moq_track_Request *request, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_import_VideoInit *init, moq_mux_import_TrackStream **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_TrackStream_video_unit(moq_track_Request *request, moq_mux_catalog_Reserved *reserved, moq_mux_import_VideoInit *init, moq_mux_import_TrackStream **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_TrackStream_initialize(moq_mux_import_TrackStream *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_TrackStream_decode(moq_mux_import_TrackStream *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_TrackStream_finish(moq_mux_import_TrackStream *self, moq_mux_import_track_Finished **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_TrackStream_set_enabled(moq_mux_import_TrackStream *self, bool enabled, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_TrackStream_video_Extra(moq_track_Request *request, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_import_VideoInit *init, moq_mux_import_TrackStream **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_TrackStream_video_Ext(moq_track_Request *request, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_import_VideoInit *init, moq_mux_import_TrackStream **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_TrackStream_video_unit(moq_track_Request *request, moq_mux_catalog_Reserved *reserved, moq_mux_import_VideoInit *init, moq_mux_import_TrackStream **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_TrackStream_initialize(moq_mux_import_TrackStream *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_TrackStream_decode(moq_mux_import_TrackStream *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_TrackStream_finish(moq_mux_import_TrackStream *self, moq_mux_import_track_Finished **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_TrackStream_set_enabled(moq_mux_import_TrackStream *self, bool enabled, moq_mux_Error **err, moq_status *status); void moq_mux_import_TrackStream_abort(moq_mux_import_TrackStream *self, moq_Error *err_, moq_status *status); -bool moq_mux_import_TrackStream_abort_unwanted(moq_mux_import_TrackStream *self, moq_Error *err_, moq_mux_import_TrackStream **err, moq_status *status); -bool moq_mux_import_TrackStream_cut(moq_mux_import_TrackStream *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_import_TrackStream_seek(moq_mux_import_TrackStream *self, uint64_t start, moq_mux_Error **err, moq_status *status); -moq_track_Demand *moq_mux_import_TrackStream_demand(const moq_mux_import_TrackStream *self, moq_status *status); -moq_buf moq_mux_import_TrackStream_name(const moq_mux_import_TrackStream *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_TrackStream_abort_unwanted(moq_mux_import_TrackStream *self, moq_Error *err_, moq_mux_import_TrackStream **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_TrackStream_cut(moq_mux_import_TrackStream *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_import_TrackStream_seek(moq_mux_import_TrackStream *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_import_TrackStream_demand(const moq_mux_import_TrackStream *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_import_TrackStream_name(const moq_mux_import_TrackStream *self, moq_status *status); void moq_mux_json_Snapshot_Json_free(moq_mux_json_Snapshot_Json *self); void moq_mux_json_Snapshot_Json_drop(moq_mux_json_Snapshot_Json *self, moq_status *status); -moq_buf moq_mux_json_Snapshot_Json_name(const moq_mux_json_Snapshot_Json *self, moq_status *status); -moq_track_Subscriber *moq_mux_json_Snapshot_Json_consume(const moq_mux_json_Snapshot_Json *self, moq_status *status); -moq_track_Demand *moq_mux_json_Snapshot_Json_demand(const moq_mux_json_Snapshot_Json *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_json_Snapshot_Json_name(const moq_mux_json_Snapshot_Json *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_json_Snapshot_Json_consume(const moq_mux_json_Snapshot_Json *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_json_Snapshot_Json_demand(const moq_mux_json_Snapshot_Json *self, moq_status *status); typedef struct moq_mux_json_Snapshot_Json_refresh_future moq_mux_json_Snapshot_Json_refresh_future; -moq_mux_json_Snapshot_Json_refresh_future *moq_mux_json_Snapshot_Json_refresh(const moq_mux_json_Snapshot_Json *self, moq_status *status); -moq_poll moq_mux_json_Snapshot_Json_refresh_start(const moq_mux_json_Snapshot_Json *self, moq_mux_Error **err, moq_mux_json_Snapshot_Json_refresh_future **future, moq_status *status); -moq_poll moq_mux_json_Snapshot_Json_refresh_poll(moq_mux_json_Snapshot_Json_refresh_future *future, moq_waker waker, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_json_Snapshot_Json_refresh_future *moq_mux_json_Snapshot_Json_refresh(const moq_mux_json_Snapshot_Json *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_json_Snapshot_Json_refresh_start(const moq_mux_json_Snapshot_Json *self, moq_mux_Error **err, moq_mux_json_Snapshot_Json_refresh_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_json_Snapshot_Json_refresh_poll(moq_mux_json_Snapshot_Json_refresh_future *future, moq_waker waker, moq_mux_Error **err); void moq_mux_json_Snapshot_Json_refresh_future_free(moq_mux_json_Snapshot_Json_refresh_future *future); -bool moq_mux_json_Snapshot_Json_update(moq_mux_json_Snapshot_Json *self, const moq_Json *value, moq_Timestamp timestamp, moq_mux_Error **err, moq_status *status); -bool moq_mux_json_Snapshot_Json_finish(moq_mux_json_Snapshot_Json *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_json_Snapshot_Json_abort(moq_mux_json_Snapshot_Json *self, moq_Error *err_, moq_mux_Error **err, moq_status *status); -bool moq_mux_json_Snapshot_Json_abort_unwanted(moq_mux_json_Snapshot_Json *self, moq_Error *err_, moq_mux_json_Snapshot_Json **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_json_Snapshot_Json_update(moq_mux_json_Snapshot_Json *self, const moq_Json *value, moq_Timestamp timestamp, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_json_Snapshot_Json_finish(moq_mux_json_Snapshot_Json *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_json_Snapshot_Json_abort(moq_mux_json_Snapshot_Json *self, moq_Error *err_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_json_Snapshot_Json_abort_unwanted(moq_mux_json_Snapshot_Json *self, moq_Error *err_, moq_mux_json_Snapshot_Json **err, moq_status *status); void moq_mux_json_Stream_Json_free(moq_mux_json_Stream_Json *self); void moq_mux_json_Stream_Json_drop(moq_mux_json_Stream_Json *self, moq_status *status); -moq_buf moq_mux_json_Stream_Json_name(const moq_mux_json_Stream_Json *self, moq_status *status); -moq_track_Subscriber *moq_mux_json_Stream_Json_consume(const moq_mux_json_Stream_Json *self, moq_status *status); -moq_track_Demand *moq_mux_json_Stream_Json_demand(const moq_mux_json_Stream_Json *self, moq_status *status); -bool moq_mux_json_Stream_Json_append(moq_mux_json_Stream_Json *self, const moq_Json *value, moq_Timestamp timestamp, moq_mux_Error **err, moq_status *status); -bool moq_mux_json_Stream_Json_finish(moq_mux_json_Stream_Json *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_json_Stream_Json_abort(moq_mux_json_Stream_Json *self, moq_Error *err_, moq_mux_Error **err, moq_status *status); -bool moq_mux_json_Stream_Json_abort_unwanted(moq_mux_json_Stream_Json *self, moq_Error *err_, moq_mux_json_Stream_Json **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_json_Stream_Json_name(const moq_mux_json_Stream_Json *self, moq_status *status); +MOQ_MUST_USE moq_track_Subscriber *moq_mux_json_Stream_Json_consume(const moq_mux_json_Stream_Json *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_json_Stream_Json_demand(const moq_mux_json_Stream_Json *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_json_Stream_Json_append(moq_mux_json_Stream_Json *self, const moq_Json *value, moq_Timestamp timestamp, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_json_Stream_Json_finish(moq_mux_json_Stream_Json *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_json_Stream_Json_abort(moq_mux_json_Stream_Json *self, moq_Error *err_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_json_Stream_Json_abort_unwanted(moq_mux_json_Stream_Json *self, moq_Error *err_, moq_mux_json_Stream_Json **err, moq_status *status); void moq_mux_json_Consumer_Json_free(moq_mux_json_Consumer_Json *self); void moq_mux_json_Consumer_Json_drop(moq_mux_json_Consumer_Json *self, moq_status *status); typedef struct moq_mux_json_Consumer_Json_from_track_future moq_mux_json_Consumer_Json_from_track_future; -moq_mux_json_Consumer_Json_from_track_future *moq_mux_json_Consumer_Json_from_track(moq_track_Consumer *track, const moq_hang_catalog_JsonConfig *config, moq_status *status); -moq_poll moq_mux_json_Consumer_Json_from_track_start(moq_track_Consumer *track, const moq_hang_catalog_JsonConfig *config, moq_mux_json_Consumer_Json **out, moq_mux_Error **err, moq_mux_json_Consumer_Json_from_track_future **future, moq_status *status); -moq_poll moq_mux_json_Consumer_Json_from_track_poll(moq_mux_json_Consumer_Json_from_track_future *future, moq_waker waker, moq_mux_json_Consumer_Json **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_json_Consumer_Json_from_track_future *moq_mux_json_Consumer_Json_from_track(moq_track_Consumer *track, const moq_hang_catalog_JsonConfig *config, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_json_Consumer_Json_from_track_start(moq_track_Consumer *track, const moq_hang_catalog_JsonConfig *config, moq_mux_json_Consumer_Json **out, moq_mux_Error **err, moq_mux_json_Consumer_Json_from_track_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_json_Consumer_Json_from_track_poll(moq_mux_json_Consumer_Json_from_track_future *future, moq_waker waker, moq_mux_json_Consumer_Json **out, moq_mux_Error **err); void moq_mux_json_Consumer_Json_from_track_future_free(moq_mux_json_Consumer_Json_from_track_future *future); -moq_hang_catalog_Mode moq_mux_json_Consumer_Json_mode(const moq_mux_json_Consumer_Json *self, moq_status *status); +MOQ_MUST_USE moq_hang_catalog_Mode moq_mux_json_Consumer_Json_mode(const moq_mux_json_Consumer_Json *self, moq_status *status); typedef struct moq_mux_json_Consumer_Json_next_future moq_mux_json_Consumer_Json_next_future; -moq_mux_json_Consumer_Json_next_future *moq_mux_json_Consumer_Json_next(moq_mux_json_Consumer_Json *self, moq_status *status); -moq_poll moq_mux_json_Consumer_Json_next_start(moq_mux_json_Consumer_Json *self, moq_moq_json_Timed_Json **out, moq_mux_Error **err, moq_mux_json_Consumer_Json_next_future **future, moq_status *status); -moq_poll moq_mux_json_Consumer_Json_next_poll(moq_mux_json_Consumer_Json_next_future *future, moq_waker waker, moq_moq_json_Timed_Json **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_json_Consumer_Json_next_future *moq_mux_json_Consumer_Json_next(moq_mux_json_Consumer_Json *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_json_Consumer_Json_next_start(moq_mux_json_Consumer_Json *self, moq_moq_json_Timed_Json **out, moq_mux_Error **err, moq_mux_json_Consumer_Json_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_json_Consumer_Json_next_poll(moq_mux_json_Consumer_Json_next_future *future, moq_waker waker, moq_moq_json_Timed_Json **out, moq_mux_Error **err); void moq_mux_json_Consumer_Json_next_future_free(moq_mux_json_Consumer_Json_next_future *future); typedef struct moq_mux_json_Consumer_Json_latest_future moq_mux_json_Consumer_Json_latest_future; -moq_mux_json_Consumer_Json_latest_future *moq_mux_json_Consumer_Json_latest(moq_mux_json_Consumer_Json *self, moq_status *status); -moq_poll moq_mux_json_Consumer_Json_latest_start(moq_mux_json_Consumer_Json *self, moq_moq_json_Timed_Json **out, moq_mux_Error **err, moq_mux_json_Consumer_Json_latest_future **future, moq_status *status); -moq_poll moq_mux_json_Consumer_Json_latest_poll(moq_mux_json_Consumer_Json_latest_future *future, moq_waker waker, moq_moq_json_Timed_Json **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_json_Consumer_Json_latest_future *moq_mux_json_Consumer_Json_latest(moq_mux_json_Consumer_Json *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_json_Consumer_Json_latest_start(moq_mux_json_Consumer_Json *self, moq_moq_json_Timed_Json **out, moq_mux_Error **err, moq_mux_json_Consumer_Json_latest_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_json_Consumer_Json_latest_poll(moq_mux_json_Consumer_Json_latest_future *future, moq_waker waker, moq_moq_json_Timed_Json **out, moq_mux_Error **err); void moq_mux_json_Consumer_Json_latest_future_free(moq_mux_json_Consumer_Json_latest_future *future); void moq_mux_json_Config_free(moq_mux_json_Config *self); void moq_mux_json_Config_drop(moq_mux_json_Config *self, moq_status *status); -moq_mux_json_Config *moq_mux_json_Config_clone(const moq_mux_json_Config *self, moq_status *status); -moq_buf moq_mux_json_Config_debug(const moq_mux_json_Config *self, moq_status *status); -moq_mux_json_Config *moq_mux_json_Config_default(void); -moq_buf moq_mux_json_Config_schema_get(const moq_mux_json_Config *self, moq_status *status); +MOQ_MUST_USE moq_mux_json_Config *moq_mux_json_Config_clone(const moq_mux_json_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_json_Config_debug(const moq_mux_json_Config *self, moq_status *status); +MOQ_MUST_USE moq_mux_json_Config *moq_mux_json_Config_default(void); +MOQ_MUST_USE moq_buf moq_mux_json_Config_schema_get(const moq_mux_json_Config *self, moq_status *status); void moq_mux_json_Config_schema_set(moq_mux_json_Config *self, moq_buf value, moq_status *status); -moq_mux_json_Config *moq_mux_json_Config_with_schema(moq_mux_json_Config *self, moq_buf schema, moq_status *status); +MOQ_MUST_USE moq_mux_json_Config *moq_mux_json_Config_with_schema(moq_mux_json_Config *self, moq_buf schema, moq_status *status); void moq_mux_json_Options_free(moq_mux_json_Options *self); void moq_mux_json_Options_drop(moq_mux_json_Options *self, moq_status *status); -moq_mux_json_Options *moq_mux_json_Options_clone(const moq_mux_json_Options *self, moq_status *status); -moq_buf moq_mux_json_Options_debug(const moq_mux_json_Options *self, moq_status *status); -moq_mux_json_Options *moq_mux_json_Options_default(void); +MOQ_MUST_USE moq_mux_json_Options *moq_mux_json_Options_clone(const moq_mux_json_Options *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_json_Options_debug(const moq_mux_json_Options *self, moq_status *status); +MOQ_MUST_USE moq_mux_json_Options *moq_mux_json_Options_default(void); bool moq_mux_json_Options_deltas_get(const moq_mux_json_Options *self, moq_status *status); void moq_mux_json_Options_deltas_set(moq_mux_json_Options *self, bool value, moq_status *status); -moq_mux_json_Options *moq_mux_json_Options_with_deltas(moq_mux_json_Options *self, bool deltas, moq_status *status); +MOQ_MUST_USE moq_mux_json_Options *moq_mux_json_Options_with_deltas(moq_mux_json_Options *self, bool deltas, moq_status *status); void moq_mux_rate_Grant_free(moq_mux_rate_Grant *self); void moq_mux_rate_Grant_drop(moq_mux_rate_Grant *self, moq_status *status); -moq_mux_rate_Grant *moq_mux_rate_Grant_new(moq_bandwidth_Consumer *grant, moq_mux_rate_Policy *policy, moq_status *status); +MOQ_MUST_USE moq_mux_rate_Grant *moq_mux_rate_Grant_new(moq_bandwidth_Consumer *grant, moq_mux_rate_Policy *policy, moq_status *status); void moq_mux_rate_Grant_assume(moq_mux_rate_Grant *self, moq_mux_rate_Target target, moq_status *status); -moq_mux_rate_Policy *moq_mux_rate_Grant_policy(const moq_mux_rate_Grant *self, moq_status *status); +MOQ_MUST_USE moq_mux_rate_Policy *moq_mux_rate_Grant_policy(const moq_mux_rate_Grant *self, moq_status *status); void moq_mux_rate_Grant_set_policy(moq_mux_rate_Grant *self, moq_mux_rate_Policy *policy, moq_status *status); typedef struct moq_mux_rate_Grant_next_future moq_mux_rate_Grant_next_future; -moq_mux_rate_Grant_next_future *moq_mux_rate_Grant_next(moq_mux_rate_Grant *self, moq_status *status); -moq_poll moq_mux_rate_Grant_next_start(moq_mux_rate_Grant *self, moq_mux_rate_Target *out, moq_Error **err, moq_mux_rate_Grant_next_future **future, moq_status *status); -moq_poll moq_mux_rate_Grant_next_poll(moq_mux_rate_Grant_next_future *future, moq_waker waker, moq_mux_rate_Target *out, moq_Error **err); +MOQ_MUST_USE moq_mux_rate_Grant_next_future *moq_mux_rate_Grant_next(moq_mux_rate_Grant *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_rate_Grant_next_start(moq_mux_rate_Grant *self, moq_mux_rate_Target *out, moq_Error **err, moq_mux_rate_Grant_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_rate_Grant_next_poll(moq_mux_rate_Grant_next_future *future, moq_waker waker, moq_mux_rate_Target *out, moq_Error **err); void moq_mux_rate_Grant_next_future_free(moq_mux_rate_Grant_next_future *future); void moq_mux_rate_Grant_failed(moq_mux_rate_Grant *self, moq_status *status); void moq_mux_rate_Policy_free(moq_mux_rate_Policy *self); void moq_mux_rate_Policy_drop(moq_mux_rate_Policy *self, moq_status *status); -moq_mux_rate_Policy *moq_mux_rate_Policy_clone(const moq_mux_rate_Policy *self, moq_status *status); +MOQ_MUST_USE moq_mux_rate_Policy *moq_mux_rate_Policy_clone(const moq_mux_rate_Policy *self, moq_status *status); bool moq_mux_rate_Policy_eq(const moq_mux_rate_Policy *a, const moq_mux_rate_Policy *b, moq_status *status); -moq_buf moq_mux_rate_Policy_debug(const moq_mux_rate_Policy *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_rate_Policy_debug(const moq_mux_rate_Policy *self, moq_status *status); moq_bandwidth_Rate moq_mux_rate_Policy_max_get(const moq_mux_rate_Policy *self, moq_status *status); void moq_mux_rate_Policy_max_set(moq_mux_rate_Policy *self, moq_bandwidth_Rate value, moq_status *status); moq_bandwidth_Rate moq_mux_rate_Policy_min_get(const moq_mux_rate_Policy *self, moq_status *status); void moq_mux_rate_Policy_min_set(moq_mux_rate_Policy *self, moq_bandwidth_Rate value, moq_status *status); moq_option_bandwidth_Rate moq_mux_rate_Policy_lower_get(const moq_mux_rate_Policy *self, moq_status *status); void moq_mux_rate_Policy_lower_set(moq_mux_rate_Policy *self, moq_option_bandwidth_Rate value, moq_status *status); -moq_mux_rate_Policy *moq_mux_rate_Policy_new(moq_bandwidth_Rate max); +MOQ_MUST_USE moq_mux_rate_Policy *moq_mux_rate_Policy_new(moq_bandwidth_Rate max); void moq_mux_rate_Control_free(moq_mux_rate_Control *self); void moq_mux_rate_Control_drop(moq_mux_rate_Control *self, moq_status *status); -moq_mux_rate_Control *moq_mux_rate_Control_clone(const moq_mux_rate_Control *self, moq_status *status); -moq_buf moq_mux_rate_Control_debug(const moq_mux_rate_Control *self, moq_status *status); -moq_mux_rate_Control *moq_mux_rate_Control_new(moq_mux_rate_Policy *policy, moq_status *status); +MOQ_MUST_USE moq_mux_rate_Control *moq_mux_rate_Control_clone(const moq_mux_rate_Control *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_rate_Control_debug(const moq_mux_rate_Control *self, moq_status *status); +MOQ_MUST_USE moq_mux_rate_Control *moq_mux_rate_Control_new(moq_mux_rate_Policy *policy, moq_status *status); moq_mux_rate_Target moq_mux_rate_Control_target(const moq_mux_rate_Control *self, moq_status *status); void moq_mux_rate_Control_set_probed(moq_mux_rate_Control *self, bool probed, moq_status *status); moq_option_mux_rate_Target moq_mux_rate_Control_update(moq_mux_rate_Control *self, moq_option_bandwidth_Rate estimate, moq_clock_Instant now, moq_status *status); void moq_mux_select_Broadcast_free(moq_mux_select_Broadcast *self); void moq_mux_select_Broadcast_drop(moq_mux_select_Broadcast *self, moq_status *status); bool moq_mux_select_Broadcast_borrowed(const moq_mux_select_Broadcast *self); -moq_mux_select_Broadcast *moq_mux_select_Broadcast_clone(const moq_mux_select_Broadcast *self, moq_status *status); -moq_buf moq_mux_select_Broadcast_debug(const moq_mux_select_Broadcast *self, moq_status *status); -moq_mux_select_Broadcast *moq_mux_select_Broadcast_default(void); -moq_mux_select_Broadcast *moq_mux_select_Broadcast_video(moq_mux_select_Broadcast *self, moq_mux_select_Video *video, moq_status *status); -moq_mux_select_Broadcast *moq_mux_select_Broadcast_audio(moq_mux_select_Broadcast *self, moq_mux_select_Audio *audio, moq_status *status); +MOQ_MUST_USE moq_mux_select_Broadcast *moq_mux_select_Broadcast_clone(const moq_mux_select_Broadcast *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_select_Broadcast_debug(const moq_mux_select_Broadcast *self, moq_status *status); +MOQ_MUST_USE moq_mux_select_Broadcast *moq_mux_select_Broadcast_default(void); +MOQ_MUST_USE moq_mux_select_Broadcast *moq_mux_select_Broadcast_video(moq_mux_select_Broadcast *self, moq_mux_select_Video *video, moq_status *status); +MOQ_MUST_USE moq_mux_select_Broadcast *moq_mux_select_Broadcast_audio(moq_mux_select_Broadcast *self, moq_mux_select_Audio *audio, moq_status *status); bool moq_mux_select_Broadcast_has_video(const moq_mux_select_Broadcast *self, moq_status *status); bool moq_mux_select_Broadcast_has_audio(const moq_mux_select_Broadcast *self, moq_status *status); void moq_mux_select_Broadcast_retain_Extra(const moq_mux_select_Broadcast *self, moq_hang_Catalog_Extra *catalog, moq_status *status); @@ -7531,251 +7541,251 @@ void moq_mux_select_Broadcast_retain_unit(const moq_mux_select_Broadcast *self, void moq_mux_select_Video_free(moq_mux_select_Video *self); void moq_mux_select_Video_drop(moq_mux_select_Video *self, moq_status *status); bool moq_mux_select_Video_borrowed(const moq_mux_select_Video *self); -moq_mux_select_Video *moq_mux_select_Video_clone(const moq_mux_select_Video *self, moq_status *status); -moq_buf moq_mux_select_Video_debug(const moq_mux_select_Video *self, moq_status *status); -moq_mux_select_Video *moq_mux_select_Video_default(void); -moq_mux_select_Video *moq_mux_select_Video_name(moq_mux_select_Video *self, moq_buf name, moq_status *status); -moq_mux_select_Video *moq_mux_select_Video_codec(moq_mux_select_Video *self, moq_hang_catalog_VideoCodecKind codec, moq_status *status); +MOQ_MUST_USE moq_mux_select_Video *moq_mux_select_Video_clone(const moq_mux_select_Video *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_select_Video_debug(const moq_mux_select_Video *self, moq_status *status); +MOQ_MUST_USE moq_mux_select_Video *moq_mux_select_Video_default(void); +MOQ_MUST_USE moq_mux_select_Video *moq_mux_select_Video_name(moq_mux_select_Video *self, moq_buf name, moq_status *status); +MOQ_MUST_USE moq_mux_select_Video *moq_mux_select_Video_codec(moq_mux_select_Video *self, moq_hang_catalog_VideoCodecKind codec, moq_status *status); void moq_mux_select_Audio_free(moq_mux_select_Audio *self); void moq_mux_select_Audio_drop(moq_mux_select_Audio *self, moq_status *status); bool moq_mux_select_Audio_borrowed(const moq_mux_select_Audio *self); -moq_mux_select_Audio *moq_mux_select_Audio_clone(const moq_mux_select_Audio *self, moq_status *status); -moq_buf moq_mux_select_Audio_debug(const moq_mux_select_Audio *self, moq_status *status); -moq_mux_select_Audio *moq_mux_select_Audio_default(void); -moq_mux_select_Audio *moq_mux_select_Audio_name(moq_mux_select_Audio *self, moq_buf name, moq_status *status); -moq_mux_select_Audio *moq_mux_select_Audio_codec(moq_mux_select_Audio *self, moq_hang_catalog_AudioCodecKind codec, moq_status *status); +MOQ_MUST_USE moq_mux_select_Audio *moq_mux_select_Audio_clone(const moq_mux_select_Audio *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_select_Audio_debug(const moq_mux_select_Audio *self, moq_status *status); +MOQ_MUST_USE moq_mux_select_Audio *moq_mux_select_Audio_default(void); +MOQ_MUST_USE moq_mux_select_Audio *moq_mux_select_Audio_name(moq_mux_select_Audio *self, moq_buf name, moq_status *status); +MOQ_MUST_USE moq_mux_select_Audio *moq_mux_select_Audio_codec(moq_mux_select_Audio *self, moq_hang_catalog_AudioCodecKind codec, moq_status *status); void moq_mux_sync_Track_free(moq_mux_sync_Track *self); bool moq_mux_sync_Track_received(const moq_mux_sync_Track *self, moq_Timestamp timestamp, moq_clock_Instant now); void moq_mux_sync_Track_reset(const moq_mux_sync_Track *self); bool moq_mux_sync_Track_set_target(const moq_mux_sync_Track *self, moq_duration target); typedef struct moq_mux_sync_Track_delay_changed_future moq_mux_sync_Track_delay_changed_future; -moq_mux_sync_Track_delay_changed_future *moq_mux_sync_Track_delay_changed(const moq_mux_sync_Track *self, moq_duration seen); -moq_poll moq_mux_sync_Track_delay_changed_start(const moq_mux_sync_Track *self, moq_duration seen, moq_duration *out, moq_mux_sync_Track_delay_changed_future **future); -moq_poll moq_mux_sync_Track_delay_changed_poll(moq_mux_sync_Track_delay_changed_future *future, moq_waker waker, moq_duration *out); +MOQ_MUST_USE moq_mux_sync_Track_delay_changed_future *moq_mux_sync_Track_delay_changed(const moq_mux_sync_Track *self, moq_duration seen); +MOQ_MUST_USE moq_poll moq_mux_sync_Track_delay_changed_start(const moq_mux_sync_Track *self, moq_duration seen, moq_duration *out, moq_mux_sync_Track_delay_changed_future **future); +MOQ_MUST_USE moq_poll moq_mux_sync_Track_delay_changed_poll(moq_mux_sync_Track_delay_changed_future *future, moq_waker waker, moq_duration *out); void moq_mux_sync_Track_delay_changed_future_free(moq_mux_sync_Track_delay_changed_future *future); void moq_mux_sync_Schedule_free(moq_mux_sync_Schedule *self); bool moq_mux_sync_Schedule_borrowed(const moq_mux_sync_Schedule *self); -moq_mux_sync_Schedule *moq_mux_sync_Schedule_clone(const moq_mux_sync_Schedule *self); +MOQ_MUST_USE moq_mux_sync_Schedule *moq_mux_sync_Schedule_clone(const moq_mux_sync_Schedule *self); bool moq_mux_sync_Schedule_eq(const moq_mux_sync_Schedule *a, const moq_mux_sync_Schedule *b); -moq_buf moq_mux_sync_Schedule_debug(const moq_mux_sync_Schedule *self); +MOQ_MUST_USE moq_buf moq_mux_sync_Schedule_debug(const moq_mux_sync_Schedule *self); moq_duration moq_mux_sync_Schedule_delay(const moq_mux_sync_Schedule *self); moq_option_clock_Instant moq_mux_sync_Schedule_due(const moq_mux_sync_Schedule *self, moq_Timestamp timestamp); void moq_mux_sync_Producer_free(moq_mux_sync_Producer *self); void moq_mux_sync_Producer_drop(moq_mux_sync_Producer *self, moq_status *status); bool moq_mux_sync_Producer_borrowed(const moq_mux_sync_Producer *self); -moq_mux_sync_Producer *moq_mux_sync_Producer_clone(const moq_mux_sync_Producer *self, moq_status *status); -moq_mux_sync_Producer *moq_mux_sync_Producer_new(moq_duration delay); -moq_mux_sync_Producer *moq_mux_sync_Producer_reset(moq_mux_sync_Producer *self, moq_duration delay, moq_status *status); -moq_mux_sync_Consumer *moq_mux_sync_Producer_consume(const moq_mux_sync_Producer *self, moq_status *status); -moq_mux_sync_Track *moq_mux_sync_Producer_track(const moq_mux_sync_Producer *self, moq_mux_container_Kind kind, moq_status *status); +MOQ_MUST_USE moq_mux_sync_Producer *moq_mux_sync_Producer_clone(const moq_mux_sync_Producer *self, moq_status *status); +MOQ_MUST_USE moq_mux_sync_Producer *moq_mux_sync_Producer_new(moq_duration delay); +MOQ_MUST_USE moq_mux_sync_Producer *moq_mux_sync_Producer_reset(moq_mux_sync_Producer *self, moq_duration delay, moq_status *status); +MOQ_MUST_USE moq_mux_sync_Consumer *moq_mux_sync_Producer_consume(const moq_mux_sync_Producer *self, moq_status *status); +MOQ_MUST_USE moq_mux_sync_Track *moq_mux_sync_Producer_track(const moq_mux_sync_Producer *self, moq_mux_container_Kind kind, moq_status *status); moq_option_clock_Instant moq_mux_sync_Producer_due(const moq_mux_sync_Producer *self, moq_Timestamp timestamp, moq_status *status); void moq_mux_sync_Consumer_free(moq_mux_sync_Consumer *self); void moq_mux_sync_Consumer_drop(moq_mux_sync_Consumer *self, moq_status *status); bool moq_mux_sync_Consumer_borrowed(const moq_mux_sync_Consumer *self); -moq_mux_sync_Consumer *moq_mux_sync_Consumer_clone(const moq_mux_sync_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_mux_sync_Consumer *moq_mux_sync_Consumer_clone(const moq_mux_sync_Consumer *self, moq_status *status); moq_duration moq_mux_sync_Consumer_delay(const moq_mux_sync_Consumer *self, moq_status *status); moq_option_clock_Instant moq_mux_sync_Consumer_due(const moq_mux_sync_Consumer *self, moq_Timestamp timestamp, moq_status *status); moq_option_duration moq_mux_sync_Consumer_position(const moq_mux_sync_Consumer *self, moq_clock_Instant at, moq_status *status); -moq_mux_sync_Schedule *moq_mux_sync_Consumer_schedule(const moq_mux_sync_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_mux_sync_Schedule *moq_mux_sync_Consumer_schedule(const moq_mux_sync_Consumer *self, moq_status *status); typedef struct moq_mux_sync_Consumer_changed_future moq_mux_sync_Consumer_changed_future; -moq_mux_sync_Consumer_changed_future *moq_mux_sync_Consumer_changed(const moq_mux_sync_Consumer *self, const moq_mux_sync_Schedule *seen, moq_status *status); -moq_poll moq_mux_sync_Consumer_changed_start(const moq_mux_sync_Consumer *self, const moq_mux_sync_Schedule *seen, moq_mux_sync_Schedule **out, moq_mux_sync_Consumer_changed_future **future, moq_status *status); -moq_poll moq_mux_sync_Consumer_changed_poll(moq_mux_sync_Consumer_changed_future *future, moq_waker waker, moq_mux_sync_Schedule **out); +MOQ_MUST_USE moq_mux_sync_Consumer_changed_future *moq_mux_sync_Consumer_changed(const moq_mux_sync_Consumer *self, const moq_mux_sync_Schedule *seen, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_sync_Consumer_changed_start(const moq_mux_sync_Consumer *self, const moq_mux_sync_Schedule *seen, moq_mux_sync_Schedule **out, moq_mux_sync_Consumer_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_sync_Consumer_changed_poll(moq_mux_sync_Consumer_changed_future *future, moq_waker waker, moq_mux_sync_Schedule **out); void moq_mux_sync_Consumer_changed_future_free(moq_mux_sync_Consumer_changed_future *future); moq_option_usize moq_mux_sync_Consumer_present(const moq_mux_sync_Consumer *self, moq_vec_Timestamp timestamps, moq_clock_Instant now, moq_status *status); void moq_tokio_tls_Error_free(moq_tokio_tls_Error *self); -moq_buf moq_tokio_tls_Error_to_string(const moq_tokio_tls_Error *self); -moq_buf moq_tokio_tls_Error_debug(const moq_tokio_tls_Error *self); +MOQ_MUST_USE moq_buf moq_tokio_tls_Error_to_string(const moq_tokio_tls_Error *self); +MOQ_MUST_USE moq_buf moq_tokio_tls_Error_debug(const moq_tokio_tls_Error *self); void moq_tokio_tls_Identity_free(moq_tokio_tls_Identity *self); void moq_tokio_tls_Identity_drop(moq_tokio_tls_Identity *self, moq_status *status); bool moq_tokio_tls_Identity_borrowed(const moq_tokio_tls_Identity *self); -moq_tokio_tls_Identity *moq_tokio_tls_Identity_clone(const moq_tokio_tls_Identity *self, moq_status *status); -moq_buf moq_tokio_tls_Identity_debug(const moq_tokio_tls_Identity *self, moq_status *status); -bool moq_tokio_tls_Identity_generate(moq_vec_string hostnames, moq_tokio_tls_Identity **out, moq_tokio_tls_Error **err); -moq_buf moq_tokio_tls_Identity_fingerprint(const moq_tokio_tls_Identity *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Identity *moq_tokio_tls_Identity_clone(const moq_tokio_tls_Identity *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_tls_Identity_debug(const moq_tokio_tls_Identity *self, moq_status *status); +MOQ_MUST_USE bool moq_tokio_tls_Identity_generate(moq_vec_string hostnames, moq_tokio_tls_Identity **out, moq_tokio_tls_Error **err); +MOQ_MUST_USE moq_buf moq_tokio_tls_Identity_fingerprint(const moq_tokio_tls_Identity *self, moq_status *status); void moq_tokio_tls_Connect_free(moq_tokio_tls_Connect *self); void moq_tokio_tls_Connect_drop(moq_tokio_tls_Connect *self, moq_status *status); -moq_tokio_tls_Connect *moq_tokio_tls_Connect_clone(const moq_tokio_tls_Connect *self, moq_status *status); -moq_buf moq_tokio_tls_Connect_debug(const moq_tokio_tls_Connect *self, moq_status *status); -moq_tokio_tls_Connect *moq_tokio_tls_Connect_default(void); -moq_vec_path moq_tokio_tls_Connect_root_get(const moq_tokio_tls_Connect *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Connect *moq_tokio_tls_Connect_clone(const moq_tokio_tls_Connect *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_tls_Connect_debug(const moq_tokio_tls_Connect *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Connect *moq_tokio_tls_Connect_default(void); +MOQ_MUST_USE moq_vec_path moq_tokio_tls_Connect_root_get(const moq_tokio_tls_Connect *self, moq_status *status); void moq_tokio_tls_Connect_root_set(moq_tokio_tls_Connect *self, moq_vec_path value, moq_status *status); moq_option_bool moq_tokio_tls_Connect_system_roots_get(const moq_tokio_tls_Connect *self, moq_status *status); void moq_tokio_tls_Connect_system_roots_set(moq_tokio_tls_Connect *self, moq_option_bool value, moq_status *status); -moq_vec_string moq_tokio_tls_Connect_fingerprint_get(const moq_tokio_tls_Connect *self, moq_status *status); +MOQ_MUST_USE moq_vec_string moq_tokio_tls_Connect_fingerprint_get(const moq_tokio_tls_Connect *self, moq_status *status); void moq_tokio_tls_Connect_fingerprint_set(moq_tokio_tls_Connect *self, moq_vec_string value, moq_status *status); -moq_tokio_tls_Identity *moq_tokio_tls_Connect_identity_get(const moq_tokio_tls_Connect *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Identity *moq_tokio_tls_Connect_identity_get(const moq_tokio_tls_Connect *self, moq_status *status); void moq_tokio_tls_Connect_identity_set(moq_tokio_tls_Connect *self, moq_tokio_tls_Identity *value, moq_status *status); -moq_buf moq_tokio_tls_Connect_cert_get(const moq_tokio_tls_Connect *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_tls_Connect_cert_get(const moq_tokio_tls_Connect *self, moq_status *status); void moq_tokio_tls_Connect_cert_set(moq_tokio_tls_Connect *self, moq_buf value, moq_status *status); -moq_buf moq_tokio_tls_Connect_key_get(const moq_tokio_tls_Connect *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_tls_Connect_key_get(const moq_tokio_tls_Connect *self, moq_status *status); void moq_tokio_tls_Connect_key_set(moq_tokio_tls_Connect *self, moq_buf value, moq_status *status); moq_option_bool moq_tokio_tls_Connect_insecure_get(const moq_tokio_tls_Connect *self, moq_status *status); void moq_tokio_tls_Connect_insecure_set(moq_tokio_tls_Connect *self, moq_option_bool value, moq_status *status); -moq_buf moq_tokio_tls_Connect_host_name_get(const moq_tokio_tls_Connect *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_tls_Connect_host_name_get(const moq_tokio_tls_Connect *self, moq_status *status); void moq_tokio_tls_Connect_host_name_set(moq_tokio_tls_Connect *self, moq_buf value, moq_status *status); -moq_moq_tokio_cli_Deprecated *moq_tokio_tls_Connect_deprecated(const moq_tokio_tls_Connect *self, moq_status *status); -bool moq_tokio_tls_Connect_build(const moq_tokio_tls_Connect *self, moq_rustls_ClientConfig **out, moq_tokio_tls_Error **err, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_cli_Deprecated *moq_tokio_tls_Connect_deprecated(const moq_tokio_tls_Connect *self, moq_status *status); +MOQ_MUST_USE bool moq_tokio_tls_Connect_build(const moq_tokio_tls_Connect *self, moq_rustls_ClientConfig **out, moq_tokio_tls_Error **err, moq_status *status); void moq_tokio_tls_Listen_free(moq_tokio_tls_Listen *self); void moq_tokio_tls_Listen_drop(moq_tokio_tls_Listen *self, moq_status *status); -moq_tokio_tls_Listen *moq_tokio_tls_Listen_clone(const moq_tokio_tls_Listen *self, moq_status *status); -moq_buf moq_tokio_tls_Listen_debug(const moq_tokio_tls_Listen *self, moq_status *status); -moq_tokio_tls_Listen *moq_tokio_tls_Listen_default(void); -moq_vec_path moq_tokio_tls_Listen_cert_get(const moq_tokio_tls_Listen *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Listen *moq_tokio_tls_Listen_clone(const moq_tokio_tls_Listen *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_tls_Listen_debug(const moq_tokio_tls_Listen *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Listen *moq_tokio_tls_Listen_default(void); +MOQ_MUST_USE moq_vec_path moq_tokio_tls_Listen_cert_get(const moq_tokio_tls_Listen *self, moq_status *status); void moq_tokio_tls_Listen_cert_set(moq_tokio_tls_Listen *self, moq_vec_path value, moq_status *status); -moq_vec_path moq_tokio_tls_Listen_key_get(const moq_tokio_tls_Listen *self, moq_status *status); +MOQ_MUST_USE moq_vec_path moq_tokio_tls_Listen_key_get(const moq_tokio_tls_Listen *self, moq_status *status); void moq_tokio_tls_Listen_key_set(moq_tokio_tls_Listen *self, moq_vec_path value, moq_status *status); -moq_vec_string moq_tokio_tls_Listen_generate_get(const moq_tokio_tls_Listen *self, moq_status *status); +MOQ_MUST_USE moq_vec_string moq_tokio_tls_Listen_generate_get(const moq_tokio_tls_Listen *self, moq_status *status); void moq_tokio_tls_Listen_generate_set(moq_tokio_tls_Listen *self, moq_vec_string value, moq_status *status); -moq_tokio_tls_Identity *moq_tokio_tls_Listen_identity_get(const moq_tokio_tls_Listen *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Identity *moq_tokio_tls_Listen_identity_get(const moq_tokio_tls_Listen *self, moq_status *status); void moq_tokio_tls_Listen_identity_set(moq_tokio_tls_Listen *self, moq_tokio_tls_Identity *value, moq_status *status); -moq_vec_path moq_tokio_tls_Listen_root_get(const moq_tokio_tls_Listen *self, moq_status *status); +MOQ_MUST_USE moq_vec_path moq_tokio_tls_Listen_root_get(const moq_tokio_tls_Listen *self, moq_status *status); void moq_tokio_tls_Listen_root_set(moq_tokio_tls_Listen *self, moq_vec_path value, moq_status *status); -bool moq_tokio_tls_Listen_load(const moq_tokio_tls_Listen *self, moq_tokio_tls_Serve **out, moq_tokio_tls_Error **err, moq_status *status); -moq_moq_tokio_cli_Deprecated *moq_tokio_tls_Listen_deprecated(const moq_tokio_tls_Listen *self, moq_status *status); -bool moq_tokio_tls_Listen_load_roots(const moq_tokio_tls_Listen *self, moq_rustls_RootCertStore **out, moq_tokio_tls_Error **err, moq_status *status); -bool moq_tokio_tls_Listen_server_config(const moq_tokio_tls_Listen *self, moq_vec_bytes alpn, moq_rustls_ServerConfig **out, moq_tokio_tls_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_tokio_tls_Listen_load(const moq_tokio_tls_Listen *self, moq_tokio_tls_Serve **out, moq_tokio_tls_Error **err, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_cli_Deprecated *moq_tokio_tls_Listen_deprecated(const moq_tokio_tls_Listen *self, moq_status *status); +MOQ_MUST_USE bool moq_tokio_tls_Listen_load_roots(const moq_tokio_tls_Listen *self, moq_rustls_RootCertStore **out, moq_tokio_tls_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_tokio_tls_Listen_server_config(const moq_tokio_tls_Listen *self, moq_vec_bytes alpn, moq_rustls_ServerConfig **out, moq_tokio_tls_Error **err, moq_status *status); void moq_tokio_tls_Serve_free(moq_tokio_tls_Serve *self); void moq_tokio_tls_Serve_drop(moq_tokio_tls_Serve *self, moq_status *status); bool moq_tokio_tls_Serve_borrowed(const moq_tokio_tls_Serve *self); -moq_tokio_tls_Serve *moq_tokio_tls_Serve_clone(const moq_tokio_tls_Serve *self, moq_status *status); -moq_buf moq_tokio_tls_Serve_debug(const moq_tokio_tls_Serve *self, moq_status *status); -moq_tokio_tls_Certificates *moq_tokio_tls_Serve_certificates(const moq_tokio_tls_Serve *self, moq_status *status); -bool moq_tokio_tls_Serve_config(const moq_tokio_tls_Serve *self, moq_vec_bytes alpn, moq_rustls_ServerConfig **out, moq_tokio_tls_Error **err, moq_status *status); -moq_tokio_tls_PeerIdentity *moq_tokio_tls_Serve_peer(const moq_tokio_tls_Serve *self, moq_vec_rustls_pki_types_CertificateDer chain, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Serve *moq_tokio_tls_Serve_clone(const moq_tokio_tls_Serve *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_tls_Serve_debug(const moq_tokio_tls_Serve *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Certificates *moq_tokio_tls_Serve_certificates(const moq_tokio_tls_Serve *self, moq_status *status); +MOQ_MUST_USE bool moq_tokio_tls_Serve_config(const moq_tokio_tls_Serve *self, moq_vec_bytes alpn, moq_rustls_ServerConfig **out, moq_tokio_tls_Error **err, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_PeerIdentity *moq_tokio_tls_Serve_peer(const moq_tokio_tls_Serve *self, moq_vec_rustls_pki_types_CertificateDer chain, moq_status *status); void moq_tokio_tls_PeerIdentity_free(moq_tokio_tls_PeerIdentity *self); bool moq_tokio_tls_PeerIdentity_borrowed(const moq_tokio_tls_PeerIdentity *self); -moq_tokio_tls_PeerIdentity *moq_tokio_tls_PeerIdentity_clone(const moq_tokio_tls_PeerIdentity *self); -moq_buf moq_tokio_tls_PeerIdentity_debug(const moq_tokio_tls_PeerIdentity *self); -moq_vec_rustls_pki_types_CertificateDer moq_tokio_tls_PeerIdentity_chain(const moq_tokio_tls_PeerIdentity *self); -moq_buf moq_tokio_tls_PeerIdentity_fingerprint(const moq_tokio_tls_PeerIdentity *self); -moq_buf moq_tokio_tls_PeerIdentity_name(const moq_tokio_tls_PeerIdentity *self); -bool moq_tokio_tls_PeerIdentity_lineage(const moq_tokio_tls_PeerIdentity *self, moq_vec_string *out, moq_tokio_tls_Error **err); -moq_buf moq_tokio_tls_PeerIdentity_issuer(const moq_tokio_tls_PeerIdentity *self); +MOQ_MUST_USE moq_tokio_tls_PeerIdentity *moq_tokio_tls_PeerIdentity_clone(const moq_tokio_tls_PeerIdentity *self); +MOQ_MUST_USE moq_buf moq_tokio_tls_PeerIdentity_debug(const moq_tokio_tls_PeerIdentity *self); +MOQ_MUST_USE moq_vec_rustls_pki_types_CertificateDer moq_tokio_tls_PeerIdentity_chain(const moq_tokio_tls_PeerIdentity *self); +MOQ_MUST_USE moq_buf moq_tokio_tls_PeerIdentity_fingerprint(const moq_tokio_tls_PeerIdentity *self); +MOQ_MUST_USE moq_buf moq_tokio_tls_PeerIdentity_name(const moq_tokio_tls_PeerIdentity *self); +MOQ_MUST_USE bool moq_tokio_tls_PeerIdentity_lineage(const moq_tokio_tls_PeerIdentity *self, moq_vec_string *out, moq_tokio_tls_Error **err); +MOQ_MUST_USE moq_buf moq_tokio_tls_PeerIdentity_issuer(const moq_tokio_tls_PeerIdentity *self); moq_option_clock_Wall moq_tokio_tls_PeerIdentity_expiry(const moq_tokio_tls_PeerIdentity *self); void moq_tokio_tls_Certificates_free(moq_tokio_tls_Certificates *self); bool moq_tokio_tls_Certificates_borrowed(const moq_tokio_tls_Certificates *self); -moq_tokio_tls_Certificates *moq_tokio_tls_Certificates_clone(const moq_tokio_tls_Certificates *self); -moq_buf moq_tokio_tls_Certificates_debug(const moq_tokio_tls_Certificates *self); -bool moq_tokio_tls_Certificates_from_pem(moq_buf chain, moq_tokio_tls_Certificates **out, moq_tokio_tls_Error **err); -moq_vec_string moq_tokio_tls_Certificates_fingerprints(const moq_tokio_tls_Certificates *self); +MOQ_MUST_USE moq_tokio_tls_Certificates *moq_tokio_tls_Certificates_clone(const moq_tokio_tls_Certificates *self); +MOQ_MUST_USE moq_buf moq_tokio_tls_Certificates_debug(const moq_tokio_tls_Certificates *self); +MOQ_MUST_USE bool moq_tokio_tls_Certificates_from_pem(moq_buf chain, moq_tokio_tls_Certificates **out, moq_tokio_tls_Error **err); +MOQ_MUST_USE moq_vec_string moq_tokio_tls_Certificates_fingerprints(const moq_tokio_tls_Certificates *self); void moq_tokio_tls_KeyLog_free(moq_tokio_tls_KeyLog *self); -moq_buf moq_tokio_tls_KeyLog_debug(const moq_tokio_tls_KeyLog *self); -bool moq_tokio_tls_KeyLog_open(moq_buf path, moq_tokio_tls_KeyLog **out, moq_tokio_tls_Error **err); +MOQ_MUST_USE moq_buf moq_tokio_tls_KeyLog_debug(const moq_tokio_tls_KeyLog *self); +MOQ_MUST_USE bool moq_tokio_tls_KeyLog_open(moq_buf path, moq_tokio_tls_KeyLog **out, moq_tokio_tls_Error **err); void moq_tokio_client_Config_free(moq_tokio_client_Config *self); void moq_tokio_client_Config_drop(moq_tokio_client_Config *self, moq_status *status); -moq_tokio_client_Config *moq_tokio_client_Config_clone(const moq_tokio_client_Config *self, moq_status *status); -moq_buf moq_tokio_client_Config_debug(const moq_tokio_client_Config *self, moq_status *status); -moq_tokio_client_Config *moq_tokio_client_Config_default(void); -moq_tokio_connect_Config *moq_tokio_client_Config_connect_get(const moq_tokio_client_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_client_Config *moq_tokio_client_Config_clone(const moq_tokio_client_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_client_Config_debug(const moq_tokio_client_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_client_Config *moq_tokio_client_Config_default(void); +MOQ_MUST_USE moq_tokio_connect_Config *moq_tokio_client_Config_connect_get(const moq_tokio_client_Config *self, moq_status *status); void moq_tokio_client_Config_connect_set(moq_tokio_client_Config *self, moq_tokio_connect_Config *value, moq_status *status); -moq_tokio_quic_Config *moq_tokio_client_Config_quic_get(const moq_tokio_client_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_quic_Config *moq_tokio_client_Config_quic_get(const moq_tokio_client_Config *self, moq_status *status); void moq_tokio_client_Config_quic_set(moq_tokio_client_Config *self, moq_tokio_quic_Config *value, moq_status *status); -bool moq_tokio_client_Config_init(moq_tokio_client_Config *self, moq_tokio_Client **out, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_tokio_client_Config_init(moq_tokio_client_Config *self, moq_tokio_Client **out, moq_tokio_Error **err, moq_status *status); void moq_tokio_connect_Config_free(moq_tokio_connect_Config *self); void moq_tokio_connect_Config_drop(moq_tokio_connect_Config *self, moq_status *status); -moq_tokio_connect_Config *moq_tokio_connect_Config_clone(const moq_tokio_connect_Config *self, moq_status *status); -moq_buf moq_tokio_connect_Config_debug(const moq_tokio_connect_Config *self, moq_status *status); -moq_tokio_connect_Config *moq_tokio_connect_Config_default(void); -moq_Url *moq_tokio_connect_Config_url_get(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_connect_Config *moq_tokio_connect_Config_clone(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_connect_Config_debug(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_connect_Config *moq_tokio_connect_Config_default(void); +MOQ_MUST_USE moq_Url *moq_tokio_connect_Config_url_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_url_set(moq_tokio_connect_Config *self, moq_Url *value, moq_status *status); -moq_vec_auth_Token moq_tokio_connect_Config_tokens_get(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_vec_auth_Token moq_tokio_connect_Config_tokens_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_tokens_set(moq_tokio_connect_Config *self, moq_vec_auth_Token value, moq_status *status); moq_option_socket_addr moq_tokio_connect_Config_bind_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_bind_set(moq_tokio_connect_Config *self, moq_option_socket_addr value, moq_status *status); -moq_tokio_Duration *moq_tokio_connect_Config_race_get(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Duration *moq_tokio_connect_Config_race_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_race_set(moq_tokio_connect_Config *self, const moq_tokio_Duration *value, moq_status *status); -moq_tokio_Duration *moq_tokio_connect_Config_resolution_delay_get(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Duration *moq_tokio_connect_Config_resolution_delay_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_resolution_delay_set(moq_tokio_connect_Config *self, const moq_tokio_Duration *value, moq_status *status); -moq_tokio_Duration *moq_tokio_connect_Config_timeout_get(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Duration *moq_tokio_connect_Config_timeout_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_timeout_set(moq_tokio_connect_Config *self, const moq_tokio_Duration *value, moq_status *status); -moq_vec_Version moq_tokio_connect_Config_version_get(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_vec_Version moq_tokio_connect_Config_version_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_version_set(moq_tokio_connect_Config *self, moq_vec_Version value, moq_status *status); -moq_buf moq_tokio_connect_Config_implementation_get(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_connect_Config_implementation_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_implementation_set(moq_tokio_connect_Config *self, moq_buf value, moq_status *status); -moq_tokio_tls_Connect *moq_tokio_connect_Config_tls_get(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Connect *moq_tokio_connect_Config_tls_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_tls_set(moq_tokio_connect_Config *self, moq_tokio_tls_Connect *value, moq_status *status); -moq_tokio_Backoff *moq_tokio_connect_Config_backoff_get(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Backoff *moq_tokio_connect_Config_backoff_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_backoff_set(moq_tokio_connect_Config *self, moq_tokio_Backoff *value, moq_status *status); -moq_moq_tokio_connection_Handover *moq_tokio_connect_Config_goaway_get(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_connection_Handover *moq_tokio_connect_Config_goaway_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_goaway_set(moq_tokio_connect_Config *self, moq_moq_tokio_connection_Handover *value, moq_status *status); -moq_moq_tokio_websocket_Config *moq_tokio_connect_Config_websocket_get(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_websocket_Config *moq_tokio_connect_Config_websocket_get(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connect_Config_websocket_set(moq_tokio_connect_Config *self, moq_moq_tokio_websocket_Config *value, moq_status *status); -moq_moq_tokio_cli_Deprecated *moq_tokio_connect_Config_deprecated(const moq_tokio_connect_Config *self, moq_status *status); -bool moq_tokio_connect_Config_init(moq_tokio_connect_Config *self, moq_tokio_quic_Config *quic, moq_tokio_Client **out, moq_tokio_Error **err, moq_status *status); -moq_Versions *moq_tokio_connect_Config_versions(const moq_tokio_connect_Config *self, moq_status *status); -moq_moq_tokio_connect_Resolved *moq_tokio_connect_Config_resolve(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_cli_Deprecated *moq_tokio_connect_Config_deprecated(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE bool moq_tokio_connect_Config_init(moq_tokio_connect_Config *self, moq_tokio_quic_Config *quic, moq_tokio_Client **out, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE moq_Versions *moq_tokio_connect_Config_versions(const moq_tokio_connect_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_connect_Resolved *moq_tokio_connect_Config_resolve(const moq_tokio_connect_Config *self, moq_status *status); void moq_tokio_connection_Monitor_free(moq_tokio_connection_Monitor *self); void moq_tokio_connection_Monitor_drop(moq_tokio_connection_Monitor *self, moq_status *status); -moq_tokio_connection_Monitor *moq_tokio_connection_Monitor_clone(const moq_tokio_connection_Monitor *self, moq_status *status); -moq_moq_tokio_connection_Observation *moq_tokio_connection_Monitor_state(const moq_tokio_connection_Monitor *self, moq_status *status); +MOQ_MUST_USE moq_tokio_connection_Monitor *moq_tokio_connection_Monitor_clone(const moq_tokio_connection_Monitor *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_connection_Observation *moq_tokio_connection_Monitor_state(const moq_tokio_connection_Monitor *self, moq_status *status); typedef struct moq_tokio_connection_Monitor_state_changed_future moq_tokio_connection_Monitor_state_changed_future; -moq_tokio_connection_Monitor_state_changed_future *moq_tokio_connection_Monitor_state_changed(const moq_tokio_connection_Monitor *self, uint64_t after, moq_status *status); -moq_poll moq_tokio_connection_Monitor_state_changed_start(const moq_tokio_connection_Monitor *self, uint64_t after, moq_moq_tokio_connection_Observation **out, moq_tokio_Error **err, moq_tokio_connection_Monitor_state_changed_future **future, moq_status *status); -moq_poll moq_tokio_connection_Monitor_state_changed_poll(moq_tokio_connection_Monitor_state_changed_future *future, moq_waker waker, moq_moq_tokio_connection_Observation **out, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_connection_Monitor_state_changed_future *moq_tokio_connection_Monitor_state_changed(const moq_tokio_connection_Monitor *self, uint64_t after, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_connection_Monitor_state_changed_start(const moq_tokio_connection_Monitor *self, uint64_t after, moq_moq_tokio_connection_Observation **out, moq_tokio_Error **err, moq_tokio_connection_Monitor_state_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_connection_Monitor_state_changed_poll(moq_tokio_connection_Monitor_state_changed_future *future, moq_waker waker, moq_moq_tokio_connection_Observation **out, moq_tokio_Error **err); void moq_tokio_connection_Monitor_state_changed_future_free(moq_tokio_connection_Monitor_state_changed_future *future); moq_stats_Presence moq_tokio_connection_Monitor_presence(const moq_tokio_connection_Monitor *self, moq_status *status); typedef struct moq_tokio_connection_Monitor_poll_presence_future moq_tokio_connection_Monitor_poll_presence_future; -moq_tokio_connection_Monitor_poll_presence_future *moq_tokio_connection_Monitor_poll_presence(moq_tokio_connection_Monitor *self, moq_status *status); -moq_poll moq_tokio_connection_Monitor_poll_presence_start(moq_tokio_connection_Monitor *self, moq_stats_Presence *out, moq_tokio_Error **err, moq_tokio_connection_Monitor_poll_presence_future **future, moq_status *status); -moq_poll moq_tokio_connection_Monitor_poll_presence_poll(moq_tokio_connection_Monitor_poll_presence_future *future, moq_waker waker, moq_stats_Presence *out, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_connection_Monitor_poll_presence_future *moq_tokio_connection_Monitor_poll_presence(moq_tokio_connection_Monitor *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_connection_Monitor_poll_presence_start(moq_tokio_connection_Monitor *self, moq_stats_Presence *out, moq_tokio_Error **err, moq_tokio_connection_Monitor_poll_presence_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_connection_Monitor_poll_presence_poll(moq_tokio_connection_Monitor_poll_presence_future *future, moq_waker waker, moq_stats_Presence *out, moq_tokio_Error **err); void moq_tokio_connection_Monitor_poll_presence_future_free(moq_tokio_connection_Monitor_poll_presence_future *future); typedef struct moq_tokio_connection_Monitor_presence_changed_future moq_tokio_connection_Monitor_presence_changed_future; -moq_tokio_connection_Monitor_presence_changed_future *moq_tokio_connection_Monitor_presence_changed(moq_tokio_connection_Monitor *self, moq_status *status); -moq_poll moq_tokio_connection_Monitor_presence_changed_start(moq_tokio_connection_Monitor *self, moq_stats_Presence *out, moq_tokio_Error **err, moq_tokio_connection_Monitor_presence_changed_future **future, moq_status *status); -moq_poll moq_tokio_connection_Monitor_presence_changed_poll(moq_tokio_connection_Monitor_presence_changed_future *future, moq_waker waker, moq_stats_Presence *out, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_connection_Monitor_presence_changed_future *moq_tokio_connection_Monitor_presence_changed(moq_tokio_connection_Monitor *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_connection_Monitor_presence_changed_start(moq_tokio_connection_Monitor *self, moq_stats_Presence *out, moq_tokio_Error **err, moq_tokio_connection_Monitor_presence_changed_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_connection_Monitor_presence_changed_poll(moq_tokio_connection_Monitor_presence_changed_future *future, moq_waker waker, moq_stats_Presence *out, moq_tokio_Error **err); void moq_tokio_connection_Monitor_presence_changed_future_free(moq_tokio_connection_Monitor_presence_changed_future *future); -moq_session_Stats *moq_tokio_connection_Monitor_stats(const moq_tokio_connection_Monitor *self, moq_status *status); -moq_tokio_Error *moq_tokio_connection_Monitor_failure(const moq_tokio_connection_Monitor *self, moq_status *status); -moq_moq_tokio_connection_Snapshot *moq_tokio_connection_Monitor_snapshot(const moq_tokio_connection_Monitor *self, moq_status *status); +MOQ_MUST_USE moq_session_Stats *moq_tokio_connection_Monitor_stats(const moq_tokio_connection_Monitor *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Error *moq_tokio_connection_Monitor_failure(const moq_tokio_connection_Monitor *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_connection_Snapshot *moq_tokio_connection_Monitor_snapshot(const moq_tokio_connection_Monitor *self, moq_status *status); void moq_tokio_listen_Config_free(moq_tokio_listen_Config *self); void moq_tokio_listen_Config_drop(moq_tokio_listen_Config *self, moq_status *status); -moq_tokio_listen_Config *moq_tokio_listen_Config_clone(const moq_tokio_listen_Config *self, moq_status *status); -moq_buf moq_tokio_listen_Config_debug(const moq_tokio_listen_Config *self, moq_status *status); -moq_tokio_listen_Config *moq_tokio_listen_Config_default(void); -moq_option_tokio_listen_Bind moq_tokio_listen_Config_bind_get(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_listen_Config *moq_tokio_listen_Config_clone(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_listen_Config_debug(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_listen_Config *moq_tokio_listen_Config_default(void); +MOQ_MUST_USE moq_option_tokio_listen_Bind moq_tokio_listen_Config_bind_get(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_listen_Config_bind_set(moq_tokio_listen_Config *self, moq_option_tokio_listen_Bind value, moq_status *status); -moq_moq_tokio_tcp_Config *moq_tokio_listen_Config_tcp_get(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_tcp_Config *moq_tokio_listen_Config_tcp_get(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_listen_Config_tcp_set(moq_tokio_listen_Config *self, moq_moq_tokio_tcp_Config *value, moq_status *status); -moq_moq_tokio_unix_Config *moq_tokio_listen_Config_unix_get(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_unix_Config *moq_tokio_listen_Config_unix_get(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_listen_Config_unix_set(moq_tokio_listen_Config *self, moq_moq_tokio_unix_Config *value, moq_status *status); -moq_vec_Version moq_tokio_listen_Config_version_get(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_vec_Version moq_tokio_listen_Config_version_get(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_listen_Config_version_set(moq_tokio_listen_Config *self, moq_vec_Version value, moq_status *status); -moq_buf moq_tokio_listen_Config_implementation_get(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_listen_Config_implementation_get(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_listen_Config_implementation_set(moq_tokio_listen_Config *self, moq_buf value, moq_status *status); -moq_tokio_Duration *moq_tokio_listen_Config_timeout_get(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Duration *moq_tokio_listen_Config_timeout_get(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_listen_Config_timeout_set(moq_tokio_listen_Config *self, const moq_tokio_Duration *value, moq_status *status); -moq_tokio_tls_Listen *moq_tokio_listen_Config_tls_get(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Listen *moq_tokio_listen_Config_tls_get(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_listen_Config_tls_set(moq_tokio_listen_Config *self, moq_tokio_tls_Listen *value, moq_status *status); moq_option_socket_addr_v4 moq_tokio_listen_Config_preferred_v4_get(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_listen_Config_preferred_v4_set(moq_tokio_listen_Config *self, moq_option_socket_addr_v4 value, moq_status *status); moq_option_socket_addr_v6 moq_tokio_listen_Config_preferred_v6_get(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_listen_Config_preferred_v6_set(moq_tokio_listen_Config *self, moq_option_socket_addr_v6 value, moq_status *status); -moq_moq_tokio_listen_LoadBalancer *moq_tokio_listen_Config_lb_get(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_listen_LoadBalancer *moq_tokio_listen_Config_lb_get(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_listen_Config_lb_set(moq_tokio_listen_Config *self, moq_moq_tokio_listen_LoadBalancer *value, moq_status *status); -moq_moq_tokio_listen_Reset *moq_tokio_listen_Config_reset_get(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_listen_Reset *moq_tokio_listen_Config_reset_get(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_listen_Config_reset_set(moq_tokio_listen_Config *self, moq_moq_tokio_listen_Reset *value, moq_status *status); -moq_moq_tokio_cli_Deprecated *moq_tokio_listen_Config_deprecated(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_cli_Deprecated *moq_tokio_listen_Config_deprecated(const moq_tokio_listen_Config *self, moq_status *status); moq_option_duration moq_tokio_listen_Config_resolved_timeout(const moq_tokio_listen_Config *self, moq_status *status); -bool moq_tokio_listen_Config_resolve(const moq_tokio_listen_Config *self, moq_moq_tokio_listen_Resolved **out, moq_tokio_Error **err, moq_status *status); -bool moq_tokio_listen_Config_init(moq_tokio_listen_Config *self, moq_tokio_quic_Config *quic, moq_tokio_Server **out, moq_tokio_Error **err, moq_status *status); -bool moq_tokio_listen_Config_init_streams(moq_tokio_listen_Config *self, moq_tokio_Server **out, moq_tokio_Error **err, moq_status *status); -moq_Versions *moq_tokio_listen_Config_versions(const moq_tokio_listen_Config *self, moq_status *status); -moq_Server *moq_tokio_listen_Config_server(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE bool moq_tokio_listen_Config_resolve(const moq_tokio_listen_Config *self, moq_moq_tokio_listen_Resolved **out, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_tokio_listen_Config_init(moq_tokio_listen_Config *self, moq_tokio_quic_Config *quic, moq_tokio_Server **out, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_tokio_listen_Config_init_streams(moq_tokio_listen_Config *self, moq_tokio_Server **out, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE moq_Versions *moq_tokio_listen_Config_versions(const moq_tokio_listen_Config *self, moq_status *status); +MOQ_MUST_USE moq_Server *moq_tokio_listen_Config_server(const moq_tokio_listen_Config *self, moq_status *status); bool moq_tokio_listen_Config_has_explicit_bind(const moq_tokio_listen_Config *self, moq_status *status); bool moq_tokio_listen_Config_serves_quic(const moq_tokio_listen_Config *self, moq_status *status); void moq_tokio_quic_Config_free(moq_tokio_quic_Config *self); void moq_tokio_quic_Config_drop(moq_tokio_quic_Config *self, moq_status *status); -moq_tokio_quic_Config *moq_tokio_quic_Config_clone(const moq_tokio_quic_Config *self, moq_status *status); -moq_buf moq_tokio_quic_Config_debug(const moq_tokio_quic_Config *self, moq_status *status); -moq_tokio_quic_Config *moq_tokio_quic_Config_default(void); +MOQ_MUST_USE moq_tokio_quic_Config *moq_tokio_quic_Config_clone(const moq_tokio_quic_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_quic_Config_debug(const moq_tokio_quic_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_quic_Config *moq_tokio_quic_Config_default(void); moq_option_u64 moq_tokio_quic_Config_max_streams_get(const moq_tokio_quic_Config *self, moq_status *status); void moq_tokio_quic_Config_max_streams_set(moq_tokio_quic_Config *self, moq_option_u64 value, moq_status *status); moq_option_bool moq_tokio_quic_Config_gso_get(const moq_tokio_quic_Config *self, moq_status *status); void moq_tokio_quic_Config_gso_set(moq_tokio_quic_Config *self, moq_option_bool value, moq_status *status); -moq_tokio_Duration *moq_tokio_quic_Config_idle_timeout_get(const moq_tokio_quic_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Duration *moq_tokio_quic_Config_idle_timeout_get(const moq_tokio_quic_Config *self, moq_status *status); void moq_tokio_quic_Config_idle_timeout_set(moq_tokio_quic_Config *self, const moq_tokio_Duration *value, moq_status *status); -moq_tokio_Duration *moq_tokio_quic_Config_keep_alive_get(const moq_tokio_quic_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Duration *moq_tokio_quic_Config_keep_alive_get(const moq_tokio_quic_Config *self, moq_status *status); void moq_tokio_quic_Config_keep_alive_set(moq_tokio_quic_Config *self, const moq_tokio_Duration *value, moq_status *status); moq_option_bool moq_tokio_quic_Config_mtu_discovery_get(const moq_tokio_quic_Config *self, moq_status *status); void moq_tokio_quic_Config_mtu_discovery_set(moq_tokio_quic_Config *self, moq_option_bool value, moq_status *status); @@ -7787,109 +7797,109 @@ moq_option_u64 moq_tokio_quic_Config_stream_receive_window_get(const moq_tokio_q void moq_tokio_quic_Config_stream_receive_window_set(moq_tokio_quic_Config *self, moq_option_u64 value, moq_status *status); moq_option_u64 moq_tokio_quic_Config_send_window_get(const moq_tokio_quic_Config *self, moq_status *status); void moq_tokio_quic_Config_send_window_set(moq_tokio_quic_Config *self, moq_option_u64 value, moq_status *status); -moq_buf moq_tokio_quic_Config_qlog_get(const moq_tokio_quic_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_quic_Config_qlog_get(const moq_tokio_quic_Config *self, moq_status *status); void moq_tokio_quic_Config_qlog_set(moq_tokio_quic_Config *self, moq_buf value, moq_status *status); -moq_buf moq_tokio_quic_Config_keylog_get(const moq_tokio_quic_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_quic_Config_keylog_get(const moq_tokio_quic_Config *self, moq_status *status); void moq_tokio_quic_Config_keylog_set(moq_tokio_quic_Config *self, moq_buf value, moq_status *status); -moq_moq_tokio_cli_Deprecated *moq_tokio_quic_Config_deprecated(const moq_tokio_quic_Config *self, moq_status *status); -bool moq_tokio_quic_Config_validate(const moq_tokio_quic_Config *self, moq_tokio_Error **err, moq_status *status); -moq_moq_tokio_quic_Resolved *moq_tokio_quic_Config_resolve(const moq_tokio_quic_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_cli_Deprecated *moq_tokio_quic_Config_deprecated(const moq_tokio_quic_Config *self, moq_status *status); +MOQ_MUST_USE bool moq_tokio_quic_Config_validate(const moq_tokio_quic_Config *self, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_quic_Resolved *moq_tokio_quic_Config_resolve(const moq_tokio_quic_Config *self, moq_status *status); void moq_tokio_server_Config_free(moq_tokio_server_Config *self); void moq_tokio_server_Config_drop(moq_tokio_server_Config *self, moq_status *status); -moq_tokio_server_Config *moq_tokio_server_Config_default(void); -moq_tokio_tls_Serve *moq_tokio_server_Config_tls_get(const moq_tokio_server_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_server_Config *moq_tokio_server_Config_default(void); +MOQ_MUST_USE moq_tokio_tls_Serve *moq_tokio_server_Config_tls_get(const moq_tokio_server_Config *self, moq_status *status); void moq_tokio_server_Config_tls_set(moq_tokio_server_Config *self, moq_tokio_tls_Serve *value, moq_status *status); -moq_server_Admission *moq_tokio_server_Config_admission_get(const moq_tokio_server_Config *self, moq_status *status); +MOQ_MUST_USE moq_server_Admission *moq_tokio_server_Config_admission_get(const moq_tokio_server_Config *self, moq_status *status); void moq_tokio_server_Config_admission_set(moq_tokio_server_Config *self, moq_server_Admission *value, moq_status *status); -moq_tokio_listen_Config *moq_tokio_server_Config_listen_get(const moq_tokio_server_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_listen_Config *moq_tokio_server_Config_listen_get(const moq_tokio_server_Config *self, moq_status *status); void moq_tokio_server_Config_listen_set(moq_tokio_server_Config *self, moq_tokio_listen_Config *value, moq_status *status); -moq_tokio_quic_Config *moq_tokio_server_Config_quic_get(const moq_tokio_server_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_quic_Config *moq_tokio_server_Config_quic_get(const moq_tokio_server_Config *self, moq_status *status); void moq_tokio_server_Config_quic_set(moq_tokio_server_Config *self, moq_tokio_quic_Config *value, moq_status *status); -moq_moq_tokio_websocket_Listener *moq_tokio_server_Config_websocket_get(const moq_tokio_server_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_websocket_Listener *moq_tokio_server_Config_websocket_get(const moq_tokio_server_Config *self, moq_status *status); void moq_tokio_server_Config_websocket_set(moq_tokio_server_Config *self, moq_moq_tokio_websocket_Listener *value, moq_status *status); -moq_origin_Consumer *moq_tokio_server_Config_publisher_get(const moq_tokio_server_Config *self, moq_status *status); +MOQ_MUST_USE moq_origin_Consumer *moq_tokio_server_Config_publisher_get(const moq_tokio_server_Config *self, moq_status *status); void moq_tokio_server_Config_publisher_set(moq_tokio_server_Config *self, moq_origin_Consumer *value, moq_status *status); -moq_origin_Producer *moq_tokio_server_Config_subscriber_get(const moq_tokio_server_Config *self, moq_status *status); +MOQ_MUST_USE moq_origin_Producer *moq_tokio_server_Config_subscriber_get(const moq_tokio_server_Config *self, moq_status *status); void moq_tokio_server_Config_subscriber_set(moq_tokio_server_Config *self, moq_origin_Producer *value, moq_status *status); -moq_stats_Session *moq_tokio_server_Config_stats_get(const moq_tokio_server_Config *self, moq_status *status); +MOQ_MUST_USE moq_stats_Session *moq_tokio_server_Config_stats_get(const moq_tokio_server_Config *self, moq_status *status); void moq_tokio_server_Config_stats_set(moq_tokio_server_Config *self, moq_stats_Session *value, moq_status *status); -moq_moq_tokio_quic_demux_Demux *moq_tokio_server_Config_demux_get(const moq_tokio_server_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_quic_demux_Demux *moq_tokio_server_Config_demux_get(const moq_tokio_server_Config *self, moq_status *status); void moq_tokio_server_Config_demux_set(moq_tokio_server_Config *self, moq_moq_tokio_quic_demux_Demux *value, moq_status *status); -moq_moq_tokio_server_Streams *moq_tokio_server_Config_streams_get(const moq_tokio_server_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_server_Streams *moq_tokio_server_Config_streams_get(const moq_tokio_server_Config *self, moq_status *status); void moq_tokio_server_Config_streams_set(moq_tokio_server_Config *self, moq_moq_tokio_server_Streams *value, moq_status *status); -bool moq_tokio_server_Config_init(moq_tokio_server_Config *self, moq_tokio_Server **out, moq_tokio_Error **err, moq_status *status); -bool moq_tokio_server_Config_init_streams(moq_tokio_server_Config *self, moq_tokio_Server **out, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_tokio_server_Config_init(moq_tokio_server_Config *self, moq_tokio_Server **out, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_tokio_server_Config_init_streams(moq_tokio_server_Config *self, moq_tokio_Server **out, moq_tokio_Error **err, moq_status *status); void moq_tokio_server_Listener_free(moq_tokio_server_Listener *self); void moq_tokio_server_Listener_drop(moq_tokio_server_Listener *self, moq_status *status); typedef struct moq_tokio_server_Listener_accept_future moq_tokio_server_Listener_accept_future; -moq_tokio_server_Listener_accept_future *moq_tokio_server_Listener_accept(moq_tokio_server_Listener *self, moq_status *status); -moq_poll moq_tokio_server_Listener_accept_start(moq_tokio_server_Listener *self, moq_tokio_server_Request **out, moq_tokio_Error **err, moq_tokio_server_Listener_accept_future **future, moq_status *status); -moq_poll moq_tokio_server_Listener_accept_poll(moq_tokio_server_Listener_accept_future *future, moq_waker waker, moq_tokio_server_Request **out, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_server_Listener_accept_future *moq_tokio_server_Listener_accept(moq_tokio_server_Listener *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Listener_accept_start(moq_tokio_server_Listener *self, moq_tokio_server_Request **out, moq_tokio_Error **err, moq_tokio_server_Listener_accept_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Listener_accept_poll(moq_tokio_server_Listener_accept_future *future, moq_waker waker, moq_tokio_server_Request **out, moq_tokio_Error **err); void moq_tokio_server_Listener_accept_future_free(moq_tokio_server_Listener_accept_future *future); typedef struct moq_tokio_server_Listener_close_future moq_tokio_server_Listener_close_future; -moq_tokio_server_Listener_close_future *moq_tokio_server_Listener_close(moq_tokio_server_Listener *self, moq_status *status); -moq_poll moq_tokio_server_Listener_close_start(moq_tokio_server_Listener *self, moq_tokio_server_Listener_close_future **future, moq_status *status); -moq_poll moq_tokio_server_Listener_close_poll(moq_tokio_server_Listener_close_future *future, moq_waker waker); +MOQ_MUST_USE moq_tokio_server_Listener_close_future *moq_tokio_server_Listener_close(moq_tokio_server_Listener *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Listener_close_start(moq_tokio_server_Listener *self, moq_tokio_server_Listener_close_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Listener_close_poll(moq_tokio_server_Listener_close_future *future, moq_waker waker); void moq_tokio_server_Listener_close_future_free(moq_tokio_server_Listener_close_future *future); typedef struct moq_tokio_server_Listener_close_streams_future moq_tokio_server_Listener_close_streams_future; -moq_tokio_server_Listener_close_streams_future *moq_tokio_server_Listener_close_streams(moq_tokio_server_Listener *self, moq_status *status); -moq_poll moq_tokio_server_Listener_close_streams_start(moq_tokio_server_Listener *self, moq_tokio_server_Listener_close_streams_future **future, moq_status *status); -moq_poll moq_tokio_server_Listener_close_streams_poll(moq_tokio_server_Listener_close_streams_future *future, moq_waker waker); +MOQ_MUST_USE moq_tokio_server_Listener_close_streams_future *moq_tokio_server_Listener_close_streams(moq_tokio_server_Listener *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Listener_close_streams_start(moq_tokio_server_Listener *self, moq_tokio_server_Listener_close_streams_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Listener_close_streams_poll(moq_tokio_server_Listener_close_streams_future *future, moq_waker waker); void moq_tokio_server_Listener_close_streams_future_free(moq_tokio_server_Listener_close_streams_future *future); -bool moq_tokio_server_Listener_local_addr(const moq_tokio_server_Listener *self, moq_socket_addr *out, moq_tokio_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_tokio_server_Listener_local_addr(const moq_tokio_server_Listener *self, moq_socket_addr *out, moq_tokio_Error **err, moq_status *status); moq_option_socket_addr moq_tokio_server_Listener_websocket_local_addr(const moq_tokio_server_Listener *self, moq_status *status); moq_option_socket_addr moq_tokio_server_Listener_tcp_local_addr(const moq_tokio_server_Listener *self, moq_status *status); -moq_tokio_tls_Certificates *moq_tokio_server_Listener_certificates(const moq_tokio_server_Listener *self, moq_status *status); -moq_vec_moq_tokio_accept_Health moq_tokio_server_Listener_accept_health(const moq_tokio_server_Listener *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Certificates *moq_tokio_server_Listener_certificates(const moq_tokio_server_Listener *self, moq_status *status); +MOQ_MUST_USE moq_vec_moq_tokio_accept_Health moq_tokio_server_Listener_accept_health(const moq_tokio_server_Listener *self, moq_status *status); void moq_tokio_server_Request_free(moq_tokio_server_Request *self); void moq_tokio_server_Request_drop(moq_tokio_server_Request *self, moq_status *status); typedef struct moq_tokio_server_Request_reject_future moq_tokio_server_Request_reject_future; -moq_tokio_server_Request_reject_future *moq_tokio_server_Request_reject(moq_tokio_server_Request *self, moq_SessionError code, moq_status *status); -moq_poll moq_tokio_server_Request_reject_start(moq_tokio_server_Request *self, moq_SessionError code, moq_tokio_Error **err, moq_tokio_server_Request_reject_future **future, moq_status *status); -moq_poll moq_tokio_server_Request_reject_poll(moq_tokio_server_Request_reject_future *future, moq_waker waker, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_server_Request_reject_future *moq_tokio_server_Request_reject(moq_tokio_server_Request *self, moq_SessionError code, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Request_reject_start(moq_tokio_server_Request *self, moq_SessionError code, moq_tokio_Error **err, moq_tokio_server_Request_reject_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Request_reject_poll(moq_tokio_server_Request_reject_future *future, moq_waker waker, moq_tokio_Error **err); void moq_tokio_server_Request_reject_future_free(moq_tokio_server_Request_reject_future *future); -moq_tokio_server_Request *moq_tokio_server_Request_with_publisher_Producer(moq_tokio_server_Request *self, const moq_origin_Producer *publish, moq_status *status); -moq_tokio_server_Request *moq_tokio_server_Request_with_publisher_Consumer(moq_tokio_server_Request *self, const moq_origin_Consumer *publish, moq_status *status); -moq_tokio_server_Request *moq_tokio_server_Request_with_subscriber(moq_tokio_server_Request *self, moq_origin_Producer *subscribe, moq_status *status); -moq_tokio_server_Request *moq_tokio_server_Request_with_peer_node(moq_tokio_server_Request *self, uint64_t node, moq_status *status); -moq_tokio_server_Request *moq_tokio_server_Request_with_stats(moq_tokio_server_Request *self, moq_stats_Session *stats, moq_status *status); -moq_tokio_server_Request *moq_tokio_server_Request_with_limits(moq_tokio_server_Request *self, moq_session_Limits limits, moq_status *status); -moq_moq_tokio_server_QuicLimits *moq_tokio_server_Request_quic_limits(const moq_tokio_server_Request *self, moq_status *status); -bool moq_tokio_server_Request_with_quic_limits(moq_tokio_server_Request *self, const moq_moq_quic_Limits *limits, moq_tokio_server_Request **out, moq_buf *err, moq_status *status); +MOQ_MUST_USE moq_tokio_server_Request *moq_tokio_server_Request_with_publisher_Producer(moq_tokio_server_Request *self, const moq_origin_Producer *publish, moq_status *status); +MOQ_MUST_USE moq_tokio_server_Request *moq_tokio_server_Request_with_publisher_Consumer(moq_tokio_server_Request *self, const moq_origin_Consumer *publish, moq_status *status); +MOQ_MUST_USE moq_tokio_server_Request *moq_tokio_server_Request_with_subscriber(moq_tokio_server_Request *self, moq_origin_Producer *subscribe, moq_status *status); +MOQ_MUST_USE moq_tokio_server_Request *moq_tokio_server_Request_with_peer_node(moq_tokio_server_Request *self, uint64_t node, moq_status *status); +MOQ_MUST_USE moq_tokio_server_Request *moq_tokio_server_Request_with_stats(moq_tokio_server_Request *self, moq_stats_Session *stats, moq_status *status); +MOQ_MUST_USE moq_tokio_server_Request *moq_tokio_server_Request_with_limits(moq_tokio_server_Request *self, moq_session_Limits limits, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_server_QuicLimits *moq_tokio_server_Request_quic_limits(const moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE bool moq_tokio_server_Request_with_quic_limits(moq_tokio_server_Request *self, const moq_moq_quic_Limits *limits, moq_tokio_server_Request **out, moq_buf *err, moq_status *status); typedef struct moq_tokio_server_Request_expired_future moq_tokio_server_Request_expired_future; -moq_tokio_server_Request_expired_future *moq_tokio_server_Request_expired(moq_tokio_server_Request *self, moq_status *status); -moq_poll moq_tokio_server_Request_expired_start(moq_tokio_server_Request *self, moq_tokio_server_Request_expired_future **future, moq_status *status); -moq_poll moq_tokio_server_Request_expired_poll(moq_tokio_server_Request_expired_future *future, moq_waker waker); +MOQ_MUST_USE moq_tokio_server_Request_expired_future *moq_tokio_server_Request_expired(moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Request_expired_start(moq_tokio_server_Request *self, moq_tokio_server_Request_expired_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Request_expired_poll(moq_tokio_server_Request_expired_future *future, moq_waker waker); void moq_tokio_server_Request_expired_future_free(moq_tokio_server_Request_expired_future *future); typedef struct moq_tokio_server_Request_ok_future moq_tokio_server_Request_ok_future; -moq_tokio_server_Request_ok_future *moq_tokio_server_Request_ok(moq_tokio_server_Request *self, moq_status *status); -moq_poll moq_tokio_server_Request_ok_start(moq_tokio_server_Request *self, moq_Session **out, moq_tokio_Error **err, moq_tokio_server_Request_ok_future **future, moq_status *status); -moq_poll moq_tokio_server_Request_ok_poll(moq_tokio_server_Request_ok_future *future, moq_waker waker, moq_Session **out, moq_tokio_Error **err); +MOQ_MUST_USE moq_tokio_server_Request_ok_future *moq_tokio_server_Request_ok(moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Request_ok_start(moq_tokio_server_Request *self, moq_Session **out, moq_tokio_Error **err, moq_tokio_server_Request_ok_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_tokio_server_Request_ok_poll(moq_tokio_server_Request_ok_future *future, moq_waker waker, moq_Session **out, moq_tokio_Error **err); void moq_tokio_server_Request_ok_future_free(moq_tokio_server_Request_ok_future *future); moq_tokio_Transport moq_tokio_server_Request_transport(const moq_tokio_server_Request *self, moq_status *status); -moq_Url *moq_tokio_server_Request_url(const moq_tokio_server_Request *self, moq_status *status); -moq_buf moq_tokio_server_Request_authority(const moq_tokio_server_Request *self, moq_status *status); -moq_buf moq_tokio_server_Request_path(const moq_tokio_server_Request *self, moq_status *status); -moq_buf moq_tokio_server_Request_query(const moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_Url *moq_tokio_server_Request_url(const moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_server_Request_authority(const moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_server_Request_path(const moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_server_Request_query(const moq_tokio_server_Request *self, moq_status *status); moq_option_socket_addr moq_tokio_server_Request_remote_addr(const moq_tokio_server_Request *self, moq_status *status); moq_option_socket_addr moq_tokio_server_Request_local_addr(const moq_tokio_server_Request *self, moq_status *status); -moq_buf moq_tokio_server_Request_server_name(const moq_tokio_server_Request *self, moq_status *status); -moq_buf moq_tokio_server_Request_alpn(const moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_server_Request_server_name(const moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_server_Request_alpn(const moq_tokio_server_Request *self, moq_status *status); moq_option_setup_Role moq_tokio_server_Request_role(const moq_tokio_server_Request *self, moq_status *status); -moq_auth_Handle *moq_tokio_server_Request_auth(const moq_tokio_server_Request *self, moq_status *status); -moq_auth_Requests *moq_tokio_server_Request_requests(moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_auth_Handle *moq_tokio_server_Request_auth(const moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_auth_Requests *moq_tokio_server_Request_requests(moq_tokio_server_Request *self, moq_status *status); moq_option_non_zero_u64 moq_tokio_server_Request_peer_node(const moq_tokio_server_Request *self, moq_status *status); -moq_buf moq_tokio_server_Request_peer_implementation(const moq_tokio_server_Request *self, moq_status *status); -moq_option_setup_Token moq_tokio_server_Request_token(const moq_tokio_server_Request *self, moq_status *status); -moq_tokio_tls_PeerIdentity *moq_tokio_server_Request_peer_identity(const moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_tokio_server_Request_peer_implementation(const moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_option_setup_Token moq_tokio_server_Request_token(const moq_tokio_server_Request *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_PeerIdentity *moq_tokio_server_Request_peer_identity(const moq_tokio_server_Request *self, moq_status *status); void moq_transport_memory_Config_free(moq_transport_memory_Config *self); void moq_transport_memory_Config_drop(moq_transport_memory_Config *self, moq_status *status); -moq_transport_memory_Config *moq_transport_memory_Config_clone(const moq_transport_memory_Config *self, moq_status *status); -moq_buf moq_transport_memory_Config_debug(const moq_transport_memory_Config *self, moq_status *status); -moq_transport_memory_Config *moq_transport_memory_Config_default(void); +MOQ_MUST_USE moq_transport_memory_Config *moq_transport_memory_Config_clone(const moq_transport_memory_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_transport_memory_Config_debug(const moq_transport_memory_Config *self, moq_status *status); +MOQ_MUST_USE moq_transport_memory_Config *moq_transport_memory_Config_default(void); size_t moq_transport_memory_Config_stream_buffer_get(const moq_transport_memory_Config *self, moq_status *status); void moq_transport_memory_Config_stream_buffer_set(moq_transport_memory_Config *self, size_t value, moq_status *status); -moq_buf moq_transport_memory_Config_protocol_get(const moq_transport_memory_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_transport_memory_Config_protocol_get(const moq_transport_memory_Config *self, moq_status *status); void moq_transport_memory_Config_protocol_set(moq_transport_memory_Config *self, moq_buf value, moq_status *status); moq_option_usize moq_transport_memory_Config_max_concurrent_uni_streams_get(const moq_transport_memory_Config *self, moq_status *status); void moq_transport_memory_Config_max_concurrent_uni_streams_set(moq_transport_memory_Config *self, moq_option_usize value, moq_status *status); @@ -7900,75 +7910,75 @@ void moq_transport_memory_Config_latency_set(moq_transport_memory_Config *self, void moq_transport_memory_Session_free(moq_transport_memory_Session *self); void moq_transport_memory_Session_drop(moq_transport_memory_Session *self, moq_status *status); bool moq_transport_memory_Session_borrowed(const moq_transport_memory_Session *self); -moq_transport_memory_Session *moq_transport_memory_Session_clone(const moq_transport_memory_Session *self, moq_status *status); -moq_transport_memory_Closer *moq_transport_memory_Session_closer(const moq_transport_memory_Session *self, moq_status *status); +MOQ_MUST_USE moq_transport_memory_Session *moq_transport_memory_Session_clone(const moq_transport_memory_Session *self, moq_status *status); +MOQ_MUST_USE moq_transport_memory_Closer *moq_transport_memory_Session_closer(const moq_transport_memory_Session *self, moq_status *status); void moq_transport_memory_Closer_free(moq_transport_memory_Closer *self); bool moq_transport_memory_Closer_borrowed(const moq_transport_memory_Closer *self); -moq_transport_memory_Closer *moq_transport_memory_Closer_clone(const moq_transport_memory_Closer *self); +MOQ_MUST_USE moq_transport_memory_Closer *moq_transport_memory_Closer_clone(const moq_transport_memory_Closer *self); void moq_transport_memory_Closer_close(const moq_transport_memory_Closer *self, uint32_t code, moq_buf reason); bool moq_transport_memory_Closer_is_closed(const moq_transport_memory_Closer *self); void moq_mux_catalog_hang_Consumer_free(moq_mux_catalog_hang_Consumer *self); void moq_mux_catalog_hang_Consumer_drop(moq_mux_catalog_hang_Consumer *self, moq_status *status); -moq_mux_catalog_hang_Consumer *moq_mux_catalog_hang_Consumer_new(moq_track_Consumer *track, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_hang_Consumer *moq_mux_catalog_hang_Consumer_new(moq_track_Consumer *track, moq_status *status); typedef struct moq_mux_catalog_hang_Consumer_next_future moq_mux_catalog_hang_Consumer_next_future; -moq_mux_catalog_hang_Consumer_next_future *moq_mux_catalog_hang_Consumer_next(moq_mux_catalog_hang_Consumer *self, moq_status *status); -moq_poll moq_mux_catalog_hang_Consumer_next_start(moq_mux_catalog_hang_Consumer *self, moq_hang_Catalog **out, moq_mux_Error **err, moq_mux_catalog_hang_Consumer_next_future **future, moq_status *status); -moq_poll moq_mux_catalog_hang_Consumer_next_poll(moq_mux_catalog_hang_Consumer_next_future *future, moq_waker waker, moq_hang_Catalog **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_hang_Consumer_next_future *moq_mux_catalog_hang_Consumer_next(moq_mux_catalog_hang_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_hang_Consumer_next_start(moq_mux_catalog_hang_Consumer *self, moq_hang_Catalog **out, moq_mux_Error **err, moq_mux_catalog_hang_Consumer_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_hang_Consumer_next_poll(moq_mux_catalog_hang_Consumer_next_future *future, moq_waker waker, moq_hang_Catalog **out, moq_mux_Error **err); void moq_mux_catalog_hang_Consumer_next_future_free(moq_mux_catalog_hang_Consumer_next_future *future); void moq_mux_catalog_hang_Consumer_Extra_free(moq_mux_catalog_hang_Consumer_Extra *self); void moq_mux_catalog_hang_Consumer_Extra_drop(moq_mux_catalog_hang_Consumer_Extra *self, moq_status *status); -moq_mux_catalog_hang_Consumer_Extra *moq_mux_catalog_hang_Consumer_Extra_new(moq_track_Consumer *track, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_hang_Consumer_Extra *moq_mux_catalog_hang_Consumer_Extra_new(moq_track_Consumer *track, moq_status *status); typedef struct moq_mux_catalog_hang_Consumer_Extra_next_future moq_mux_catalog_hang_Consumer_Extra_next_future; -moq_mux_catalog_hang_Consumer_Extra_next_future *moq_mux_catalog_hang_Consumer_Extra_next(moq_mux_catalog_hang_Consumer_Extra *self, moq_status *status); -moq_poll moq_mux_catalog_hang_Consumer_Extra_next_start(moq_mux_catalog_hang_Consumer_Extra *self, moq_hang_Catalog_Extra **out, moq_mux_Error **err, moq_mux_catalog_hang_Consumer_Extra_next_future **future, moq_status *status); -moq_poll moq_mux_catalog_hang_Consumer_Extra_next_poll(moq_mux_catalog_hang_Consumer_Extra_next_future *future, moq_waker waker, moq_hang_Catalog_Extra **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_hang_Consumer_Extra_next_future *moq_mux_catalog_hang_Consumer_Extra_next(moq_mux_catalog_hang_Consumer_Extra *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_hang_Consumer_Extra_next_start(moq_mux_catalog_hang_Consumer_Extra *self, moq_hang_Catalog_Extra **out, moq_mux_Error **err, moq_mux_catalog_hang_Consumer_Extra_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_hang_Consumer_Extra_next_poll(moq_mux_catalog_hang_Consumer_Extra_next_future *future, moq_waker waker, moq_hang_Catalog_Extra **out, moq_mux_Error **err); void moq_mux_catalog_hang_Consumer_Extra_next_future_free(moq_mux_catalog_hang_Consumer_Extra_next_future *future); void moq_mux_catalog_hang_Consumer_Ext_free(moq_mux_catalog_hang_Consumer_Ext *self); void moq_mux_catalog_hang_Consumer_Ext_drop(moq_mux_catalog_hang_Consumer_Ext *self, moq_status *status); -moq_mux_catalog_hang_Consumer_Ext *moq_mux_catalog_hang_Consumer_Ext_new(moq_track_Consumer *track, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_hang_Consumer_Ext *moq_mux_catalog_hang_Consumer_Ext_new(moq_track_Consumer *track, moq_status *status); typedef struct moq_mux_catalog_hang_Consumer_Ext_next_future moq_mux_catalog_hang_Consumer_Ext_next_future; -moq_mux_catalog_hang_Consumer_Ext_next_future *moq_mux_catalog_hang_Consumer_Ext_next(moq_mux_catalog_hang_Consumer_Ext *self, moq_status *status); -moq_poll moq_mux_catalog_hang_Consumer_Ext_next_start(moq_mux_catalog_hang_Consumer_Ext *self, moq_hang_Catalog_Ext **out, moq_mux_Error **err, moq_mux_catalog_hang_Consumer_Ext_next_future **future, moq_status *status); -moq_poll moq_mux_catalog_hang_Consumer_Ext_next_poll(moq_mux_catalog_hang_Consumer_Ext_next_future *future, moq_waker waker, moq_hang_Catalog_Ext **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_hang_Consumer_Ext_next_future *moq_mux_catalog_hang_Consumer_Ext_next(moq_mux_catalog_hang_Consumer_Ext *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_hang_Consumer_Ext_next_start(moq_mux_catalog_hang_Consumer_Ext *self, moq_hang_Catalog_Ext **out, moq_mux_Error **err, moq_mux_catalog_hang_Consumer_Ext_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_hang_Consumer_Ext_next_poll(moq_mux_catalog_hang_Consumer_Ext_next_future *future, moq_waker waker, moq_hang_Catalog_Ext **out, moq_mux_Error **err); void moq_mux_catalog_hang_Consumer_Ext_next_future_free(moq_mux_catalog_hang_Consumer_Ext_next_future *future); void moq_mux_catalog_hang_Container_free(moq_mux_catalog_hang_Container *self); void moq_mux_catalog_hang_Container_drop(moq_mux_catalog_hang_Container *self, moq_status *status); -bool moq_mux_catalog_hang_Container_new(const moq_hang_catalog_Container *container, moq_mux_container_Kind kind, moq_mux_catalog_hang_Container **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_hang_Container_new(const moq_hang_catalog_Container *container, moq_mux_container_Kind kind, moq_mux_catalog_hang_Container **out, moq_mux_Error **err, moq_status *status); void moq_mux_catalog_hang_Extra_free(moq_mux_catalog_hang_Extra *self); void moq_mux_catalog_hang_Extra_drop(moq_mux_catalog_hang_Extra *self, moq_status *status); -moq_mux_catalog_hang_Extra *moq_mux_catalog_hang_Extra_clone(const moq_mux_catalog_hang_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_hang_Extra *moq_mux_catalog_hang_Extra_clone(const moq_mux_catalog_hang_Extra *self, moq_status *status); bool moq_mux_catalog_hang_Extra_eq(const moq_mux_catalog_hang_Extra *a, const moq_mux_catalog_hang_Extra *b, moq_status *status); -moq_buf moq_mux_catalog_hang_Extra_debug(const moq_mux_catalog_hang_Extra *self, moq_status *status); -moq_mux_catalog_hang_Extra *moq_mux_catalog_hang_Extra_default(void); -moq_Json *moq_mux_catalog_hang_Extra_get(const moq_mux_catalog_hang_Extra *self, moq_buf name, moq_status *status); -moq_vec_tuple_string_Json moq_mux_catalog_hang_Extra_iter(const moq_mux_catalog_hang_Extra *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_catalog_hang_Extra_debug(const moq_mux_catalog_hang_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_hang_Extra *moq_mux_catalog_hang_Extra_default(void); +MOQ_MUST_USE moq_Json *moq_mux_catalog_hang_Extra_get(const moq_mux_catalog_hang_Extra *self, moq_buf name, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_string_Json moq_mux_catalog_hang_Extra_iter(const moq_mux_catalog_hang_Extra *self, moq_status *status); size_t moq_mux_catalog_hang_Extra_len(const moq_mux_catalog_hang_Extra *self, moq_status *status); bool moq_mux_catalog_hang_Extra_is_empty(const moq_mux_catalog_hang_Extra *self, moq_status *status); -bool moq_mux_catalog_hang_Extra_set(moq_mux_catalog_hang_Extra *self, moq_buf name, moq_Json *value, moq_mux_Error **err, moq_status *status); -moq_Json *moq_mux_catalog_hang_Extra_remove(moq_mux_catalog_hang_Extra *self, moq_buf name, moq_status *status); +MOQ_MUST_USE bool moq_mux_catalog_hang_Extra_set(moq_mux_catalog_hang_Extra *self, moq_buf name, moq_Json *value, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_Json *moq_mux_catalog_hang_Extra_remove(moq_mux_catalog_hang_Extra *self, moq_buf name, moq_status *status); void moq_mux_catalog_msf_Consumer_free(moq_mux_catalog_msf_Consumer *self); void moq_mux_catalog_msf_Consumer_drop(moq_mux_catalog_msf_Consumer *self, moq_status *status); -moq_mux_catalog_msf_Consumer *moq_mux_catalog_msf_Consumer_new(moq_track_Subscriber *track, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_msf_Consumer *moq_mux_catalog_msf_Consumer_new(moq_track_Subscriber *track, moq_status *status); typedef struct moq_mux_catalog_msf_Consumer_next_future moq_mux_catalog_msf_Consumer_next_future; -moq_mux_catalog_msf_Consumer_next_future *moq_mux_catalog_msf_Consumer_next(moq_mux_catalog_msf_Consumer *self, moq_status *status); -moq_poll moq_mux_catalog_msf_Consumer_next_start(moq_mux_catalog_msf_Consumer *self, moq_hang_Catalog **out, moq_mux_Error **err, moq_mux_catalog_msf_Consumer_next_future **future, moq_status *status); -moq_poll moq_mux_catalog_msf_Consumer_next_poll(moq_mux_catalog_msf_Consumer_next_future *future, moq_waker waker, moq_hang_Catalog **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_msf_Consumer_next_future *moq_mux_catalog_msf_Consumer_next(moq_mux_catalog_msf_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_msf_Consumer_next_start(moq_mux_catalog_msf_Consumer *self, moq_hang_Catalog **out, moq_mux_Error **err, moq_mux_catalog_msf_Consumer_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_msf_Consumer_next_poll(moq_mux_catalog_msf_Consumer_next_future *future, moq_waker waker, moq_hang_Catalog **out, moq_mux_Error **err); void moq_mux_catalog_msf_Consumer_next_future_free(moq_mux_catalog_msf_Consumer_next_future *future); void moq_mux_catalog_msf_Consumer_Extra_free(moq_mux_catalog_msf_Consumer_Extra *self); void moq_mux_catalog_msf_Consumer_Extra_drop(moq_mux_catalog_msf_Consumer_Extra *self, moq_status *status); -moq_mux_catalog_msf_Consumer_Extra *moq_mux_catalog_msf_Consumer_Extra_new(moq_track_Subscriber *track, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_msf_Consumer_Extra *moq_mux_catalog_msf_Consumer_Extra_new(moq_track_Subscriber *track, moq_status *status); typedef struct moq_mux_catalog_msf_Consumer_Extra_next_future moq_mux_catalog_msf_Consumer_Extra_next_future; -moq_mux_catalog_msf_Consumer_Extra_next_future *moq_mux_catalog_msf_Consumer_Extra_next(moq_mux_catalog_msf_Consumer_Extra *self, moq_status *status); -moq_poll moq_mux_catalog_msf_Consumer_Extra_next_start(moq_mux_catalog_msf_Consumer_Extra *self, moq_hang_Catalog_Extra **out, moq_mux_Error **err, moq_mux_catalog_msf_Consumer_Extra_next_future **future, moq_status *status); -moq_poll moq_mux_catalog_msf_Consumer_Extra_next_poll(moq_mux_catalog_msf_Consumer_Extra_next_future *future, moq_waker waker, moq_hang_Catalog_Extra **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_msf_Consumer_Extra_next_future *moq_mux_catalog_msf_Consumer_Extra_next(moq_mux_catalog_msf_Consumer_Extra *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_msf_Consumer_Extra_next_start(moq_mux_catalog_msf_Consumer_Extra *self, moq_hang_Catalog_Extra **out, moq_mux_Error **err, moq_mux_catalog_msf_Consumer_Extra_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_msf_Consumer_Extra_next_poll(moq_mux_catalog_msf_Consumer_Extra_next_future *future, moq_waker waker, moq_hang_Catalog_Extra **out, moq_mux_Error **err); void moq_mux_catalog_msf_Consumer_Extra_next_future_free(moq_mux_catalog_msf_Consumer_Extra_next_future *future); void moq_mux_catalog_msf_Consumer_Ext_free(moq_mux_catalog_msf_Consumer_Ext *self); void moq_mux_catalog_msf_Consumer_Ext_drop(moq_mux_catalog_msf_Consumer_Ext *self, moq_status *status); -moq_mux_catalog_msf_Consumer_Ext *moq_mux_catalog_msf_Consumer_Ext_new(moq_track_Subscriber *track, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_msf_Consumer_Ext *moq_mux_catalog_msf_Consumer_Ext_new(moq_track_Subscriber *track, moq_status *status); typedef struct moq_mux_catalog_msf_Consumer_Ext_next_future moq_mux_catalog_msf_Consumer_Ext_next_future; -moq_mux_catalog_msf_Consumer_Ext_next_future *moq_mux_catalog_msf_Consumer_Ext_next(moq_mux_catalog_msf_Consumer_Ext *self, moq_status *status); -moq_poll moq_mux_catalog_msf_Consumer_Ext_next_start(moq_mux_catalog_msf_Consumer_Ext *self, moq_hang_Catalog_Ext **out, moq_mux_Error **err, moq_mux_catalog_msf_Consumer_Ext_next_future **future, moq_status *status); -moq_poll moq_mux_catalog_msf_Consumer_Ext_next_poll(moq_mux_catalog_msf_Consumer_Ext_next_future *future, moq_waker waker, moq_hang_Catalog_Ext **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_catalog_msf_Consumer_Ext_next_future *moq_mux_catalog_msf_Consumer_Ext_next(moq_mux_catalog_msf_Consumer_Ext *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_msf_Consumer_Ext_next_start(moq_mux_catalog_msf_Consumer_Ext *self, moq_hang_Catalog_Ext **out, moq_mux_Error **err, moq_mux_catalog_msf_Consumer_Ext_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_catalog_msf_Consumer_Ext_next_poll(moq_mux_catalog_msf_Consumer_Ext_next_future *future, moq_waker waker, moq_hang_Catalog_Ext **out, moq_mux_Error **err); void moq_mux_catalog_msf_Consumer_Ext_next_future_free(moq_mux_catalog_msf_Consumer_Ext_next_future *future); void moq_mux_codec_aac_Config_free(moq_mux_codec_aac_Config *self); void moq_mux_codec_aac_Config_drop(moq_mux_codec_aac_Config *self, moq_status *status); @@ -7978,83 +7988,83 @@ uint32_t moq_mux_codec_aac_Config_sample_rate_get(const moq_mux_codec_aac_Config void moq_mux_codec_aac_Config_sample_rate_set(moq_mux_codec_aac_Config *self, uint32_t value, moq_status *status); uint32_t moq_mux_codec_aac_Config_channel_count_get(const moq_mux_codec_aac_Config *self, moq_status *status); void moq_mux_codec_aac_Config_channel_count_set(moq_mux_codec_aac_Config *self, uint32_t value, moq_status *status); -moq_mux_codec_aac_Config *moq_mux_codec_aac_Config_new(uint8_t profile, uint32_t sample_rate, uint32_t channel_count); -bool moq_mux_codec_aac_Config_parse(moq_buf buf, moq_buf *buf_out, moq_mux_codec_aac_Config **out, moq_mux_codec_aac_Error **err); -bool moq_mux_codec_aac_Config_encode(const moq_mux_codec_aac_Config *self, moq_buf *out, moq_mux_codec_aac_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_codec_aac_Config *moq_mux_codec_aac_Config_new(uint8_t profile, uint32_t sample_rate, uint32_t channel_count); +MOQ_MUST_USE bool moq_mux_codec_aac_Config_parse(moq_buf buf, moq_buf *buf_out, moq_mux_codec_aac_Config **out, moq_mux_codec_aac_Error **err); +MOQ_MUST_USE bool moq_mux_codec_aac_Config_encode(const moq_mux_codec_aac_Config *self, moq_buf *out, moq_mux_codec_aac_Error **err, moq_status *status); void moq_mux_codec_aac_Error_free(moq_mux_codec_aac_Error *self); bool moq_mux_codec_aac_Error_borrowed(const moq_mux_codec_aac_Error *self); -moq_mux_codec_aac_Error *moq_mux_codec_aac_Error_clone(const moq_mux_codec_aac_Error *self); -moq_buf moq_mux_codec_aac_Error_to_string(const moq_mux_codec_aac_Error *self); -moq_buf moq_mux_codec_aac_Error_debug(const moq_mux_codec_aac_Error *self); +MOQ_MUST_USE moq_mux_codec_aac_Error *moq_mux_codec_aac_Error_clone(const moq_mux_codec_aac_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_aac_Error_to_string(const moq_mux_codec_aac_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_aac_Error_debug(const moq_mux_codec_aac_Error *self); void moq_mux_codec_aac_Import_free(moq_mux_codec_aac_Import *self); void moq_mux_codec_aac_Import_drop(moq_mux_codec_aac_Import *self, moq_status *status); -bool moq_mux_codec_aac_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_aac_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_aac_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_aac_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_aac_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_aac_Import **out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_codec_aac_Import_name(const moq_mux_codec_aac_Import *self, moq_status *status); -moq_track_Demand *moq_mux_codec_aac_Import_demand(const moq_mux_codec_aac_Import *self, moq_status *status); -bool moq_mux_codec_aac_Import_finish(moq_mux_codec_aac_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_aac_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_aac_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_aac_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_aac_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_aac_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_aac_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_codec_aac_Import_name(const moq_mux_codec_aac_Import *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_codec_aac_Import_demand(const moq_mux_codec_aac_Import *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_aac_Import_finish(moq_mux_codec_aac_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_aac_Import_abort(moq_mux_codec_aac_Import *self, moq_Error *err_, moq_status *status); -bool moq_mux_codec_aac_Import_abort_unwanted(moq_mux_codec_aac_Import *self, moq_Error *err_, moq_mux_codec_aac_Import **err, moq_status *status); -bool moq_mux_codec_aac_Import_cut(moq_mux_codec_aac_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_aac_Import_discontinuity(moq_mux_codec_aac_Import *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_aac_Import_seek(moq_mux_codec_aac_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_aac_Import_decode(moq_mux_codec_aac_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_aac_Import_abort_unwanted(moq_mux_codec_aac_Import *self, moq_Error *err_, moq_mux_codec_aac_Import **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_aac_Import_cut(moq_mux_codec_aac_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_aac_Import_discontinuity(moq_mux_codec_aac_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_aac_Import_seek(moq_mux_codec_aac_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_aac_Import_decode(moq_mux_codec_aac_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); void moq_mux_codec_annexb_Error_free(moq_mux_codec_annexb_Error *self); bool moq_mux_codec_annexb_Error_borrowed(const moq_mux_codec_annexb_Error *self); -moq_mux_codec_annexb_Error *moq_mux_codec_annexb_Error_clone(const moq_mux_codec_annexb_Error *self); -moq_buf moq_mux_codec_annexb_Error_to_string(const moq_mux_codec_annexb_Error *self); -moq_buf moq_mux_codec_annexb_Error_debug(const moq_mux_codec_annexb_Error *self); +MOQ_MUST_USE moq_mux_codec_annexb_Error *moq_mux_codec_annexb_Error_clone(const moq_mux_codec_annexb_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_annexb_Error_to_string(const moq_mux_codec_annexb_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_annexb_Error_debug(const moq_mux_codec_annexb_Error *self); void moq_mux_codec_av1_Import_free(moq_mux_codec_av1_Import *self); void moq_mux_codec_av1_Import_drop(moq_mux_codec_av1_Import *self, moq_status *status); -bool moq_mux_codec_av1_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_av1_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_av1_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_av1_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_av1_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_av1_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_av1_Import_initialize(moq_mux_codec_av1_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); -moq_track_Demand *moq_mux_codec_av1_Import_demand(const moq_mux_codec_av1_Import *self, moq_status *status); -bool moq_mux_codec_av1_Import_finish(moq_mux_codec_av1_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_av1_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_av1_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_av1_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Import_initialize(moq_mux_codec_av1_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_codec_av1_Import_demand(const moq_mux_codec_av1_Import *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Import_finish(moq_mux_codec_av1_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_av1_Import_abort(moq_mux_codec_av1_Import *self, moq_Error *err_, moq_status *status); -bool moq_mux_codec_av1_Import_abort_unwanted(moq_mux_codec_av1_Import *self, moq_Error *err_, moq_mux_codec_av1_Import **err, moq_status *status); -bool moq_mux_codec_av1_Import_cut(moq_mux_codec_av1_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_av1_Import_discontinuity(moq_mux_codec_av1_Import *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_av1_Import_set_enabled(moq_mux_codec_av1_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_av1_Import_seek(moq_mux_codec_av1_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_av1_Import_decode(moq_mux_codec_av1_Import *self, moq_vec_mux_container_Frame frames, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Import_abort_unwanted(moq_mux_codec_av1_Import *self, moq_Error *err_, moq_mux_codec_av1_Import **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Import_cut(moq_mux_codec_av1_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Import_discontinuity(moq_mux_codec_av1_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Import_set_enabled(moq_mux_codec_av1_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Import_seek(moq_mux_codec_av1_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Import_decode(moq_mux_codec_av1_Import *self, moq_vec_mux_container_Frame frames, moq_mux_Error **err, moq_status *status); void moq_mux_codec_av1_Split_free(moq_mux_codec_av1_Split *self); void moq_mux_codec_av1_Split_drop(moq_mux_codec_av1_Split *self, moq_status *status); -moq_mux_codec_av1_Split *moq_mux_codec_av1_Split_default(void); -moq_mux_codec_av1_Split *moq_mux_codec_av1_Split_new(void); -bool moq_mux_codec_av1_Split_decode(moq_mux_codec_av1_Split *self, moq_buf data_, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_av1_Split_flush(moq_mux_codec_av1_Split *self, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_codec_av1_Split *moq_mux_codec_av1_Split_default(void); +MOQ_MUST_USE moq_mux_codec_av1_Split *moq_mux_codec_av1_Split_new(void); +MOQ_MUST_USE bool moq_mux_codec_av1_Split_decode(moq_mux_codec_av1_Split *self, moq_buf data_, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_av1_Split_flush(moq_mux_codec_av1_Split *self, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_av1_Split_reset(moq_mux_codec_av1_Split *self, moq_status *status); void moq_mux_codec_flac_Import_free(moq_mux_codec_flac_Import *self); void moq_mux_codec_flac_Import_drop(moq_mux_codec_flac_Import *self, moq_status *status); -bool moq_mux_codec_flac_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_flac_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_flac_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_flac_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_flac_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_flac_Import **out, moq_mux_Error **err, moq_status *status); -moq_track_Demand *moq_mux_codec_flac_Import_demand(const moq_mux_codec_flac_Import *self, moq_status *status); -bool moq_mux_codec_flac_Import_finish(moq_mux_codec_flac_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_flac_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_flac_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_flac_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_flac_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_flac_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_flac_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_codec_flac_Import_demand(const moq_mux_codec_flac_Import *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_flac_Import_finish(moq_mux_codec_flac_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_flac_Import_abort(moq_mux_codec_flac_Import *self, moq_Error *err_, moq_status *status); -bool moq_mux_codec_flac_Import_abort_unwanted(moq_mux_codec_flac_Import *self, moq_Error *err_, moq_mux_codec_flac_Import **err, moq_status *status); -bool moq_mux_codec_flac_Import_cut(moq_mux_codec_flac_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_flac_Import_discontinuity(moq_mux_codec_flac_Import *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_flac_Import_seek(moq_mux_codec_flac_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_flac_Import_decode(moq_mux_codec_flac_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_flac_Import_abort_unwanted(moq_mux_codec_flac_Import *self, moq_Error *err_, moq_mux_codec_flac_Import **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_flac_Import_cut(moq_mux_codec_flac_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_flac_Import_discontinuity(moq_mux_codec_flac_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_flac_Import_seek(moq_mux_codec_flac_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_flac_Import_decode(moq_mux_codec_flac_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h264_Avc1_free(moq_mux_codec_h264_Avc1 *self); void moq_mux_codec_h264_Avc1_drop(moq_mux_codec_h264_Avc1 *self, moq_status *status); -moq_mux_codec_h264_Avc1 *moq_mux_codec_h264_Avc1_default(void); -moq_mux_codec_h264_Avc1 *moq_mux_codec_h264_Avc1_new(void); -moq_buf moq_mux_codec_h264_Avc1_avcc(const moq_mux_codec_h264_Avc1 *self, moq_status *status); -bool moq_mux_codec_h264_Avc1_transform(moq_mux_codec_h264_Avc1 *self, moq_buf payload, moq_buf *out, moq_mux_codec_h264_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_codec_h264_Avc1 *moq_mux_codec_h264_Avc1_default(void); +MOQ_MUST_USE moq_mux_codec_h264_Avc1 *moq_mux_codec_h264_Avc1_new(void); +MOQ_MUST_USE moq_buf moq_mux_codec_h264_Avc1_avcc(const moq_mux_codec_h264_Avc1 *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Avc1_transform(moq_mux_codec_h264_Avc1 *self, moq_buf payload, moq_buf *out, moq_mux_codec_h264_Error **err, moq_status *status); void moq_mux_codec_h264_Error_free(moq_mux_codec_h264_Error *self); bool moq_mux_codec_h264_Error_borrowed(const moq_mux_codec_h264_Error *self); -moq_mux_codec_h264_Error *moq_mux_codec_h264_Error_clone(const moq_mux_codec_h264_Error *self); -moq_buf moq_mux_codec_h264_Error_to_string(const moq_mux_codec_h264_Error *self); -moq_buf moq_mux_codec_h264_Error_debug(const moq_mux_codec_h264_Error *self); +MOQ_MUST_USE moq_mux_codec_h264_Error *moq_mux_codec_h264_Error_clone(const moq_mux_codec_h264_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_h264_Error_to_string(const moq_mux_codec_h264_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_h264_Error_debug(const moq_mux_codec_h264_Error *self); void moq_mux_codec_h264_Avcc_free(moq_mux_codec_h264_Avcc *self); void moq_mux_codec_h264_Avcc_drop(moq_mux_codec_h264_Avcc *self, moq_status *status); -moq_mux_codec_h264_Avcc *moq_mux_codec_h264_Avcc_clone(const moq_mux_codec_h264_Avcc *self, moq_status *status); -moq_buf moq_mux_codec_h264_Avcc_debug(const moq_mux_codec_h264_Avcc *self, moq_status *status); +MOQ_MUST_USE moq_mux_codec_h264_Avcc *moq_mux_codec_h264_Avcc_clone(const moq_mux_codec_h264_Avcc *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_codec_h264_Avcc_debug(const moq_mux_codec_h264_Avcc *self, moq_status *status); uint8_t moq_mux_codec_h264_Avcc_profile_get(const moq_mux_codec_h264_Avcc *self, moq_status *status); void moq_mux_codec_h264_Avcc_profile_set(moq_mux_codec_h264_Avcc *self, uint8_t value, moq_status *status); uint8_t moq_mux_codec_h264_Avcc_constraints_get(const moq_mux_codec_h264_Avcc *self, moq_status *status); @@ -8063,118 +8073,118 @@ uint8_t moq_mux_codec_h264_Avcc_level_get(const moq_mux_codec_h264_Avcc *self, m void moq_mux_codec_h264_Avcc_level_set(moq_mux_codec_h264_Avcc *self, uint8_t value, moq_status *status); size_t moq_mux_codec_h264_Avcc_length_size_get(const moq_mux_codec_h264_Avcc *self, moq_status *status); void moq_mux_codec_h264_Avcc_length_size_set(moq_mux_codec_h264_Avcc *self, size_t value, moq_status *status); -moq_vec_bytes moq_mux_codec_h264_Avcc_sps_get(const moq_mux_codec_h264_Avcc *self, moq_status *status); +MOQ_MUST_USE moq_vec_bytes moq_mux_codec_h264_Avcc_sps_get(const moq_mux_codec_h264_Avcc *self, moq_status *status); void moq_mux_codec_h264_Avcc_sps_set(moq_mux_codec_h264_Avcc *self, moq_vec_bytes value, moq_status *status); -moq_vec_bytes moq_mux_codec_h264_Avcc_pps_get(const moq_mux_codec_h264_Avcc *self, moq_status *status); +MOQ_MUST_USE moq_vec_bytes moq_mux_codec_h264_Avcc_pps_get(const moq_mux_codec_h264_Avcc *self, moq_status *status); void moq_mux_codec_h264_Avcc_pps_set(moq_mux_codec_h264_Avcc *self, moq_vec_bytes value, moq_status *status); moq_option_u32 moq_mux_codec_h264_Avcc_coded_width_get(const moq_mux_codec_h264_Avcc *self, moq_status *status); void moq_mux_codec_h264_Avcc_coded_width_set(moq_mux_codec_h264_Avcc *self, moq_option_u32 value, moq_status *status); moq_option_u32 moq_mux_codec_h264_Avcc_coded_height_get(const moq_mux_codec_h264_Avcc *self, moq_status *status); void moq_mux_codec_h264_Avcc_coded_height_set(moq_mux_codec_h264_Avcc *self, moq_option_u32 value, moq_status *status); -bool moq_mux_codec_h264_Avcc_parse(moq_buf avcc, moq_mux_codec_h264_Avcc **out, moq_mux_codec_h264_Error **err); +MOQ_MUST_USE bool moq_mux_codec_h264_Avcc_parse(moq_buf avcc, moq_mux_codec_h264_Avcc **out, moq_mux_codec_h264_Error **err); void moq_mux_codec_h264_Import_free(moq_mux_codec_h264_Import *self); void moq_mux_codec_h264_Import_drop(moq_mux_codec_h264_Import *self, moq_status *status); -bool moq_mux_codec_h264_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h264_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h264_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h264_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h264_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h264_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h264_Import_initialize(moq_mux_codec_h264_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_codec_h264_Import_name(const moq_mux_codec_h264_Import *self, moq_status *status); -moq_track_Demand *moq_mux_codec_h264_Import_demand(const moq_mux_codec_h264_Import *self, moq_status *status); -moq_track_Producer *moq_mux_codec_h264_Import_track(const moq_mux_codec_h264_Import *self, moq_status *status); -bool moq_mux_codec_h264_Import_finish(moq_mux_codec_h264_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h264_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h264_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h264_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_initialize(moq_mux_codec_h264_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_codec_h264_Import_name(const moq_mux_codec_h264_Import *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_codec_h264_Import_demand(const moq_mux_codec_h264_Import *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_codec_h264_Import_track(const moq_mux_codec_h264_Import *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_finish(moq_mux_codec_h264_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h264_Import_abort(moq_mux_codec_h264_Import *self, moq_Error *err_, moq_status *status); -bool moq_mux_codec_h264_Import_abort_unwanted(moq_mux_codec_h264_Import *self, moq_Error *err_, moq_mux_codec_h264_Import **err, moq_status *status); -bool moq_mux_codec_h264_Import_cut(moq_mux_codec_h264_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h264_Import_discontinuity(moq_mux_codec_h264_Import *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h264_Import_set_enabled(moq_mux_codec_h264_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_abort_unwanted(moq_mux_codec_h264_Import *self, moq_Error *err_, moq_mux_codec_h264_Import **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_cut(moq_mux_codec_h264_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_discontinuity(moq_mux_codec_h264_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_set_enabled(moq_mux_codec_h264_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h264_Import_report_skipped(const moq_mux_codec_h264_Import *self, uint64_t frames, moq_status *status); void moq_mux_codec_h264_Import_report_bitrate(const moq_mux_codec_h264_Import *self, moq_bandwidth_Rate bitrate, moq_status *status); -bool moq_mux_codec_h264_Import_seek(moq_mux_codec_h264_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h264_Import_observe_reorder(moq_mux_codec_h264_Import *self, moq_Timestamp reorder, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h264_Import_decode(moq_mux_codec_h264_Import *self, moq_vec_mux_container_Frame frames, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_seek(moq_mux_codec_h264_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_observe_reorder(moq_mux_codec_h264_Import *self, moq_Timestamp reorder, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Import_decode(moq_mux_codec_h264_Import *self, moq_vec_mux_container_Frame frames, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h264_Split_free(moq_mux_codec_h264_Split *self); void moq_mux_codec_h264_Split_drop(moq_mux_codec_h264_Split *self, moq_status *status); -moq_mux_codec_h264_Split *moq_mux_codec_h264_Split_default(void); -moq_mux_codec_h264_Split *moq_mux_codec_h264_Split_new(void); -bool moq_mux_codec_h264_Split_decode(moq_mux_codec_h264_Split *self, moq_buf data_, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h264_Split_flush(moq_mux_codec_h264_Split *self, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_codec_h264_Split *moq_mux_codec_h264_Split_default(void); +MOQ_MUST_USE moq_mux_codec_h264_Split *moq_mux_codec_h264_Split_new(void); +MOQ_MUST_USE bool moq_mux_codec_h264_Split_decode(moq_mux_codec_h264_Split *self, moq_buf data_, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h264_Split_flush(moq_mux_codec_h264_Split *self, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h264_Split_reset(moq_mux_codec_h264_Split *self, moq_status *status); void moq_mux_codec_h265_Hvc1_free(moq_mux_codec_h265_Hvc1 *self); void moq_mux_codec_h265_Hvc1_drop(moq_mux_codec_h265_Hvc1 *self, moq_status *status); -moq_mux_codec_h265_Hvc1 *moq_mux_codec_h265_Hvc1_default(void); -moq_mux_codec_h265_Hvc1 *moq_mux_codec_h265_Hvc1_new(void); -moq_buf moq_mux_codec_h265_Hvc1_hvcc(const moq_mux_codec_h265_Hvc1 *self, moq_status *status); -bool moq_mux_codec_h265_Hvc1_transform(moq_mux_codec_h265_Hvc1 *self, moq_buf payload, moq_buf *out, moq_mux_codec_h265_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_codec_h265_Hvc1 *moq_mux_codec_h265_Hvc1_default(void); +MOQ_MUST_USE moq_mux_codec_h265_Hvc1 *moq_mux_codec_h265_Hvc1_new(void); +MOQ_MUST_USE moq_buf moq_mux_codec_h265_Hvc1_hvcc(const moq_mux_codec_h265_Hvc1 *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Hvc1_transform(moq_mux_codec_h265_Hvc1 *self, moq_buf payload, moq_buf *out, moq_mux_codec_h265_Error **err, moq_status *status); void moq_mux_codec_h265_Error_free(moq_mux_codec_h265_Error *self); bool moq_mux_codec_h265_Error_borrowed(const moq_mux_codec_h265_Error *self); -moq_mux_codec_h265_Error *moq_mux_codec_h265_Error_clone(const moq_mux_codec_h265_Error *self); -moq_buf moq_mux_codec_h265_Error_to_string(const moq_mux_codec_h265_Error *self); -moq_buf moq_mux_codec_h265_Error_debug(const moq_mux_codec_h265_Error *self); +MOQ_MUST_USE moq_mux_codec_h265_Error *moq_mux_codec_h265_Error_clone(const moq_mux_codec_h265_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_h265_Error_to_string(const moq_mux_codec_h265_Error *self); +MOQ_MUST_USE moq_buf moq_mux_codec_h265_Error_debug(const moq_mux_codec_h265_Error *self); void moq_mux_codec_h265_Hvcc_free(moq_mux_codec_h265_Hvcc *self); void moq_mux_codec_h265_Hvcc_drop(moq_mux_codec_h265_Hvcc *self, moq_status *status); -moq_mux_codec_h265_Hvcc *moq_mux_codec_h265_Hvcc_clone(const moq_mux_codec_h265_Hvcc *self, moq_status *status); -moq_buf moq_mux_codec_h265_Hvcc_debug(const moq_mux_codec_h265_Hvcc *self, moq_status *status); +MOQ_MUST_USE moq_mux_codec_h265_Hvcc *moq_mux_codec_h265_Hvcc_clone(const moq_mux_codec_h265_Hvcc *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_codec_h265_Hvcc_debug(const moq_mux_codec_h265_Hvcc *self, moq_status *status); size_t moq_mux_codec_h265_Hvcc_length_size_get(const moq_mux_codec_h265_Hvcc *self, moq_status *status); void moq_mux_codec_h265_Hvcc_length_size_set(moq_mux_codec_h265_Hvcc *self, size_t value, moq_status *status); -moq_vec_bytes moq_mux_codec_h265_Hvcc_vps_get(const moq_mux_codec_h265_Hvcc *self, moq_status *status); +MOQ_MUST_USE moq_vec_bytes moq_mux_codec_h265_Hvcc_vps_get(const moq_mux_codec_h265_Hvcc *self, moq_status *status); void moq_mux_codec_h265_Hvcc_vps_set(moq_mux_codec_h265_Hvcc *self, moq_vec_bytes value, moq_status *status); -moq_vec_bytes moq_mux_codec_h265_Hvcc_sps_get(const moq_mux_codec_h265_Hvcc *self, moq_status *status); +MOQ_MUST_USE moq_vec_bytes moq_mux_codec_h265_Hvcc_sps_get(const moq_mux_codec_h265_Hvcc *self, moq_status *status); void moq_mux_codec_h265_Hvcc_sps_set(moq_mux_codec_h265_Hvcc *self, moq_vec_bytes value, moq_status *status); -moq_vec_bytes moq_mux_codec_h265_Hvcc_pps_get(const moq_mux_codec_h265_Hvcc *self, moq_status *status); +MOQ_MUST_USE moq_vec_bytes moq_mux_codec_h265_Hvcc_pps_get(const moq_mux_codec_h265_Hvcc *self, moq_status *status); void moq_mux_codec_h265_Hvcc_pps_set(moq_mux_codec_h265_Hvcc *self, moq_vec_bytes value, moq_status *status); -bool moq_mux_codec_h265_Hvcc_parse(moq_buf hvcc, moq_mux_codec_h265_Hvcc **out, moq_mux_codec_h265_Error **err); +MOQ_MUST_USE bool moq_mux_codec_h265_Hvcc_parse(moq_buf hvcc, moq_mux_codec_h265_Hvcc **out, moq_mux_codec_h265_Error **err); void moq_mux_codec_h265_Sps_free(moq_mux_codec_h265_Sps *self); bool moq_mux_codec_h265_Sps_borrowed(const moq_mux_codec_h265_Sps *self); -moq_mux_codec_h265_Sps *moq_mux_codec_h265_Sps_clone(const moq_mux_codec_h265_Sps *self); -moq_buf moq_mux_codec_h265_Sps_debug(const moq_mux_codec_h265_Sps *self); -bool moq_mux_codec_h265_Sps_parse(moq_buf nal, moq_mux_codec_h265_Sps **out, moq_mux_codec_h265_Error **err); +MOQ_MUST_USE moq_mux_codec_h265_Sps *moq_mux_codec_h265_Sps_clone(const moq_mux_codec_h265_Sps *self); +MOQ_MUST_USE moq_buf moq_mux_codec_h265_Sps_debug(const moq_mux_codec_h265_Sps *self); +MOQ_MUST_USE bool moq_mux_codec_h265_Sps_parse(moq_buf nal, moq_mux_codec_h265_Sps **out, moq_mux_codec_h265_Error **err); void moq_mux_codec_h265_Sps_size(const moq_mux_codec_h265_Sps *self, uint32_t *out0, uint32_t *out1); moq_option_mux_codec_h265_VideoSignal moq_mux_codec_h265_Sps_video_signal(const moq_mux_codec_h265_Sps *self); void moq_mux_codec_h265_Import_free(moq_mux_codec_h265_Import *self); void moq_mux_codec_h265_Import_drop(moq_mux_codec_h265_Import *self, moq_status *status); -bool moq_mux_codec_h265_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h265_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h265_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h265_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h265_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h265_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h265_Import_initialize(moq_mux_codec_h265_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_codec_h265_Import_name(const moq_mux_codec_h265_Import *self, moq_status *status); -moq_track_Demand *moq_mux_codec_h265_Import_demand(const moq_mux_codec_h265_Import *self, moq_status *status); -moq_track_Producer *moq_mux_codec_h265_Import_track(const moq_mux_codec_h265_Import *self, moq_status *status); -bool moq_mux_codec_h265_Import_finish(moq_mux_codec_h265_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h265_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h265_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_h265_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_initialize(moq_mux_codec_h265_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_codec_h265_Import_name(const moq_mux_codec_h265_Import *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_codec_h265_Import_demand(const moq_mux_codec_h265_Import *self, moq_status *status); +MOQ_MUST_USE moq_track_Producer *moq_mux_codec_h265_Import_track(const moq_mux_codec_h265_Import *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_finish(moq_mux_codec_h265_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h265_Import_abort(moq_mux_codec_h265_Import *self, moq_Error *err_, moq_status *status); -bool moq_mux_codec_h265_Import_abort_unwanted(moq_mux_codec_h265_Import *self, moq_Error *err_, moq_mux_codec_h265_Import **err, moq_status *status); -bool moq_mux_codec_h265_Import_cut(moq_mux_codec_h265_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h265_Import_discontinuity(moq_mux_codec_h265_Import *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h265_Import_set_enabled(moq_mux_codec_h265_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_abort_unwanted(moq_mux_codec_h265_Import *self, moq_Error *err_, moq_mux_codec_h265_Import **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_cut(moq_mux_codec_h265_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_discontinuity(moq_mux_codec_h265_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_set_enabled(moq_mux_codec_h265_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h265_Import_report_skipped(const moq_mux_codec_h265_Import *self, uint64_t frames, moq_status *status); void moq_mux_codec_h265_Import_report_bitrate(const moq_mux_codec_h265_Import *self, moq_bandwidth_Rate bitrate, moq_status *status); -bool moq_mux_codec_h265_Import_seek(moq_mux_codec_h265_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h265_Import_observe_reorder(moq_mux_codec_h265_Import *self, moq_Timestamp reorder, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h265_Import_decode(moq_mux_codec_h265_Import *self, moq_vec_mux_container_Frame frames, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_seek(moq_mux_codec_h265_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_observe_reorder(moq_mux_codec_h265_Import *self, moq_Timestamp reorder, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Import_decode(moq_mux_codec_h265_Import *self, moq_vec_mux_container_Frame frames, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h265_Split_free(moq_mux_codec_h265_Split *self); void moq_mux_codec_h265_Split_drop(moq_mux_codec_h265_Split *self, moq_status *status); -moq_mux_codec_h265_Split *moq_mux_codec_h265_Split_default(void); -moq_mux_codec_h265_Split *moq_mux_codec_h265_Split_new(void); -bool moq_mux_codec_h265_Split_decode(moq_mux_codec_h265_Split *self, moq_buf data_, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_h265_Split_flush(moq_mux_codec_h265_Split *self, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_codec_h265_Split *moq_mux_codec_h265_Split_default(void); +MOQ_MUST_USE moq_mux_codec_h265_Split *moq_mux_codec_h265_Split_new(void); +MOQ_MUST_USE bool moq_mux_codec_h265_Split_decode(moq_mux_codec_h265_Split *self, moq_buf data_, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_h265_Split_flush(moq_mux_codec_h265_Split *self, moq_option_Timestamp pts, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_h265_Split_reset(moq_mux_codec_h265_Split *self, moq_status *status); void moq_mux_codec_mp3_Import_free(moq_mux_codec_mp3_Import *self); void moq_mux_codec_mp3_Import_drop(moq_mux_codec_mp3_Import *self, moq_status *status); -bool moq_mux_codec_mp3_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_mp3_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_mp3_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_mp3_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_mp3_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_mp3_Import **out, moq_mux_Error **err, moq_status *status); -moq_track_Demand *moq_mux_codec_mp3_Import_demand(const moq_mux_codec_mp3_Import *self, moq_status *status); -bool moq_mux_codec_mp3_Import_finish(moq_mux_codec_mp3_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_mp3_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_mp3_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_mp3_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_mp3_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_mp3_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_mp3_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_codec_mp3_Import_demand(const moq_mux_codec_mp3_Import *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_mp3_Import_finish(moq_mux_codec_mp3_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_mp3_Import_abort(moq_mux_codec_mp3_Import *self, moq_Error *err_, moq_status *status); -bool moq_mux_codec_mp3_Import_abort_unwanted(moq_mux_codec_mp3_Import *self, moq_Error *err_, moq_mux_codec_mp3_Import **err, moq_status *status); -bool moq_mux_codec_mp3_Import_cut(moq_mux_codec_mp3_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_mp3_Import_discontinuity(moq_mux_codec_mp3_Import *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_mp3_Import_seek(moq_mux_codec_mp3_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_mp3_Import_decode(moq_mux_codec_mp3_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_mp3_Import_abort_unwanted(moq_mux_codec_mp3_Import *self, moq_Error *err_, moq_mux_codec_mp3_Import **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_mp3_Import_cut(moq_mux_codec_mp3_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_mp3_Import_discontinuity(moq_mux_codec_mp3_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_mp3_Import_seek(moq_mux_codec_mp3_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_mp3_Import_decode(moq_mux_codec_mp3_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); void moq_mux_codec_opus_Config_free(moq_mux_codec_opus_Config *self); void moq_mux_codec_opus_Config_drop(moq_mux_codec_opus_Config *self, moq_status *status); -moq_mux_codec_opus_Config *moq_mux_codec_opus_Config_clone(const moq_mux_codec_opus_Config *self, moq_status *status); +MOQ_MUST_USE moq_mux_codec_opus_Config *moq_mux_codec_opus_Config_clone(const moq_mux_codec_opus_Config *self, moq_status *status); bool moq_mux_codec_opus_Config_eq(const moq_mux_codec_opus_Config *a, const moq_mux_codec_opus_Config *b, moq_status *status); -moq_buf moq_mux_codec_opus_Config_debug(const moq_mux_codec_opus_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_codec_opus_Config_debug(const moq_mux_codec_opus_Config *self, moq_status *status); uint32_t moq_mux_codec_opus_Config_sample_rate_get(const moq_mux_codec_opus_Config *self, moq_status *status); void moq_mux_codec_opus_Config_sample_rate_set(moq_mux_codec_opus_Config *self, uint32_t value, moq_status *status); uint32_t moq_mux_codec_opus_Config_channel_count_get(const moq_mux_codec_opus_Config *self, moq_status *status); @@ -8185,77 +8195,77 @@ int16_t moq_mux_codec_opus_Config_output_gain_get(const moq_mux_codec_opus_Confi void moq_mux_codec_opus_Config_output_gain_set(moq_mux_codec_opus_Config *self, int16_t value, moq_status *status); moq_option_mux_codec_opus_Mapping moq_mux_codec_opus_Config_mapping_get(const moq_mux_codec_opus_Config *self, moq_status *status); void moq_mux_codec_opus_Config_mapping_set(moq_mux_codec_opus_Config *self, moq_option_mux_codec_opus_Mapping value, moq_status *status); -moq_mux_codec_opus_Config *moq_mux_codec_opus_Config_new(uint32_t sample_rate, uint32_t channel_count); -moq_mux_codec_opus_Config *moq_mux_codec_opus_Config_with_pre_skip(const moq_mux_codec_opus_Config *self, uint16_t pre_skip, moq_status *status); -bool moq_mux_codec_opus_Config_parse(moq_buf buf, moq_buf *buf_out, moq_mux_codec_opus_Config **out, moq_mux_codec_opus_Error *err); -bool moq_mux_codec_opus_Config_encode(const moq_mux_codec_opus_Config *self, moq_buf *out, moq_mux_codec_opus_Error *err, moq_status *status); +MOQ_MUST_USE moq_mux_codec_opus_Config *moq_mux_codec_opus_Config_new(uint32_t sample_rate, uint32_t channel_count); +MOQ_MUST_USE moq_mux_codec_opus_Config *moq_mux_codec_opus_Config_with_pre_skip(const moq_mux_codec_opus_Config *self, uint16_t pre_skip, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_opus_Config_parse(moq_buf buf, moq_buf *buf_out, moq_mux_codec_opus_Config **out, moq_mux_codec_opus_Error *err); +MOQ_MUST_USE bool moq_mux_codec_opus_Config_encode(const moq_mux_codec_opus_Config *self, moq_buf *out, moq_mux_codec_opus_Error *err, moq_status *status); void moq_mux_codec_opus_Import_free(moq_mux_codec_opus_Import *self); void moq_mux_codec_opus_Import_drop(moq_mux_codec_opus_Import *self, moq_status *status); -bool moq_mux_codec_opus_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_opus_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_opus_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_opus_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_opus_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_opus_Import **out, moq_mux_Error **err, moq_status *status); -moq_buf moq_mux_codec_opus_Import_name(const moq_mux_codec_opus_Import *self, moq_status *status); -moq_track_Demand *moq_mux_codec_opus_Import_demand(const moq_mux_codec_opus_Import *self, moq_status *status); -bool moq_mux_codec_opus_Import_finish(moq_mux_codec_opus_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_opus_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_opus_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_opus_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_opus_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_opus_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_hang_catalog_AudioConfig *config, moq_mux_codec_opus_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_codec_opus_Import_name(const moq_mux_codec_opus_Import *self, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_codec_opus_Import_demand(const moq_mux_codec_opus_Import *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_opus_Import_finish(moq_mux_codec_opus_Import *self, moq_mux_container_Finished_Container_AudioConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_opus_Import_abort(moq_mux_codec_opus_Import *self, moq_Error *err_, moq_status *status); -bool moq_mux_codec_opus_Import_abort_unwanted(moq_mux_codec_opus_Import *self, moq_Error *err_, moq_mux_codec_opus_Import **err, moq_status *status); -bool moq_mux_codec_opus_Import_cut(moq_mux_codec_opus_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_opus_Import_discontinuity(moq_mux_codec_opus_Import *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_opus_Import_seek(moq_mux_codec_opus_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_opus_Import_decode(moq_mux_codec_opus_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_opus_Import_abort_unwanted(moq_mux_codec_opus_Import *self, moq_Error *err_, moq_mux_codec_opus_Import **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_opus_Import_cut(moq_mux_codec_opus_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_opus_Import_discontinuity(moq_mux_codec_opus_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_opus_Import_seek(moq_mux_codec_opus_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_opus_Import_decode(moq_mux_codec_opus_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); void moq_mux_codec_vp8_Import_free(moq_mux_codec_vp8_Import *self); void moq_mux_codec_vp8_Import_drop(moq_mux_codec_vp8_Import *self, moq_status *status); -bool moq_mux_codec_vp8_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp8_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp8_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp8_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp8_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp8_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp8_Import_initialize(moq_mux_codec_vp8_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp8_Import_decode(moq_mux_codec_vp8_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); -moq_track_Demand *moq_mux_codec_vp8_Import_demand(const moq_mux_codec_vp8_Import *self, moq_status *status); -bool moq_mux_codec_vp8_Import_finish(moq_mux_codec_vp8_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp8_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp8_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp8_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp8_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp8_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp8_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp8_Import_initialize(moq_mux_codec_vp8_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp8_Import_decode(moq_mux_codec_vp8_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_codec_vp8_Import_demand(const moq_mux_codec_vp8_Import *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp8_Import_finish(moq_mux_codec_vp8_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_vp8_Import_abort(moq_mux_codec_vp8_Import *self, moq_Error *err_, moq_status *status); -bool moq_mux_codec_vp8_Import_abort_unwanted(moq_mux_codec_vp8_Import *self, moq_Error *err_, moq_mux_codec_vp8_Import **err, moq_status *status); -bool moq_mux_codec_vp8_Import_cut(moq_mux_codec_vp8_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp8_Import_discontinuity(moq_mux_codec_vp8_Import *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp8_Import_set_enabled(moq_mux_codec_vp8_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp8_Import_seek(moq_mux_codec_vp8_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp8_Import_abort_unwanted(moq_mux_codec_vp8_Import *self, moq_Error *err_, moq_mux_codec_vp8_Import **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp8_Import_cut(moq_mux_codec_vp8_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp8_Import_discontinuity(moq_mux_codec_vp8_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp8_Import_set_enabled(moq_mux_codec_vp8_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp8_Import_seek(moq_mux_codec_vp8_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); void moq_mux_codec_vp9_Import_free(moq_mux_codec_vp9_Import *self); void moq_mux_codec_vp9_Import_drop(moq_mux_codec_vp9_Import *self, moq_status *status); -bool moq_mux_codec_vp9_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp9_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp9_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp9_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp9_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp9_Import **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp9_Import_initialize(moq_mux_codec_vp9_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp9_Import_decode(moq_mux_codec_vp9_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); -moq_track_Demand *moq_mux_codec_vp9_Import_demand(const moq_mux_codec_vp9_Import *self, moq_status *status); -bool moq_mux_codec_vp9_Import_finish(moq_mux_codec_vp9_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp9_Import_new_Extra(moq_track_Producer *track, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp9_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp9_Import_new_Ext(moq_track_Producer *track, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp9_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp9_Import_new_unit(moq_track_Producer *track, moq_mux_catalog_Reserved *reserved, moq_mux_catalog_VideoHint *hint, moq_mux_codec_vp9_Import **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp9_Import_initialize(moq_mux_codec_vp9_Import *self, moq_buf buf, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp9_Import_decode(moq_mux_codec_vp9_Import *self, moq_buf frame, moq_option_Timestamp pts, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_track_Demand *moq_mux_codec_vp9_Import_demand(const moq_mux_codec_vp9_Import *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp9_Import_finish(moq_mux_codec_vp9_Import *self, moq_mux_container_Finished_Container_VideoConfig **out, moq_mux_Error **err, moq_status *status); void moq_mux_codec_vp9_Import_abort(moq_mux_codec_vp9_Import *self, moq_Error *err_, moq_status *status); -bool moq_mux_codec_vp9_Import_abort_unwanted(moq_mux_codec_vp9_Import *self, moq_Error *err_, moq_mux_codec_vp9_Import **err, moq_status *status); -bool moq_mux_codec_vp9_Import_cut(moq_mux_codec_vp9_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp9_Import_discontinuity(moq_mux_codec_vp9_Import *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp9_Import_set_enabled(moq_mux_codec_vp9_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); -bool moq_mux_codec_vp9_Import_seek(moq_mux_codec_vp9_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp9_Import_abort_unwanted(moq_mux_codec_vp9_Import *self, moq_Error *err_, moq_mux_codec_vp9_Import **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp9_Import_cut(moq_mux_codec_vp9_Import *self, moq_option_Timestamp end, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp9_Import_discontinuity(moq_mux_codec_vp9_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp9_Import_set_enabled(moq_mux_codec_vp9_Import *self, bool enabled, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_vp9_Import_seek(moq_mux_codec_vp9_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); void moq_mux_container_flv_Import_free(moq_mux_container_flv_Import *self); void moq_mux_container_flv_Import_drop(moq_mux_container_flv_Import *self, moq_status *status); -moq_mux_container_flv_Import *moq_mux_container_flv_Import_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, moq_status *status); -moq_mux_container_flv_Import *moq_mux_container_flv_Import_with_container(moq_mux_container_flv_Import *self, moq_hang_catalog_Container *container, moq_status *status); -bool moq_mux_container_flv_Import_decode(moq_mux_container_flv_Import *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_flv_Import_seek(moq_mux_container_flv_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_flv_Import_finish(moq_mux_container_flv_Import *self, moq_mux_container_flv_Finished **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_flv_Import *moq_mux_container_flv_Import_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, moq_status *status); +MOQ_MUST_USE moq_mux_container_flv_Import *moq_mux_container_flv_Import_with_container(moq_mux_container_flv_Import *self, moq_hang_catalog_Container *container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_flv_Import_decode(moq_mux_container_flv_Import *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_flv_Import_seek(moq_mux_container_flv_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_flv_Import_finish(moq_mux_container_flv_Import *self, moq_mux_container_flv_Finished **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_flv_Import_abort(moq_mux_container_flv_Import *self, moq_Error *err_, moq_status *status); void moq_mux_container_flv_Import_Extra_free(moq_mux_container_flv_Import_Extra *self); void moq_mux_container_flv_Import_Extra_drop(moq_mux_container_flv_Import_Extra *self, moq_status *status); -moq_mux_container_flv_Import_Extra *moq_mux_container_flv_Import_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, moq_status *status); -moq_mux_container_flv_Import_Extra *moq_mux_container_flv_Import_Extra_with_container(moq_mux_container_flv_Import_Extra *self, moq_hang_catalog_Container *container, moq_status *status); -bool moq_mux_container_flv_Import_Extra_decode(moq_mux_container_flv_Import_Extra *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_flv_Import_Extra_seek(moq_mux_container_flv_Import_Extra *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_flv_Import_Extra_finish(moq_mux_container_flv_Import_Extra *self, moq_mux_container_flv_Finished_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_flv_Import_Extra *moq_mux_container_flv_Import_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, moq_status *status); +MOQ_MUST_USE moq_mux_container_flv_Import_Extra *moq_mux_container_flv_Import_Extra_with_container(moq_mux_container_flv_Import_Extra *self, moq_hang_catalog_Container *container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_flv_Import_Extra_decode(moq_mux_container_flv_Import_Extra *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_flv_Import_Extra_seek(moq_mux_container_flv_Import_Extra *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_flv_Import_Extra_finish(moq_mux_container_flv_Import_Extra *self, moq_mux_container_flv_Finished_Extra **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_flv_Import_Extra_abort(moq_mux_container_flv_Import_Extra *self, moq_Error *err_, moq_status *status); void moq_mux_container_flv_Import_Ext_free(moq_mux_container_flv_Import_Ext *self); void moq_mux_container_flv_Import_Ext_drop(moq_mux_container_flv_Import_Ext *self, moq_status *status); -moq_mux_container_flv_Import_Ext *moq_mux_container_flv_Import_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, moq_status *status); -moq_mux_container_flv_Import_Ext *moq_mux_container_flv_Import_Ext_with_container(moq_mux_container_flv_Import_Ext *self, moq_hang_catalog_Container *container, moq_status *status); -bool moq_mux_container_flv_Import_Ext_decode(moq_mux_container_flv_Import_Ext *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_flv_Import_Ext_seek(moq_mux_container_flv_Import_Ext *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_flv_Import_Ext_finish(moq_mux_container_flv_Import_Ext *self, moq_mux_container_flv_Finished_Ext **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_flv_Import_Ext *moq_mux_container_flv_Import_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, moq_status *status); +MOQ_MUST_USE moq_mux_container_flv_Import_Ext *moq_mux_container_flv_Import_Ext_with_container(moq_mux_container_flv_Import_Ext *self, moq_hang_catalog_Container *container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_flv_Import_Ext_decode(moq_mux_container_flv_Import_Ext *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_flv_Import_Ext_seek(moq_mux_container_flv_Import_Ext *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_flv_Import_Ext_finish(moq_mux_container_flv_Import_Ext *self, moq_mux_container_flv_Finished_Ext **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_flv_Import_Ext_abort(moq_mux_container_flv_Import_Ext *self, moq_Error *err_, moq_status *status); void moq_mux_container_flv_Finished_free(moq_mux_container_flv_Finished *self); void moq_mux_container_flv_Finished_drop(moq_mux_container_flv_Finished *self, moq_status *status); @@ -8268,48 +8278,48 @@ void moq_mux_container_flv_Finished_Ext_drop(moq_mux_container_flv_Finished_Ext void moq_mux_container_flv_Finished_Ext_abort(moq_mux_container_flv_Finished_Ext *self, moq_Error *err_, moq_status *status); void moq_mux_container_fmp4_Wire_free(moq_mux_container_fmp4_Wire *self); void moq_mux_container_fmp4_Wire_drop(moq_mux_container_fmp4_Wire *self, moq_status *status); -bool moq_mux_container_fmp4_Wire_from_init(moq_buf init_data, moq_mux_container_fmp4_Wire **out, moq_mux_container_fmp4_Error **err); +MOQ_MUST_USE bool moq_mux_container_fmp4_Wire_from_init(moq_buf init_data, moq_mux_container_fmp4_Wire **out, moq_mux_container_fmp4_Error **err); void moq_mux_container_fmp4_Error_free(moq_mux_container_fmp4_Error *self); bool moq_mux_container_fmp4_Error_borrowed(const moq_mux_container_fmp4_Error *self); -moq_mux_container_fmp4_Error *moq_mux_container_fmp4_Error_clone(const moq_mux_container_fmp4_Error *self); -moq_buf moq_mux_container_fmp4_Error_to_string(const moq_mux_container_fmp4_Error *self); -moq_buf moq_mux_container_fmp4_Error_debug(const moq_mux_container_fmp4_Error *self); +MOQ_MUST_USE moq_mux_container_fmp4_Error *moq_mux_container_fmp4_Error_clone(const moq_mux_container_fmp4_Error *self); +MOQ_MUST_USE moq_buf moq_mux_container_fmp4_Error_to_string(const moq_mux_container_fmp4_Error *self); +MOQ_MUST_USE moq_buf moq_mux_container_fmp4_Error_debug(const moq_mux_container_fmp4_Error *self); void moq_mux_container_fmp4_Import_free(moq_mux_container_fmp4_Import *self); void moq_mux_container_fmp4_Import_drop(moq_mux_container_fmp4_Import *self, moq_status *status); -moq_mux_container_fmp4_Import *moq_mux_container_fmp4_Import_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, moq_status *status); -bool moq_mux_container_fmp4_Import_cut(moq_mux_container_fmp4_Import *self, moq_mux_Error **err, moq_status *status); -moq_mux_container_fmp4_Import *moq_mux_container_fmp4_Import_with_select(moq_mux_container_fmp4_Import *self, moq_mux_select_Broadcast *select, moq_status *status); -moq_mux_container_fmp4_Import *moq_mux_container_fmp4_Import_with_cmaf(moq_mux_container_fmp4_Import *self, bool cmaf, moq_status *status); -bool moq_mux_container_fmp4_Import_decode(moq_mux_container_fmp4_Import *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Import_finish(moq_mux_container_fmp4_Import *self, moq_mux_container_fmp4_Finished **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_fmp4_Import *moq_mux_container_fmp4_Import_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_cut(moq_mux_container_fmp4_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_fmp4_Import *moq_mux_container_fmp4_Import_with_select(moq_mux_container_fmp4_Import *self, moq_mux_select_Broadcast *select, moq_status *status); +MOQ_MUST_USE moq_mux_container_fmp4_Import *moq_mux_container_fmp4_Import_with_cmaf(moq_mux_container_fmp4_Import *self, bool cmaf, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_decode(moq_mux_container_fmp4_Import *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_finish(moq_mux_container_fmp4_Import *self, moq_mux_container_fmp4_Finished **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_fmp4_Import_abort(moq_mux_container_fmp4_Import *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_fmp4_Import_seek(moq_mux_container_fmp4_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Import_rejoin(moq_mux_container_fmp4_Import *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Import_discontinuity(moq_mux_container_fmp4_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_seek(moq_mux_container_fmp4_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_rejoin(moq_mux_container_fmp4_Import *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_discontinuity(moq_mux_container_fmp4_Import *self, moq_mux_Error **err, moq_status *status); void moq_mux_container_fmp4_Import_Extra_free(moq_mux_container_fmp4_Import_Extra *self); void moq_mux_container_fmp4_Import_Extra_drop(moq_mux_container_fmp4_Import_Extra *self, moq_status *status); -moq_mux_container_fmp4_Import_Extra *moq_mux_container_fmp4_Import_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, moq_status *status); -bool moq_mux_container_fmp4_Import_Extra_cut(moq_mux_container_fmp4_Import_Extra *self, moq_mux_Error **err, moq_status *status); -moq_mux_container_fmp4_Import_Extra *moq_mux_container_fmp4_Import_Extra_with_select(moq_mux_container_fmp4_Import_Extra *self, moq_mux_select_Broadcast *select, moq_status *status); -moq_mux_container_fmp4_Import_Extra *moq_mux_container_fmp4_Import_Extra_with_cmaf(moq_mux_container_fmp4_Import_Extra *self, bool cmaf, moq_status *status); -bool moq_mux_container_fmp4_Import_Extra_decode(moq_mux_container_fmp4_Import_Extra *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Import_Extra_finish(moq_mux_container_fmp4_Import_Extra *self, moq_mux_container_fmp4_Finished_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_fmp4_Import_Extra *moq_mux_container_fmp4_Import_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Extra_cut(moq_mux_container_fmp4_Import_Extra *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_fmp4_Import_Extra *moq_mux_container_fmp4_Import_Extra_with_select(moq_mux_container_fmp4_Import_Extra *self, moq_mux_select_Broadcast *select, moq_status *status); +MOQ_MUST_USE moq_mux_container_fmp4_Import_Extra *moq_mux_container_fmp4_Import_Extra_with_cmaf(moq_mux_container_fmp4_Import_Extra *self, bool cmaf, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Extra_decode(moq_mux_container_fmp4_Import_Extra *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Extra_finish(moq_mux_container_fmp4_Import_Extra *self, moq_mux_container_fmp4_Finished_Extra **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_fmp4_Import_Extra_abort(moq_mux_container_fmp4_Import_Extra *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_fmp4_Import_Extra_seek(moq_mux_container_fmp4_Import_Extra *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Import_Extra_rejoin(moq_mux_container_fmp4_Import_Extra *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Import_Extra_discontinuity(moq_mux_container_fmp4_Import_Extra *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Extra_seek(moq_mux_container_fmp4_Import_Extra *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Extra_rejoin(moq_mux_container_fmp4_Import_Extra *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Extra_discontinuity(moq_mux_container_fmp4_Import_Extra *self, moq_mux_Error **err, moq_status *status); void moq_mux_container_fmp4_Import_Ext_free(moq_mux_container_fmp4_Import_Ext *self); void moq_mux_container_fmp4_Import_Ext_drop(moq_mux_container_fmp4_Import_Ext *self, moq_status *status); -moq_mux_container_fmp4_Import_Ext *moq_mux_container_fmp4_Import_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, moq_status *status); -bool moq_mux_container_fmp4_Import_Ext_cut(moq_mux_container_fmp4_Import_Ext *self, moq_mux_Error **err, moq_status *status); -moq_mux_container_fmp4_Import_Ext *moq_mux_container_fmp4_Import_Ext_with_select(moq_mux_container_fmp4_Import_Ext *self, moq_mux_select_Broadcast *select, moq_status *status); -moq_mux_container_fmp4_Import_Ext *moq_mux_container_fmp4_Import_Ext_with_cmaf(moq_mux_container_fmp4_Import_Ext *self, bool cmaf, moq_status *status); -bool moq_mux_container_fmp4_Import_Ext_decode(moq_mux_container_fmp4_Import_Ext *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Import_Ext_finish(moq_mux_container_fmp4_Import_Ext *self, moq_mux_container_fmp4_Finished_Ext **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_fmp4_Import_Ext *moq_mux_container_fmp4_Import_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Ext_cut(moq_mux_container_fmp4_Import_Ext *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_fmp4_Import_Ext *moq_mux_container_fmp4_Import_Ext_with_select(moq_mux_container_fmp4_Import_Ext *self, moq_mux_select_Broadcast *select, moq_status *status); +MOQ_MUST_USE moq_mux_container_fmp4_Import_Ext *moq_mux_container_fmp4_Import_Ext_with_cmaf(moq_mux_container_fmp4_Import_Ext *self, bool cmaf, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Ext_decode(moq_mux_container_fmp4_Import_Ext *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Ext_finish(moq_mux_container_fmp4_Import_Ext *self, moq_mux_container_fmp4_Finished_Ext **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_fmp4_Import_Ext_abort(moq_mux_container_fmp4_Import_Ext *self, moq_Error *err_, moq_status *status); -bool moq_mux_container_fmp4_Import_Ext_seek(moq_mux_container_fmp4_Import_Ext *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Import_Ext_rejoin(moq_mux_container_fmp4_Import_Ext *self, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Import_Ext_discontinuity(moq_mux_container_fmp4_Import_Ext *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Ext_seek(moq_mux_container_fmp4_Import_Ext *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Ext_rejoin(moq_mux_container_fmp4_Import_Ext *self, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Import_Ext_discontinuity(moq_mux_container_fmp4_Import_Ext *self, moq_mux_Error **err, moq_status *status); void moq_mux_container_fmp4_Finished_free(moq_mux_container_fmp4_Finished *self); void moq_mux_container_fmp4_Finished_drop(moq_mux_container_fmp4_Finished *self, moq_status *status); void moq_mux_container_fmp4_Finished_abort(moq_mux_container_fmp4_Finished *self, moq_Error *err_, moq_status *status); @@ -8321,48 +8331,48 @@ void moq_mux_container_fmp4_Finished_Ext_drop(moq_mux_container_fmp4_Finished_Ex void moq_mux_container_fmp4_Finished_Ext_abort(moq_mux_container_fmp4_Finished_Ext *self, moq_Error *err_, moq_status *status); void moq_mux_container_fmp4_Muxer_free(moq_mux_container_fmp4_Muxer *self); void moq_mux_container_fmp4_Muxer_drop(moq_mux_container_fmp4_Muxer *self, moq_status *status); -bool moq_mux_container_fmp4_Muxer_video(const moq_hang_catalog_VideoConfig *config, moq_mux_container_fmp4_Muxer **out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Muxer_audio(const moq_hang_catalog_AudioConfig *config, moq_mux_container_fmp4_Muxer **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Muxer_video(const moq_hang_catalog_VideoConfig *config, moq_mux_container_fmp4_Muxer **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Muxer_audio(const moq_hang_catalog_AudioConfig *config, moq_mux_container_fmp4_Muxer **out, moq_mux_Error **err, moq_status *status); moq_Timescale moq_mux_container_fmp4_Muxer_timescale(const moq_mux_container_fmp4_Muxer *self, moq_status *status); -bool moq_mux_container_fmp4_Muxer_with_timescale(moq_mux_container_fmp4_Muxer *self, moq_Timescale timescale, moq_mux_container_fmp4_Muxer **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Muxer_with_timescale(moq_mux_container_fmp4_Muxer *self, moq_Timescale timescale, moq_mux_container_fmp4_Muxer **out, moq_mux_Error **err, moq_status *status); typedef struct moq_mux_container_fmp4_Muxer_read_future moq_mux_container_fmp4_Muxer_read_future; -moq_mux_container_fmp4_Muxer_read_future *moq_mux_container_fmp4_Muxer_read(moq_mux_container_fmp4_Muxer *self, moq_group_Consumer *group, moq_status *status); -moq_poll moq_mux_container_fmp4_Muxer_read_start(moq_mux_container_fmp4_Muxer *self, moq_group_Consumer *group, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_fmp4_Muxer_read_future **future, moq_status *status); -moq_poll moq_mux_container_fmp4_Muxer_read_poll(moq_mux_container_fmp4_Muxer_read_future *future, moq_waker waker, moq_vec_mux_container_Frame *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_fmp4_Muxer_read_future *moq_mux_container_fmp4_Muxer_read(moq_mux_container_fmp4_Muxer *self, moq_group_Consumer *group, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_fmp4_Muxer_read_start(moq_mux_container_fmp4_Muxer *self, moq_group_Consumer *group, moq_vec_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_fmp4_Muxer_read_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_fmp4_Muxer_read_poll(moq_mux_container_fmp4_Muxer_read_future *future, moq_waker waker, moq_vec_mux_container_Frame *out, moq_mux_Error **err); void moq_mux_container_fmp4_Muxer_read_future_free(moq_mux_container_fmp4_Muxer_read_future *future); -bool moq_mux_container_fmp4_Muxer_picture_size(moq_mux_container_fmp4_Muxer *self, moq_mux_container_Frame keyframe, moq_option_tuple_u32_u32 *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Muxer_init(const moq_mux_container_fmp4_Muxer *self, moq_buf *out, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_fmp4_Muxer_fragment(const moq_mux_container_fmp4_Muxer *self, uint32_t sequence, moq_vec_mux_container_Frame frames, moq_option_Timestamp end, moq_buf *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Muxer_picture_size(moq_mux_container_fmp4_Muxer *self, moq_mux_container_Frame keyframe, moq_option_tuple_u32_u32 *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Muxer_init(const moq_mux_container_fmp4_Muxer *self, moq_buf *out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_fmp4_Muxer_fragment(const moq_mux_container_fmp4_Muxer *self, uint32_t sequence, moq_vec_mux_container_Frame frames, moq_option_Timestamp end, moq_buf *out, moq_mux_Error **err, moq_status *status); void moq_mux_container_legacy_Audio_free(moq_mux_container_legacy_Audio *self); bool moq_mux_container_legacy_Audio_borrowed(const moq_mux_container_legacy_Audio *self); -moq_mux_container_legacy_Audio *moq_mux_container_legacy_Audio_clone(const moq_mux_container_legacy_Audio *self); +MOQ_MUST_USE moq_mux_container_legacy_Audio *moq_mux_container_legacy_Audio_clone(const moq_mux_container_legacy_Audio *self); bool moq_mux_container_legacy_Audio_eq(const moq_mux_container_legacy_Audio *a, const moq_mux_container_legacy_Audio *b); -moq_buf moq_mux_container_legacy_Audio_debug(const moq_mux_container_legacy_Audio *self); -moq_mux_container_legacy_Audio *moq_mux_container_legacy_Audio_new(const moq_hang_catalog_AudioConfig *config, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_legacy_Audio_debug(const moq_mux_container_legacy_Audio *self); +MOQ_MUST_USE moq_mux_container_legacy_Audio *moq_mux_container_legacy_Audio_new(const moq_hang_catalog_AudioConfig *config, moq_status *status); moq_option_Timestamp moq_mux_container_legacy_Audio_duration(const moq_mux_container_legacy_Audio *self, moq_buf payload); void moq_mux_container_mkv_Import_free(moq_mux_container_mkv_Import *self); void moq_mux_container_mkv_Import_drop(moq_mux_container_mkv_Import *self, moq_status *status); -moq_mux_container_mkv_Import *moq_mux_container_mkv_Import_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, moq_status *status); -moq_mux_container_mkv_Import *moq_mux_container_mkv_Import_with_container(moq_mux_container_mkv_Import *self, moq_hang_catalog_Container *container, moq_status *status); -bool moq_mux_container_mkv_Import_decode(moq_mux_container_mkv_Import *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_mkv_Import_seek(moq_mux_container_mkv_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_mkv_Import_finish(moq_mux_container_mkv_Import *self, moq_mux_container_mkv_Finished **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_mkv_Import *moq_mux_container_mkv_Import_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, moq_status *status); +MOQ_MUST_USE moq_mux_container_mkv_Import *moq_mux_container_mkv_Import_with_container(moq_mux_container_mkv_Import *self, moq_hang_catalog_Container *container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_mkv_Import_decode(moq_mux_container_mkv_Import *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_mkv_Import_seek(moq_mux_container_mkv_Import *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_mkv_Import_finish(moq_mux_container_mkv_Import *self, moq_mux_container_mkv_Finished **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_mkv_Import_abort(moq_mux_container_mkv_Import *self, moq_Error *err_, moq_status *status); void moq_mux_container_mkv_Import_Extra_free(moq_mux_container_mkv_Import_Extra *self); void moq_mux_container_mkv_Import_Extra_drop(moq_mux_container_mkv_Import_Extra *self, moq_status *status); -moq_mux_container_mkv_Import_Extra *moq_mux_container_mkv_Import_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, moq_status *status); -moq_mux_container_mkv_Import_Extra *moq_mux_container_mkv_Import_Extra_with_container(moq_mux_container_mkv_Import_Extra *self, moq_hang_catalog_Container *container, moq_status *status); -bool moq_mux_container_mkv_Import_Extra_decode(moq_mux_container_mkv_Import_Extra *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_mkv_Import_Extra_seek(moq_mux_container_mkv_Import_Extra *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_mkv_Import_Extra_finish(moq_mux_container_mkv_Import_Extra *self, moq_mux_container_mkv_Finished_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_mkv_Import_Extra *moq_mux_container_mkv_Import_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, moq_status *status); +MOQ_MUST_USE moq_mux_container_mkv_Import_Extra *moq_mux_container_mkv_Import_Extra_with_container(moq_mux_container_mkv_Import_Extra *self, moq_hang_catalog_Container *container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_mkv_Import_Extra_decode(moq_mux_container_mkv_Import_Extra *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_mkv_Import_Extra_seek(moq_mux_container_mkv_Import_Extra *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_mkv_Import_Extra_finish(moq_mux_container_mkv_Import_Extra *self, moq_mux_container_mkv_Finished_Extra **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_mkv_Import_Extra_abort(moq_mux_container_mkv_Import_Extra *self, moq_Error *err_, moq_status *status); void moq_mux_container_mkv_Import_Ext_free(moq_mux_container_mkv_Import_Ext *self); void moq_mux_container_mkv_Import_Ext_drop(moq_mux_container_mkv_Import_Ext *self, moq_status *status); -moq_mux_container_mkv_Import_Ext *moq_mux_container_mkv_Import_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, moq_status *status); -moq_mux_container_mkv_Import_Ext *moq_mux_container_mkv_Import_Ext_with_container(moq_mux_container_mkv_Import_Ext *self, moq_hang_catalog_Container *container, moq_status *status); -bool moq_mux_container_mkv_Import_Ext_decode(moq_mux_container_mkv_Import_Ext *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_mkv_Import_Ext_seek(moq_mux_container_mkv_Import_Ext *self, uint64_t start, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_mkv_Import_Ext_finish(moq_mux_container_mkv_Import_Ext *self, moq_mux_container_mkv_Finished_Ext **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_mkv_Import_Ext *moq_mux_container_mkv_Import_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, moq_status *status); +MOQ_MUST_USE moq_mux_container_mkv_Import_Ext *moq_mux_container_mkv_Import_Ext_with_container(moq_mux_container_mkv_Import_Ext *self, moq_hang_catalog_Container *container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_mkv_Import_Ext_decode(moq_mux_container_mkv_Import_Ext *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_mkv_Import_Ext_seek(moq_mux_container_mkv_Import_Ext *self, uint64_t start, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_mkv_Import_Ext_finish(moq_mux_container_mkv_Import_Ext *self, moq_mux_container_mkv_Finished_Ext **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_mkv_Import_Ext_abort(moq_mux_container_mkv_Import_Ext *self, moq_Error *err_, moq_status *status); void moq_mux_container_mkv_Finished_free(moq_mux_container_mkv_Finished *self); void moq_mux_container_mkv_Finished_drop(moq_mux_container_mkv_Finished *self, moq_status *status); @@ -8375,61 +8385,61 @@ void moq_mux_container_mkv_Finished_Ext_drop(moq_mux_container_mkv_Finished_Ext void moq_mux_container_mkv_Finished_Ext_abort(moq_mux_container_mkv_Finished_Ext *self, moq_Error *err_, moq_status *status); void moq_mux_container_mp4_Finish_free(moq_mux_container_mp4_Finish *self); bool moq_mux_container_mp4_Finish_borrowed(const moq_mux_container_mp4_Finish *self); -moq_mux_container_mp4_Finish *moq_mux_container_mp4_Finish_clone(const moq_mux_container_mp4_Finish *self); -moq_buf moq_mux_container_mp4_Finish_debug(const moq_mux_container_mp4_Finish *self); +MOQ_MUST_USE moq_mux_container_mp4_Finish *moq_mux_container_mp4_Finish_clone(const moq_mux_container_mp4_Finish *self); +MOQ_MUST_USE moq_buf moq_mux_container_mp4_Finish_debug(const moq_mux_container_mp4_Finish *self); void moq_mux_container_ts_Ext_free(moq_mux_container_ts_Ext *self); void moq_mux_container_ts_Ext_drop(moq_mux_container_ts_Ext *self, moq_status *status); -moq_mux_container_ts_Ext *moq_mux_container_ts_Ext_clone(const moq_mux_container_ts_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Ext *moq_mux_container_ts_Ext_clone(const moq_mux_container_ts_Ext *self, moq_status *status); bool moq_mux_container_ts_Ext_eq(const moq_mux_container_ts_Ext *a, const moq_mux_container_ts_Ext *b, moq_status *status); -moq_buf moq_mux_container_ts_Ext_debug(const moq_mux_container_ts_Ext *self, moq_status *status); -moq_mux_container_ts_Ext *moq_mux_container_ts_Ext_default(void); -moq_mux_container_ts_Mpegts *moq_mux_container_ts_Ext_mpegts_get(const moq_mux_container_ts_Ext *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Ext_debug(const moq_mux_container_ts_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Ext *moq_mux_container_ts_Ext_default(void); +MOQ_MUST_USE moq_mux_container_ts_Mpegts *moq_mux_container_ts_Ext_mpegts_get(const moq_mux_container_ts_Ext *self, moq_status *status); void moq_mux_container_ts_Ext_mpegts_set(moq_mux_container_ts_Ext *self, moq_mux_container_ts_Mpegts *value, moq_status *status); void moq_mux_container_ts_Mpegts_free(moq_mux_container_ts_Mpegts *self); void moq_mux_container_ts_Mpegts_drop(moq_mux_container_ts_Mpegts *self, moq_status *status); -moq_mux_container_ts_Mpegts *moq_mux_container_ts_Mpegts_clone(const moq_mux_container_ts_Mpegts *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Mpegts *moq_mux_container_ts_Mpegts_clone(const moq_mux_container_ts_Mpegts *self, moq_status *status); bool moq_mux_container_ts_Mpegts_eq(const moq_mux_container_ts_Mpegts *a, const moq_mux_container_ts_Mpegts *b, moq_status *status); -moq_buf moq_mux_container_ts_Mpegts_debug(const moq_mux_container_ts_Mpegts *self, moq_status *status); -moq_mux_container_ts_Mpegts *moq_mux_container_ts_Mpegts_default(void); -moq_vec_tuple_string_mux_container_ts_Track moq_mux_container_ts_Mpegts_tracks_get(const moq_mux_container_ts_Mpegts *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Mpegts_debug(const moq_mux_container_ts_Mpegts *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Mpegts *moq_mux_container_ts_Mpegts_default(void); +MOQ_MUST_USE moq_vec_tuple_string_mux_container_ts_Track moq_mux_container_ts_Mpegts_tracks_get(const moq_mux_container_ts_Mpegts *self, moq_status *status); void moq_mux_container_ts_Mpegts_tracks_set(moq_mux_container_ts_Mpegts *self, moq_vec_tuple_string_mux_container_ts_Track value, moq_status *status); -moq_vec_mux_container_ts_Descriptor moq_mux_container_ts_Mpegts_program_descriptors_get(const moq_mux_container_ts_Mpegts *self, moq_status *status); +MOQ_MUST_USE moq_vec_mux_container_ts_Descriptor moq_mux_container_ts_Mpegts_program_descriptors_get(const moq_mux_container_ts_Mpegts *self, moq_status *status); void moq_mux_container_ts_Mpegts_program_descriptors_set(moq_mux_container_ts_Mpegts *self, moq_vec_mux_container_ts_Descriptor value, moq_status *status); -moq_mux_container_ts_Program *moq_mux_container_ts_Mpegts_program_get(const moq_mux_container_ts_Mpegts *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Program *moq_mux_container_ts_Mpegts_program_get(const moq_mux_container_ts_Mpegts *self, moq_status *status); void moq_mux_container_ts_Mpegts_program_set(moq_mux_container_ts_Mpegts *self, moq_mux_container_ts_Program *value, moq_status *status); -moq_vec_tuple_u16_vec_tuple_u8_mux_container_ts_SiEntry moq_mux_container_ts_Mpegts_si_get(const moq_mux_container_ts_Mpegts *self, moq_status *status); +MOQ_MUST_USE moq_vec_tuple_u16_vec_tuple_u8_mux_container_ts_SiEntry moq_mux_container_ts_Mpegts_si_get(const moq_mux_container_ts_Mpegts *self, moq_status *status); void moq_mux_container_ts_Mpegts_si_set(moq_mux_container_ts_Mpegts *self, moq_vec_tuple_u16_vec_tuple_u8_mux_container_ts_SiEntry value, moq_status *status); moq_option_u64 moq_mux_container_ts_Mpegts_mux_rate_get(const moq_mux_container_ts_Mpegts *self, moq_status *status); void moq_mux_container_ts_Mpegts_mux_rate_set(moq_mux_container_ts_Mpegts *self, moq_option_u64 value, moq_status *status); -moq_mux_container_ts_PassthroughTrack *moq_mux_container_ts_Mpegts_passthrough_get(const moq_mux_container_ts_Mpegts *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_PassthroughTrack *moq_mux_container_ts_Mpegts_passthrough_get(const moq_mux_container_ts_Mpegts *self, moq_status *status); void moq_mux_container_ts_Mpegts_passthrough_set(moq_mux_container_ts_Mpegts *self, moq_mux_container_ts_PassthroughTrack *value, moq_status *status); -bool moq_mux_container_ts_Mpegts_deserialize(moq_Json *__deserializer, moq_mux_container_ts_Mpegts **out, moq_buf *err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Mpegts_deserialize(moq_Json *__deserializer, moq_mux_container_ts_Mpegts **out, moq_buf *err, moq_status *status); bool moq_mux_container_ts_Mpegts_is_empty(const moq_mux_container_ts_Mpegts *self, moq_status *status); void moq_mux_container_ts_PassthroughTrack_free(moq_mux_container_ts_PassthroughTrack *self); void moq_mux_container_ts_PassthroughTrack_drop(moq_mux_container_ts_PassthroughTrack *self, moq_status *status); -moq_mux_container_ts_PassthroughTrack *moq_mux_container_ts_PassthroughTrack_clone(const moq_mux_container_ts_PassthroughTrack *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_PassthroughTrack *moq_mux_container_ts_PassthroughTrack_clone(const moq_mux_container_ts_PassthroughTrack *self, moq_status *status); bool moq_mux_container_ts_PassthroughTrack_eq(const moq_mux_container_ts_PassthroughTrack *a, const moq_mux_container_ts_PassthroughTrack *b, moq_status *status); -moq_buf moq_mux_container_ts_PassthroughTrack_debug(const moq_mux_container_ts_PassthroughTrack *self, moq_status *status); -moq_buf moq_mux_container_ts_PassthroughTrack_track_get(const moq_mux_container_ts_PassthroughTrack *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_PassthroughTrack_debug(const moq_mux_container_ts_PassthroughTrack *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_PassthroughTrack_track_get(const moq_mux_container_ts_PassthroughTrack *self, moq_status *status); void moq_mux_container_ts_PassthroughTrack_track_set(moq_mux_container_ts_PassthroughTrack *self, moq_buf value, moq_status *status); bool moq_mux_container_ts_PassthroughTrack_random_access_get(const moq_mux_container_ts_PassthroughTrack *self, moq_status *status); void moq_mux_container_ts_PassthroughTrack_random_access_set(moq_mux_container_ts_PassthroughTrack *self, bool value, moq_status *status); -moq_mux_container_ts_PassthroughTrack *moq_mux_container_ts_PassthroughTrack_new(moq_buf track); +MOQ_MUST_USE moq_mux_container_ts_PassthroughTrack *moq_mux_container_ts_PassthroughTrack_new(moq_buf track); void moq_mux_container_ts_PesPacket_free(moq_mux_container_ts_PesPacket *self); void moq_mux_container_ts_PesPacket_drop(moq_mux_container_ts_PesPacket *self, moq_status *status); -moq_mux_container_ts_PesPacket *moq_mux_container_ts_PesPacket_clone(const moq_mux_container_ts_PesPacket *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_PesPacket *moq_mux_container_ts_PesPacket_clone(const moq_mux_container_ts_PesPacket *self, moq_status *status); bool moq_mux_container_ts_PesPacket_eq(const moq_mux_container_ts_PesPacket *a, const moq_mux_container_ts_PesPacket *b, moq_status *status); -moq_buf moq_mux_container_ts_PesPacket_debug(const moq_mux_container_ts_PesPacket *self, moq_status *status); -moq_mux_container_ts_PesPacket *moq_mux_container_ts_PesPacket_default(void); +MOQ_MUST_USE moq_buf moq_mux_container_ts_PesPacket_debug(const moq_mux_container_ts_PesPacket *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_PesPacket *moq_mux_container_ts_PesPacket_default(void); uint8_t moq_mux_container_ts_PesPacket_stream_type_get(const moq_mux_container_ts_PesPacket *self, moq_status *status); void moq_mux_container_ts_PesPacket_stream_type_set(moq_mux_container_ts_PesPacket *self, uint8_t value, moq_status *status); -moq_mux_container_ts_PesPacket *moq_mux_container_ts_PesPacket_new(uint8_t stream_type); +MOQ_MUST_USE moq_mux_container_ts_PesPacket *moq_mux_container_ts_PesPacket_new(uint8_t stream_type); void moq_mux_container_ts_Program_free(moq_mux_container_ts_Program *self); void moq_mux_container_ts_Program_drop(moq_mux_container_ts_Program *self, moq_status *status); -moq_mux_container_ts_Program *moq_mux_container_ts_Program_clone(const moq_mux_container_ts_Program *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Program *moq_mux_container_ts_Program_clone(const moq_mux_container_ts_Program *self, moq_status *status); bool moq_mux_container_ts_Program_eq(const moq_mux_container_ts_Program *a, const moq_mux_container_ts_Program *b, moq_status *status); -moq_buf moq_mux_container_ts_Program_debug(const moq_mux_container_ts_Program *self, moq_status *status); -moq_mux_container_ts_Program *moq_mux_container_ts_Program_default(void); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Program_debug(const moq_mux_container_ts_Program *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Program *moq_mux_container_ts_Program_default(void); uint16_t moq_mux_container_ts_Program_transport_stream_id_get(const moq_mux_container_ts_Program *self, moq_status *status); void moq_mux_container_ts_Program_transport_stream_id_set(moq_mux_container_ts_Program *self, uint16_t value, moq_status *status); uint16_t moq_mux_container_ts_Program_program_number_get(const moq_mux_container_ts_Program *self, moq_status *status); @@ -8438,221 +8448,221 @@ uint16_t moq_mux_container_ts_Program_pmt_pid_get(const moq_mux_container_ts_Pro void moq_mux_container_ts_Program_pmt_pid_set(moq_mux_container_ts_Program *self, uint16_t value, moq_status *status); void moq_mux_container_ts_SiEntry_free(moq_mux_container_ts_SiEntry *self); void moq_mux_container_ts_SiEntry_drop(moq_mux_container_ts_SiEntry *self, moq_status *status); -moq_mux_container_ts_SiEntry *moq_mux_container_ts_SiEntry_clone(const moq_mux_container_ts_SiEntry *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_SiEntry *moq_mux_container_ts_SiEntry_clone(const moq_mux_container_ts_SiEntry *self, moq_status *status); bool moq_mux_container_ts_SiEntry_eq(const moq_mux_container_ts_SiEntry *a, const moq_mux_container_ts_SiEntry *b, moq_status *status); -moq_buf moq_mux_container_ts_SiEntry_debug(const moq_mux_container_ts_SiEntry *self, moq_status *status); -moq_mux_container_ts_SiEntry *moq_mux_container_ts_SiEntry_default(void); -moq_buf moq_mux_container_ts_SiEntry_track_get(const moq_mux_container_ts_SiEntry *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_SiEntry_debug(const moq_mux_container_ts_SiEntry *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_SiEntry *moq_mux_container_ts_SiEntry_default(void); +MOQ_MUST_USE moq_buf moq_mux_container_ts_SiEntry_track_get(const moq_mux_container_ts_SiEntry *self, moq_status *status); void moq_mux_container_ts_SiEntry_track_set(moq_mux_container_ts_SiEntry *self, moq_buf value, moq_status *status); moq_option_duration moq_mux_container_ts_SiEntry_interval_get(const moq_mux_container_ts_SiEntry *self, moq_status *status); void moq_mux_container_ts_SiEntry_interval_set(moq_mux_container_ts_SiEntry *self, moq_option_duration value, moq_status *status); void moq_mux_container_ts_Track_free(moq_mux_container_ts_Track *self); void moq_mux_container_ts_Track_drop(moq_mux_container_ts_Track *self, moq_status *status); -moq_mux_container_ts_Track *moq_mux_container_ts_Track_clone(const moq_mux_container_ts_Track *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Track *moq_mux_container_ts_Track_clone(const moq_mux_container_ts_Track *self, moq_status *status); bool moq_mux_container_ts_Track_eq(const moq_mux_container_ts_Track *a, const moq_mux_container_ts_Track *b, moq_status *status); -moq_buf moq_mux_container_ts_Track_debug(const moq_mux_container_ts_Track *self, moq_status *status); -moq_mux_container_ts_Track *moq_mux_container_ts_Track_default(void); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Track_debug(const moq_mux_container_ts_Track *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Track *moq_mux_container_ts_Track_default(void); uint16_t moq_mux_container_ts_Track_pid_get(const moq_mux_container_ts_Track *self, moq_status *status); void moq_mux_container_ts_Track_pid_set(moq_mux_container_ts_Track *self, uint16_t value, moq_status *status); -moq_vec_mux_container_ts_Descriptor moq_mux_container_ts_Track_descriptors_get(const moq_mux_container_ts_Track *self, moq_status *status); +MOQ_MUST_USE moq_vec_mux_container_ts_Descriptor moq_mux_container_ts_Track_descriptors_get(const moq_mux_container_ts_Track *self, moq_status *status); void moq_mux_container_ts_Track_descriptors_set(moq_mux_container_ts_Track *self, moq_vec_mux_container_ts_Descriptor value, moq_status *status); -moq_mux_container_ts_Verbatim *moq_mux_container_ts_Track_verbatim_get(const moq_mux_container_ts_Track *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Verbatim *moq_mux_container_ts_Track_verbatim_get(const moq_mux_container_ts_Track *self, moq_status *status); void moq_mux_container_ts_Track_verbatim_set(moq_mux_container_ts_Track *self, moq_mux_container_ts_Verbatim *value, moq_status *status); -moq_mux_container_ts_PesPacket *moq_mux_container_ts_Track_pes_packet_get(const moq_mux_container_ts_Track *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_PesPacket *moq_mux_container_ts_Track_pes_packet_get(const moq_mux_container_ts_Track *self, moq_status *status); void moq_mux_container_ts_Track_pes_packet_set(moq_mux_container_ts_Track *self, moq_mux_container_ts_PesPacket *value, moq_status *status); -moq_mux_container_ts_Track *moq_mux_container_ts_Track_new(uint16_t pid); +MOQ_MUST_USE moq_mux_container_ts_Track *moq_mux_container_ts_Track_new(uint16_t pid); void moq_mux_container_ts_Verbatim_free(moq_mux_container_ts_Verbatim *self); void moq_mux_container_ts_Verbatim_drop(moq_mux_container_ts_Verbatim *self, moq_status *status); -moq_mux_container_ts_Verbatim *moq_mux_container_ts_Verbatim_clone(const moq_mux_container_ts_Verbatim *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Verbatim *moq_mux_container_ts_Verbatim_clone(const moq_mux_container_ts_Verbatim *self, moq_status *status); bool moq_mux_container_ts_Verbatim_eq(const moq_mux_container_ts_Verbatim *a, const moq_mux_container_ts_Verbatim *b, moq_status *status); -moq_buf moq_mux_container_ts_Verbatim_debug(const moq_mux_container_ts_Verbatim *self, moq_status *status); -moq_mux_container_ts_Verbatim *moq_mux_container_ts_Verbatim_default(void); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Verbatim_debug(const moq_mux_container_ts_Verbatim *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Verbatim *moq_mux_container_ts_Verbatim_default(void); uint8_t moq_mux_container_ts_Verbatim_stream_type_get(const moq_mux_container_ts_Verbatim *self, moq_status *status); void moq_mux_container_ts_Verbatim_stream_type_set(moq_mux_container_ts_Verbatim *self, uint8_t value, moq_status *status); moq_mux_container_ts_Framing moq_mux_container_ts_Verbatim_framing_get(const moq_mux_container_ts_Verbatim *self, moq_status *status); void moq_mux_container_ts_Verbatim_framing_set(moq_mux_container_ts_Verbatim *self, moq_mux_container_ts_Framing value, moq_status *status); -moq_mux_container_ts_Verbatim *moq_mux_container_ts_Verbatim_new(uint8_t stream_type, moq_mux_container_ts_Framing framing); +MOQ_MUST_USE moq_mux_container_ts_Verbatim *moq_mux_container_ts_Verbatim_new(uint8_t stream_type, moq_mux_container_ts_Framing framing); void moq_mux_container_ts_Error_free(moq_mux_container_ts_Error *self); bool moq_mux_container_ts_Error_borrowed(const moq_mux_container_ts_Error *self); -moq_mux_container_ts_Error *moq_mux_container_ts_Error_clone(const moq_mux_container_ts_Error *self); -moq_buf moq_mux_container_ts_Error_to_string(const moq_mux_container_ts_Error *self); -moq_buf moq_mux_container_ts_Error_debug(const moq_mux_container_ts_Error *self); +MOQ_MUST_USE moq_mux_container_ts_Error *moq_mux_container_ts_Error_clone(const moq_mux_container_ts_Error *self); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Error_to_string(const moq_mux_container_ts_Error *self); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Error_debug(const moq_mux_container_ts_Error *self); void moq_mux_container_ts_Export_Consumer_Extra_free(moq_mux_container_ts_Export_Consumer_Extra *self); void moq_mux_container_ts_Export_Consumer_Extra_drop(moq_mux_container_ts_Export_Consumer_Extra *self, moq_status *status); -moq_mux_container_ts_Export_Consumer_Extra *moq_mux_container_ts_Export_Consumer_Extra_new(moq_mux_Source *source, moq_mux_catalog_Consumer_Extra *catalog, moq_duration delay, moq_status *status); -moq_mux_container_ts_Export_Consumer_Extra *moq_mux_container_ts_Export_Consumer_Extra_with_mux_rate(moq_mux_container_ts_Export_Consumer_Extra *self, uint64_t mux_rate, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer_Extra *moq_mux_container_ts_Export_Consumer_Extra_new(moq_mux_Source *source, moq_mux_catalog_Consumer_Extra *catalog, moq_duration delay, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer_Extra *moq_mux_container_ts_Export_Consumer_Extra_with_mux_rate(moq_mux_container_ts_Export_Consumer_Extra *self, uint64_t mux_rate, moq_status *status); typedef struct moq_mux_container_ts_Export_Consumer_Extra_next_future moq_mux_container_ts_Export_Consumer_Extra_next_future; -moq_mux_container_ts_Export_Consumer_Extra_next_future *moq_mux_container_ts_Export_Consumer_Extra_next(moq_mux_container_ts_Export_Consumer_Extra *self, moq_status *status); -moq_poll moq_mux_container_ts_Export_Consumer_Extra_next_start(moq_mux_container_ts_Export_Consumer_Extra *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Export_Consumer_Extra_next_future **future, moq_status *status); -moq_poll moq_mux_container_ts_Export_Consumer_Extra_next_poll(moq_mux_container_ts_Export_Consumer_Extra_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer_Extra_next_future *moq_mux_container_ts_Export_Consumer_Extra_next(moq_mux_container_ts_Export_Consumer_Extra *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Export_Consumer_Extra_next_start(moq_mux_container_ts_Export_Consumer_Extra *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Export_Consumer_Extra_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Export_Consumer_Extra_next_poll(moq_mux_container_ts_Export_Consumer_Extra_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); void moq_mux_container_ts_Export_Consumer_Extra_next_future_free(moq_mux_container_ts_Export_Consumer_Extra_next_future *future); -moq_mux_container_ts_stats_Export *moq_mux_container_ts_Export_Consumer_Extra_stats(const moq_mux_container_ts_Export_Consumer_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Export *moq_mux_container_ts_Export_Consumer_Extra_stats(const moq_mux_container_ts_Export_Consumer_Extra *self, moq_status *status); uint64_t moq_mux_container_ts_Export_Consumer_Extra_discontinuity(const moq_mux_container_ts_Export_Consumer_Extra *self, moq_status *status); -bool moq_mux_container_ts_Export_Consumer_Extra_follow(moq_mux_container_ts_Export_Consumer_Extra *self, moq_broadcast_Consumer *broadcast, moq_mux_catalog_Consumer_Extra *catalog, moq_mux_container_ts_Export_Consumer_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Export_Consumer_Extra_follow(moq_mux_container_ts_Export_Consumer_Extra *self, moq_broadcast_Consumer *broadcast, moq_mux_catalog_Consumer_Extra *catalog, moq_mux_container_ts_Export_Consumer_Extra **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_ts_Export_Consumer_Ext_free(moq_mux_container_ts_Export_Consumer_Ext *self); void moq_mux_container_ts_Export_Consumer_Ext_drop(moq_mux_container_ts_Export_Consumer_Ext *self, moq_status *status); -moq_mux_container_ts_Export_Consumer_Ext *moq_mux_container_ts_Export_Consumer_Ext_new(moq_mux_Source *source, moq_mux_catalog_Consumer_Ext *catalog, moq_duration delay, moq_status *status); -moq_mux_container_ts_Export_Consumer_Ext *moq_mux_container_ts_Export_Consumer_Ext_with_mux_rate(moq_mux_container_ts_Export_Consumer_Ext *self, uint64_t mux_rate, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer_Ext *moq_mux_container_ts_Export_Consumer_Ext_new(moq_mux_Source *source, moq_mux_catalog_Consumer_Ext *catalog, moq_duration delay, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer_Ext *moq_mux_container_ts_Export_Consumer_Ext_with_mux_rate(moq_mux_container_ts_Export_Consumer_Ext *self, uint64_t mux_rate, moq_status *status); typedef struct moq_mux_container_ts_Export_Consumer_Ext_next_future moq_mux_container_ts_Export_Consumer_Ext_next_future; -moq_mux_container_ts_Export_Consumer_Ext_next_future *moq_mux_container_ts_Export_Consumer_Ext_next(moq_mux_container_ts_Export_Consumer_Ext *self, moq_status *status); -moq_poll moq_mux_container_ts_Export_Consumer_Ext_next_start(moq_mux_container_ts_Export_Consumer_Ext *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Export_Consumer_Ext_next_future **future, moq_status *status); -moq_poll moq_mux_container_ts_Export_Consumer_Ext_next_poll(moq_mux_container_ts_Export_Consumer_Ext_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer_Ext_next_future *moq_mux_container_ts_Export_Consumer_Ext_next(moq_mux_container_ts_Export_Consumer_Ext *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Export_Consumer_Ext_next_start(moq_mux_container_ts_Export_Consumer_Ext *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Export_Consumer_Ext_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Export_Consumer_Ext_next_poll(moq_mux_container_ts_Export_Consumer_Ext_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); void moq_mux_container_ts_Export_Consumer_Ext_next_future_free(moq_mux_container_ts_Export_Consumer_Ext_next_future *future); -moq_mux_container_ts_stats_Export *moq_mux_container_ts_Export_Consumer_Ext_stats(const moq_mux_container_ts_Export_Consumer_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Export *moq_mux_container_ts_Export_Consumer_Ext_stats(const moq_mux_container_ts_Export_Consumer_Ext *self, moq_status *status); uint64_t moq_mux_container_ts_Export_Consumer_Ext_discontinuity(const moq_mux_container_ts_Export_Consumer_Ext *self, moq_status *status); -bool moq_mux_container_ts_Export_Consumer_Ext_follow(moq_mux_container_ts_Export_Consumer_Ext *self, moq_broadcast_Consumer *broadcast, moq_mux_catalog_Consumer_Ext *catalog, moq_mux_container_ts_Export_Consumer_Ext **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Export_Consumer_Ext_follow(moq_mux_container_ts_Export_Consumer_Ext *self, moq_broadcast_Consumer *broadcast, moq_mux_catalog_Consumer_Ext *catalog, moq_mux_container_ts_Export_Consumer_Ext **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_ts_Export_Consumer_free(moq_mux_container_ts_Export_Consumer *self); void moq_mux_container_ts_Export_Consumer_drop(moq_mux_container_ts_Export_Consumer *self, moq_status *status); -moq_mux_container_ts_Export_Consumer *moq_mux_container_ts_Export_Consumer_new(moq_mux_Source *source, moq_mux_catalog_Consumer *catalog, moq_duration delay, moq_status *status); -moq_mux_container_ts_Export_Consumer *moq_mux_container_ts_Export_Consumer_with_mux_rate(moq_mux_container_ts_Export_Consumer *self, uint64_t mux_rate, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer *moq_mux_container_ts_Export_Consumer_new(moq_mux_Source *source, moq_mux_catalog_Consumer *catalog, moq_duration delay, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer *moq_mux_container_ts_Export_Consumer_with_mux_rate(moq_mux_container_ts_Export_Consumer *self, uint64_t mux_rate, moq_status *status); typedef struct moq_mux_container_ts_Export_Consumer_next_future moq_mux_container_ts_Export_Consumer_next_future; -moq_mux_container_ts_Export_Consumer_next_future *moq_mux_container_ts_Export_Consumer_next(moq_mux_container_ts_Export_Consumer *self, moq_status *status); -moq_poll moq_mux_container_ts_Export_Consumer_next_start(moq_mux_container_ts_Export_Consumer *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Export_Consumer_next_future **future, moq_status *status); -moq_poll moq_mux_container_ts_Export_Consumer_next_poll(moq_mux_container_ts_Export_Consumer_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer_next_future *moq_mux_container_ts_Export_Consumer_next(moq_mux_container_ts_Export_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Export_Consumer_next_start(moq_mux_container_ts_Export_Consumer *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Export_Consumer_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Export_Consumer_next_poll(moq_mux_container_ts_Export_Consumer_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); void moq_mux_container_ts_Export_Consumer_next_future_free(moq_mux_container_ts_Export_Consumer_next_future *future); -moq_mux_container_ts_stats_Export *moq_mux_container_ts_Export_Consumer_stats(const moq_mux_container_ts_Export_Consumer *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Export *moq_mux_container_ts_Export_Consumer_stats(const moq_mux_container_ts_Export_Consumer *self, moq_status *status); uint64_t moq_mux_container_ts_Export_Consumer_discontinuity(const moq_mux_container_ts_Export_Consumer *self, moq_status *status); -bool moq_mux_container_ts_Export_Consumer_follow(moq_mux_container_ts_Export_Consumer *self, moq_broadcast_Consumer *broadcast, moq_mux_catalog_Consumer *catalog, moq_mux_container_ts_Export_Consumer **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Export_Consumer_follow(moq_mux_container_ts_Export_Consumer *self, moq_broadcast_Consumer *broadcast, moq_mux_catalog_Consumer *catalog, moq_mux_container_ts_Export_Consumer **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_ts_Follower_free(moq_mux_container_ts_Follower *self); void moq_mux_container_ts_Follower_drop(moq_mux_container_ts_Follower *self, moq_status *status); -bool moq_mux_container_ts_Follower_new(moq_mux_container_ts_Export_Consumer *export_, moq_mux_container_ts_Follower **out, moq_mux_Error **err, moq_status *status); -moq_mux_container_ts_Follower *moq_mux_container_ts_Follower_with_follow(moq_mux_container_ts_Follower *self, moq_duration follow, moq_status *status); -moq_mux_container_ts_Follower *moq_mux_container_ts_Follower_with_stitch(moq_mux_container_ts_Follower *self, bool stitch, moq_status *status); -moq_mux_container_ts_Export_Consumer *moq_mux_container_ts_Follower_export(const moq_mux_container_ts_Follower *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Follower_new(moq_mux_container_ts_Export_Consumer *export_, moq_mux_container_ts_Follower **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Follower *moq_mux_container_ts_Follower_with_follow(moq_mux_container_ts_Follower *self, moq_duration follow, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Follower *moq_mux_container_ts_Follower_with_stitch(moq_mux_container_ts_Follower *self, bool stitch, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer *moq_mux_container_ts_Follower_export(const moq_mux_container_ts_Follower *self, moq_status *status); typedef struct moq_mux_container_ts_Follower_next_future moq_mux_container_ts_Follower_next_future; -moq_mux_container_ts_Follower_next_future *moq_mux_container_ts_Follower_next(moq_mux_container_ts_Follower *self, moq_status *status); -moq_poll moq_mux_container_ts_Follower_next_start(moq_mux_container_ts_Follower *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Follower_next_future **future, moq_status *status); -moq_poll moq_mux_container_ts_Follower_next_poll(moq_mux_container_ts_Follower_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_ts_Follower_next_future *moq_mux_container_ts_Follower_next(moq_mux_container_ts_Follower *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Follower_next_start(moq_mux_container_ts_Follower *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Follower_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Follower_next_poll(moq_mux_container_ts_Follower_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); void moq_mux_container_ts_Follower_next_future_free(moq_mux_container_ts_Follower_next_future *future); void moq_mux_container_ts_Follower_Extra_free(moq_mux_container_ts_Follower_Extra *self); void moq_mux_container_ts_Follower_Extra_drop(moq_mux_container_ts_Follower_Extra *self, moq_status *status); -bool moq_mux_container_ts_Follower_Extra_new(moq_mux_container_ts_Export_Consumer_Extra *export_, moq_mux_container_ts_Follower_Extra **out, moq_mux_Error **err, moq_status *status); -moq_mux_container_ts_Follower_Extra *moq_mux_container_ts_Follower_Extra_with_follow(moq_mux_container_ts_Follower_Extra *self, moq_duration follow, moq_status *status); -moq_mux_container_ts_Follower_Extra *moq_mux_container_ts_Follower_Extra_with_stitch(moq_mux_container_ts_Follower_Extra *self, bool stitch, moq_status *status); -moq_mux_container_ts_Export_Consumer_Extra *moq_mux_container_ts_Follower_Extra_export(const moq_mux_container_ts_Follower_Extra *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Follower_Extra_new(moq_mux_container_ts_Export_Consumer_Extra *export_, moq_mux_container_ts_Follower_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Follower_Extra *moq_mux_container_ts_Follower_Extra_with_follow(moq_mux_container_ts_Follower_Extra *self, moq_duration follow, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Follower_Extra *moq_mux_container_ts_Follower_Extra_with_stitch(moq_mux_container_ts_Follower_Extra *self, bool stitch, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer_Extra *moq_mux_container_ts_Follower_Extra_export(const moq_mux_container_ts_Follower_Extra *self, moq_status *status); typedef struct moq_mux_container_ts_Follower_Extra_next_future moq_mux_container_ts_Follower_Extra_next_future; -moq_mux_container_ts_Follower_Extra_next_future *moq_mux_container_ts_Follower_Extra_next(moq_mux_container_ts_Follower_Extra *self, moq_status *status); -moq_poll moq_mux_container_ts_Follower_Extra_next_start(moq_mux_container_ts_Follower_Extra *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Follower_Extra_next_future **future, moq_status *status); -moq_poll moq_mux_container_ts_Follower_Extra_next_poll(moq_mux_container_ts_Follower_Extra_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_ts_Follower_Extra_next_future *moq_mux_container_ts_Follower_Extra_next(moq_mux_container_ts_Follower_Extra *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Follower_Extra_next_start(moq_mux_container_ts_Follower_Extra *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Follower_Extra_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Follower_Extra_next_poll(moq_mux_container_ts_Follower_Extra_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); void moq_mux_container_ts_Follower_Extra_next_future_free(moq_mux_container_ts_Follower_Extra_next_future *future); void moq_mux_container_ts_Follower_Ext_free(moq_mux_container_ts_Follower_Ext *self); void moq_mux_container_ts_Follower_Ext_drop(moq_mux_container_ts_Follower_Ext *self, moq_status *status); -bool moq_mux_container_ts_Follower_Ext_new(moq_mux_container_ts_Export_Consumer_Ext *export_, moq_mux_container_ts_Follower_Ext **out, moq_mux_Error **err, moq_status *status); -moq_mux_container_ts_Follower_Ext *moq_mux_container_ts_Follower_Ext_with_follow(moq_mux_container_ts_Follower_Ext *self, moq_duration follow, moq_status *status); -moq_mux_container_ts_Follower_Ext *moq_mux_container_ts_Follower_Ext_with_stitch(moq_mux_container_ts_Follower_Ext *self, bool stitch, moq_status *status); -moq_mux_container_ts_Export_Consumer_Ext *moq_mux_container_ts_Follower_Ext_export(const moq_mux_container_ts_Follower_Ext *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Follower_Ext_new(moq_mux_container_ts_Export_Consumer_Ext *export_, moq_mux_container_ts_Follower_Ext **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Follower_Ext *moq_mux_container_ts_Follower_Ext_with_follow(moq_mux_container_ts_Follower_Ext *self, moq_duration follow, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Follower_Ext *moq_mux_container_ts_Follower_Ext_with_stitch(moq_mux_container_ts_Follower_Ext *self, bool stitch, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Export_Consumer_Ext *moq_mux_container_ts_Follower_Ext_export(const moq_mux_container_ts_Follower_Ext *self, moq_status *status); typedef struct moq_mux_container_ts_Follower_Ext_next_future moq_mux_container_ts_Follower_Ext_next_future; -moq_mux_container_ts_Follower_Ext_next_future *moq_mux_container_ts_Follower_Ext_next(moq_mux_container_ts_Follower_Ext *self, moq_status *status); -moq_poll moq_mux_container_ts_Follower_Ext_next_start(moq_mux_container_ts_Follower_Ext *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Follower_Ext_next_future **future, moq_status *status); -moq_poll moq_mux_container_ts_Follower_Ext_next_poll(moq_mux_container_ts_Follower_Ext_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_ts_Follower_Ext_next_future *moq_mux_container_ts_Follower_Ext_next(moq_mux_container_ts_Follower_Ext *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Follower_Ext_next_start(moq_mux_container_ts_Follower_Ext *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Follower_Ext_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Follower_Ext_next_poll(moq_mux_container_ts_Follower_Ext_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); void moq_mux_container_ts_Follower_Ext_next_future_free(moq_mux_container_ts_Follower_Ext_next_future *future); void moq_mux_container_ts_Passthrough_free(moq_mux_container_ts_Passthrough *self); void moq_mux_container_ts_Passthrough_drop(moq_mux_container_ts_Passthrough *self, moq_status *status); -bool moq_mux_container_ts_Passthrough_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_container_ts_Passthrough **out, moq_mux_Error **err, moq_status *status); -moq_mux_container_ts_Passthrough *moq_mux_container_ts_Passthrough_with_pcr_pid(moq_mux_container_ts_Passthrough *self, uint16_t pid, moq_status *status); -moq_buf moq_mux_container_ts_Passthrough_track(const moq_mux_container_ts_Passthrough *self, moq_status *status); -bool moq_mux_container_ts_Passthrough_decode(moq_mux_container_ts_Passthrough *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_ts_Passthrough_finish(moq_mux_container_ts_Passthrough *self, moq_mux_container_ts_passthrough_Finished **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Passthrough_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, moq_mux_container_ts_Passthrough **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Passthrough *moq_mux_container_ts_Passthrough_with_pcr_pid(moq_mux_container_ts_Passthrough *self, uint16_t pid, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Passthrough_track(const moq_mux_container_ts_Passthrough *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Passthrough_decode(moq_mux_container_ts_Passthrough *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Passthrough_finish(moq_mux_container_ts_Passthrough *self, moq_mux_container_ts_passthrough_Finished **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_ts_Passthrough_abort(moq_mux_container_ts_Passthrough *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_Passthrough_unit_free(moq_mux_container_ts_Passthrough_unit *self); void moq_mux_container_ts_Passthrough_unit_drop(moq_mux_container_ts_Passthrough_unit *self, moq_status *status); -bool moq_mux_container_ts_Passthrough_unit_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, moq_mux_container_ts_Passthrough_unit **out, moq_mux_Error **err, moq_status *status); -moq_mux_container_ts_Passthrough_unit *moq_mux_container_ts_Passthrough_unit_with_pcr_pid(moq_mux_container_ts_Passthrough_unit *self, uint16_t pid, moq_status *status); -moq_buf moq_mux_container_ts_Passthrough_unit_track(const moq_mux_container_ts_Passthrough_unit *self, moq_status *status); -bool moq_mux_container_ts_Passthrough_unit_decode(moq_mux_container_ts_Passthrough_unit *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_ts_Passthrough_unit_finish(moq_mux_container_ts_Passthrough_unit *self, moq_mux_container_ts_passthrough_Finished_unit **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Passthrough_unit_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, moq_mux_container_ts_Passthrough_unit **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Passthrough_unit *moq_mux_container_ts_Passthrough_unit_with_pcr_pid(moq_mux_container_ts_Passthrough_unit *self, uint16_t pid, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Passthrough_unit_track(const moq_mux_container_ts_Passthrough_unit *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Passthrough_unit_decode(moq_mux_container_ts_Passthrough_unit *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Passthrough_unit_finish(moq_mux_container_ts_Passthrough_unit *self, moq_mux_container_ts_passthrough_Finished_unit **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_ts_Passthrough_unit_abort(moq_mux_container_ts_Passthrough_unit *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_Passthrough_Extra_free(moq_mux_container_ts_Passthrough_Extra *self); void moq_mux_container_ts_Passthrough_Extra_drop(moq_mux_container_ts_Passthrough_Extra *self, moq_status *status); -bool moq_mux_container_ts_Passthrough_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_container_ts_Passthrough_Extra **out, moq_mux_Error **err, moq_status *status); -moq_mux_container_ts_Passthrough_Extra *moq_mux_container_ts_Passthrough_Extra_with_pcr_pid(moq_mux_container_ts_Passthrough_Extra *self, uint16_t pid, moq_status *status); -moq_buf moq_mux_container_ts_Passthrough_Extra_track(const moq_mux_container_ts_Passthrough_Extra *self, moq_status *status); -bool moq_mux_container_ts_Passthrough_Extra_decode(moq_mux_container_ts_Passthrough_Extra *self, moq_buf data_, moq_mux_Error **err, moq_status *status); -bool moq_mux_container_ts_Passthrough_Extra_finish(moq_mux_container_ts_Passthrough_Extra *self, moq_mux_container_ts_passthrough_Finished_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Passthrough_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, moq_mux_container_ts_Passthrough_Extra **out, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Passthrough_Extra *moq_mux_container_ts_Passthrough_Extra_with_pcr_pid(moq_mux_container_ts_Passthrough_Extra *self, uint16_t pid, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Passthrough_Extra_track(const moq_mux_container_ts_Passthrough_Extra *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Passthrough_Extra_decode(moq_mux_container_ts_Passthrough_Extra *self, moq_buf data_, moq_mux_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Passthrough_Extra_finish(moq_mux_container_ts_Passthrough_Extra *self, moq_mux_container_ts_passthrough_Finished_Extra **out, moq_mux_Error **err, moq_status *status); void moq_mux_container_ts_Passthrough_Extra_abort(moq_mux_container_ts_Passthrough_Extra *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_Programs_free(moq_mux_container_ts_Programs *self); void moq_mux_container_ts_Programs_drop(moq_mux_container_ts_Programs *self, moq_status *status); -moq_mux_container_ts_Programs *moq_mux_container_ts_Programs_new(moq_origin_Producer *origin, moq_Path *name, moq_mux_catalog_Config *config, moq_status *status); -bool moq_mux_container_ts_Programs_decode(moq_mux_container_ts_Programs *self, moq_buf data_, moq_mux_container_ts_Error **err, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Programs_stats(const moq_mux_container_ts_Programs *self, moq_status *status); -bool moq_mux_container_ts_Programs_finish(moq_mux_container_ts_Programs *self, moq_mux_container_ts_programs_Finished **out, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Programs *moq_mux_container_ts_Programs_new(moq_origin_Producer *origin, moq_Path *name, moq_mux_catalog_Config *config, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Programs_decode(moq_mux_container_ts_Programs *self, moq_buf data_, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Programs_stats(const moq_mux_container_ts_Programs *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Programs_finish(moq_mux_container_ts_Programs *self, moq_mux_container_ts_programs_Finished **out, moq_mux_container_ts_Error **err, moq_status *status); void moq_mux_container_ts_Programs_abort(moq_mux_container_ts_Programs *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_Release_free(moq_mux_container_ts_Release *self); void moq_mux_container_ts_Release_drop(moq_mux_container_ts_Release *self, moq_status *status); typedef struct moq_mux_container_ts_Release_new_future moq_mux_container_ts_Release_new_future; -moq_mux_container_ts_Release_new_future *moq_mux_container_ts_Release_new(moq_mux_Source *source, moq_mux_catalog_CatalogFormat catalog_format, moq_duration delay, moq_status *status); -moq_poll moq_mux_container_ts_Release_new_start(moq_mux_Source *source, moq_mux_catalog_CatalogFormat catalog_format, moq_duration delay, moq_mux_container_ts_Release **out, moq_mux_Error **err, moq_mux_container_ts_Release_new_future **future, moq_status *status); -moq_poll moq_mux_container_ts_Release_new_poll(moq_mux_container_ts_Release_new_future *future, moq_waker waker, moq_mux_container_ts_Release **out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_ts_Release_new_future *moq_mux_container_ts_Release_new(moq_mux_Source *source, moq_mux_catalog_CatalogFormat catalog_format, moq_duration delay, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Release_new_start(moq_mux_Source *source, moq_mux_catalog_CatalogFormat catalog_format, moq_duration delay, moq_mux_container_ts_Release **out, moq_mux_Error **err, moq_mux_container_ts_Release_new_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Release_new_poll(moq_mux_container_ts_Release_new_future *future, moq_waker waker, moq_mux_container_ts_Release **out, moq_mux_Error **err); void moq_mux_container_ts_Release_new_future_free(moq_mux_container_ts_Release_new_future *future); uint64_t moq_mux_container_ts_Release_dropped(const moq_mux_container_ts_Release *self, moq_status *status); moq_option_f64 moq_mux_container_ts_Release_drift(const moq_mux_container_ts_Release *self, moq_status *status); uint64_t moq_mux_container_ts_Release_out_of_tolerance(const moq_mux_container_ts_Release *self, moq_status *status); -moq_mux_container_ts_stats_Release *moq_mux_container_ts_Release_stats(const moq_mux_container_ts_Release *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Release *moq_mux_container_ts_Release_stats(const moq_mux_container_ts_Release *self, moq_status *status); typedef struct moq_mux_container_ts_Release_next_future moq_mux_container_ts_Release_next_future; -moq_mux_container_ts_Release_next_future *moq_mux_container_ts_Release_next(moq_mux_container_ts_Release *self, moq_status *status); -moq_poll moq_mux_container_ts_Release_next_start(moq_mux_container_ts_Release *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Release_next_future **future, moq_status *status); -moq_poll moq_mux_container_ts_Release_next_poll(moq_mux_container_ts_Release_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); +MOQ_MUST_USE moq_mux_container_ts_Release_next_future *moq_mux_container_ts_Release_next(moq_mux_container_ts_Release *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Release_next_start(moq_mux_container_ts_Release *self, moq_option_mux_container_Frame *out, moq_mux_Error **err, moq_mux_container_ts_Release_next_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_mux_container_ts_Release_next_poll(moq_mux_container_ts_Release_next_future *future, moq_waker waker, moq_option_mux_container_Frame *out, moq_mux_Error **err); void moq_mux_container_ts_Release_next_future_free(moq_mux_container_ts_Release_next_future *future); void moq_mux_container_ts_Republish_free(moq_mux_container_ts_Republish *self); void moq_mux_container_ts_Republish_drop(moq_mux_container_ts_Republish *self, moq_status *status); -bool moq_mux_container_ts_Republish_new(moq_origin_Producer *origin, moq_Path *name, moq_Instance *instance, moq_mux_catalog_Config *config, moq_mux_container_ts_Republish **out, moq_mux_container_ts_Error **err, moq_status *status); -moq_mux_container_ts_Republish *moq_mux_container_ts_Republish_with_program(moq_mux_container_ts_Republish *self, uint16_t program, moq_status *status); -moq_broadcast_Producer *moq_mux_container_ts_Republish_broadcast(const moq_mux_container_ts_Republish *self, moq_status *status); -moq_mux_catalog_Producer_Ext *moq_mux_container_ts_Republish_catalog(const moq_mux_container_ts_Republish *self, moq_status *status); -moq_Instance *moq_mux_container_ts_Republish_instance(const moq_mux_container_ts_Republish *self, moq_status *status); -bool moq_mux_container_ts_Republish_decode(moq_mux_container_ts_Republish *self, moq_buf data_, moq_mux_container_ts_Republished **out, moq_mux_container_ts_Error **err, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Republish_stats(const moq_mux_container_ts_Republish *self, moq_status *status); -bool moq_mux_container_ts_Republish_finish(moq_mux_container_ts_Republish *self, moq_mux_container_ts_republish_Finished **out, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Republish_new(moq_origin_Producer *origin, moq_Path *name, moq_Instance *instance, moq_mux_catalog_Config *config, moq_mux_container_ts_Republish **out, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Republish *moq_mux_container_ts_Republish_with_program(moq_mux_container_ts_Republish *self, uint16_t program, moq_status *status); +MOQ_MUST_USE moq_broadcast_Producer *moq_mux_container_ts_Republish_broadcast(const moq_mux_container_ts_Republish *self, moq_status *status); +MOQ_MUST_USE moq_mux_catalog_Producer_Ext *moq_mux_container_ts_Republish_catalog(const moq_mux_container_ts_Republish *self, moq_status *status); +MOQ_MUST_USE moq_Instance *moq_mux_container_ts_Republish_instance(const moq_mux_container_ts_Republish *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Republish_decode(moq_mux_container_ts_Republish *self, moq_buf data_, moq_mux_container_ts_Republished **out, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Republish_stats(const moq_mux_container_ts_Republish *self, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Republish_finish(moq_mux_container_ts_Republish *self, moq_mux_container_ts_republish_Finished **out, moq_mux_container_ts_Error **err, moq_status *status); void moq_mux_container_ts_Republish_abort(moq_mux_container_ts_Republish *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_Republished_free(moq_mux_container_ts_Republished *self); void moq_mux_container_ts_Republished_drop(moq_mux_container_ts_Republished *self, moq_status *status); -moq_mux_container_ts_Republished *moq_mux_container_ts_Republished_clone(const moq_mux_container_ts_Republished *self, moq_status *status); -moq_buf moq_mux_container_ts_Republished_debug(const moq_mux_container_ts_Republished *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Republished *moq_mux_container_ts_Republished_clone(const moq_mux_container_ts_Republished *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_Republished_debug(const moq_mux_container_ts_Republished *self, moq_status *status); moq_mux_container_ts_Step moq_mux_container_ts_Republished_step_get(const moq_mux_container_ts_Republished *self, moq_status *status); void moq_mux_container_ts_Republished_step_set(moq_mux_container_ts_Republished *self, moq_mux_container_ts_Step value, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Republished_stats_get(const moq_mux_container_ts_Republished *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Republished_stats_get(const moq_mux_container_ts_Republished *self, moq_status *status); void moq_mux_container_ts_Republished_stats_set(moq_mux_container_ts_Republished *self, moq_mux_container_ts_stats_Snapshot *value, moq_status *status); void moq_mux_container_ts_Import_free(moq_mux_container_ts_Import *self); void moq_mux_container_ts_Import_drop(moq_mux_container_ts_Import *self, moq_status *status); -moq_mux_container_ts_Import *moq_mux_container_ts_Import_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, moq_status *status); -moq_mux_container_ts_Import *moq_mux_container_ts_Import_with_program(moq_mux_container_ts_Import *self, uint16_t program, moq_status *status); -moq_mux_container_ts_Import *moq_mux_container_ts_Import_with_container(moq_mux_container_ts_Import *self, moq_hang_catalog_Container *container, moq_status *status); -bool moq_mux_container_ts_Import_decode(moq_mux_container_ts_Import *self, moq_buf data_, moq_mux_container_ts_Error **err, moq_status *status); -bool moq_mux_container_ts_Import_seek(moq_mux_container_ts_Import *self, uint64_t sequence, moq_mux_container_ts_Error **err, moq_status *status); -bool moq_mux_container_ts_Import_finish(moq_mux_container_ts_Import *self, moq_mux_container_ts_Finished **out, moq_mux_container_ts_Error **err, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Import_stats(const moq_mux_container_ts_Import *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Import *moq_mux_container_ts_Import_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved *reserved, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Import *moq_mux_container_ts_Import_with_program(moq_mux_container_ts_Import *self, uint16_t program, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Import *moq_mux_container_ts_Import_with_container(moq_mux_container_ts_Import *self, moq_hang_catalog_Container *container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Import_decode(moq_mux_container_ts_Import *self, moq_buf data_, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Import_seek(moq_mux_container_ts_Import *self, uint64_t sequence, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Import_finish(moq_mux_container_ts_Import *self, moq_mux_container_ts_Finished **out, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Import_stats(const moq_mux_container_ts_Import *self, moq_status *status); void moq_mux_container_ts_Import_abort(moq_mux_container_ts_Import *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_Import_Extra_free(moq_mux_container_ts_Import_Extra *self); void moq_mux_container_ts_Import_Extra_drop(moq_mux_container_ts_Import_Extra *self, moq_status *status); -moq_mux_container_ts_Import_Extra *moq_mux_container_ts_Import_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, moq_status *status); -moq_mux_container_ts_Import_Extra *moq_mux_container_ts_Import_Extra_with_program(moq_mux_container_ts_Import_Extra *self, uint16_t program, moq_status *status); -moq_mux_container_ts_Import_Extra *moq_mux_container_ts_Import_Extra_with_container(moq_mux_container_ts_Import_Extra *self, moq_hang_catalog_Container *container, moq_status *status); -bool moq_mux_container_ts_Import_Extra_decode(moq_mux_container_ts_Import_Extra *self, moq_buf data_, moq_mux_container_ts_Error **err, moq_status *status); -bool moq_mux_container_ts_Import_Extra_seek(moq_mux_container_ts_Import_Extra *self, uint64_t sequence, moq_mux_container_ts_Error **err, moq_status *status); -bool moq_mux_container_ts_Import_Extra_finish(moq_mux_container_ts_Import_Extra *self, moq_mux_container_ts_Finished_Extra **out, moq_mux_container_ts_Error **err, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Import_Extra_stats(const moq_mux_container_ts_Import_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Import_Extra *moq_mux_container_ts_Import_Extra_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Extra *reserved, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Import_Extra *moq_mux_container_ts_Import_Extra_with_program(moq_mux_container_ts_Import_Extra *self, uint16_t program, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Import_Extra *moq_mux_container_ts_Import_Extra_with_container(moq_mux_container_ts_Import_Extra *self, moq_hang_catalog_Container *container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Import_Extra_decode(moq_mux_container_ts_Import_Extra *self, moq_buf data_, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Import_Extra_seek(moq_mux_container_ts_Import_Extra *self, uint64_t sequence, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Import_Extra_finish(moq_mux_container_ts_Import_Extra *self, moq_mux_container_ts_Finished_Extra **out, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Import_Extra_stats(const moq_mux_container_ts_Import_Extra *self, moq_status *status); void moq_mux_container_ts_Import_Extra_abort(moq_mux_container_ts_Import_Extra *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_Import_Ext_free(moq_mux_container_ts_Import_Ext *self); void moq_mux_container_ts_Import_Ext_drop(moq_mux_container_ts_Import_Ext *self, moq_status *status); -moq_mux_container_ts_Import_Ext *moq_mux_container_ts_Import_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, moq_status *status); -moq_mux_container_ts_Import_Ext *moq_mux_container_ts_Import_Ext_with_program(moq_mux_container_ts_Import_Ext *self, uint16_t program, moq_status *status); -moq_mux_container_ts_Import_Ext *moq_mux_container_ts_Import_Ext_with_container(moq_mux_container_ts_Import_Ext *self, moq_hang_catalog_Container *container, moq_status *status); -bool moq_mux_container_ts_Import_Ext_decode(moq_mux_container_ts_Import_Ext *self, moq_buf data_, moq_mux_container_ts_Error **err, moq_status *status); -bool moq_mux_container_ts_Import_Ext_seek(moq_mux_container_ts_Import_Ext *self, uint64_t sequence, moq_mux_container_ts_Error **err, moq_status *status); -bool moq_mux_container_ts_Import_Ext_finish(moq_mux_container_ts_Import_Ext *self, moq_mux_container_ts_Finished_Ext **out, moq_mux_container_ts_Error **err, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Import_Ext_stats(const moq_mux_container_ts_Import_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Import_Ext *moq_mux_container_ts_Import_Ext_new(moq_broadcast_Producer *broadcast, moq_mux_catalog_Reserved_Ext *reserved, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Import_Ext *moq_mux_container_ts_Import_Ext_with_program(moq_mux_container_ts_Import_Ext *self, uint16_t program, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_Import_Ext *moq_mux_container_ts_Import_Ext_with_container(moq_mux_container_ts_Import_Ext *self, moq_hang_catalog_Container *container, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Import_Ext_decode(moq_mux_container_ts_Import_Ext *self, moq_buf data_, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Import_Ext_seek(moq_mux_container_ts_Import_Ext *self, uint64_t sequence, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE bool moq_mux_container_ts_Import_Ext_finish(moq_mux_container_ts_Import_Ext *self, moq_mux_container_ts_Finished_Ext **out, moq_mux_container_ts_Error **err, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Import_Ext_stats(const moq_mux_container_ts_Import_Ext *self, moq_status *status); void moq_mux_container_ts_Import_Ext_abort(moq_mux_container_ts_Import_Ext *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_Finished_free(moq_mux_container_ts_Finished *self); void moq_mux_container_ts_Finished_drop(moq_mux_container_ts_Finished *self, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Finished_stats(const moq_mux_container_ts_Finished *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Finished_stats(const moq_mux_container_ts_Finished *self, moq_status *status); void moq_mux_container_ts_Finished_abort(moq_mux_container_ts_Finished *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_Finished_Extra_free(moq_mux_container_ts_Finished_Extra *self); void moq_mux_container_ts_Finished_Extra_drop(moq_mux_container_ts_Finished_Extra *self, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Finished_Extra_stats(const moq_mux_container_ts_Finished_Extra *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Finished_Extra_stats(const moq_mux_container_ts_Finished_Extra *self, moq_status *status); void moq_mux_container_ts_Finished_Extra_abort(moq_mux_container_ts_Finished_Extra *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_Finished_Ext_free(moq_mux_container_ts_Finished_Ext *self); void moq_mux_container_ts_Finished_Ext_drop(moq_mux_container_ts_Finished_Ext *self, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Finished_Ext_stats(const moq_mux_container_ts_Finished_Ext *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_Finished_Ext_stats(const moq_mux_container_ts_Finished_Ext *self, moq_status *status); void moq_mux_container_ts_Finished_Ext_abort(moq_mux_container_ts_Finished_Ext *self, moq_Error *err_, moq_status *status); void moq_mux_import_container_Finished_free(moq_mux_import_container_Finished *self); void moq_mux_import_container_Finished_drop(moq_mux_import_container_Finished *self, moq_status *status); @@ -8665,12 +8675,12 @@ void moq_mux_import_container_Finished_Ext_drop(moq_mux_import_container_Finishe void moq_mux_import_container_Finished_Ext_abort(moq_mux_import_container_Finished_Ext *self, moq_Error *err_, moq_status *status); void moq_mux_import_track_Finished_free(moq_mux_import_track_Finished *self); void moq_mux_import_track_Finished_drop(moq_mux_import_track_Finished *self, moq_status *status); -moq_buf moq_mux_import_track_Finished_name(const moq_mux_import_track_Finished *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_import_track_Finished_name(const moq_mux_import_track_Finished *self, moq_status *status); void moq_mux_import_track_Finished_abort(moq_mux_import_track_Finished *self, moq_Error *err_, moq_status *status); void moq_mux_codec_aac_adts_Header_free(moq_mux_codec_aac_adts_Header *self); void moq_mux_codec_aac_adts_Header_drop(moq_mux_codec_aac_adts_Header *self, moq_status *status); -moq_mux_codec_aac_adts_Header *moq_mux_codec_aac_adts_Header_clone(const moq_mux_codec_aac_adts_Header *self, moq_status *status); -moq_buf moq_mux_codec_aac_adts_Header_debug(const moq_mux_codec_aac_adts_Header *self, moq_status *status); +MOQ_MUST_USE moq_mux_codec_aac_adts_Header *moq_mux_codec_aac_adts_Header_clone(const moq_mux_codec_aac_adts_Header *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_codec_aac_adts_Header_debug(const moq_mux_codec_aac_adts_Header *self, moq_status *status); uint8_t moq_mux_codec_aac_adts_Header_object_type_get(const moq_mux_codec_aac_adts_Header *self, moq_status *status); void moq_mux_codec_aac_adts_Header_object_type_set(moq_mux_codec_aac_adts_Header *self, uint8_t value, moq_status *status); uint32_t moq_mux_codec_aac_adts_Header_sample_rate_get(const moq_mux_codec_aac_adts_Header *self, moq_status *status); @@ -8679,47 +8689,47 @@ uint8_t moq_mux_codec_aac_adts_Header_channel_config_get(const moq_mux_codec_aac void moq_mux_codec_aac_adts_Header_channel_config_set(moq_mux_codec_aac_adts_Header *self, uint8_t value, moq_status *status); uint8_t moq_mux_codec_aac_adts_Header_blocks_get(const moq_mux_codec_aac_adts_Header *self, moq_status *status); void moq_mux_codec_aac_adts_Header_blocks_set(moq_mux_codec_aac_adts_Header *self, uint8_t value, moq_status *status); -bool moq_mux_codec_aac_adts_Header_parse(moq_buf data_, moq_mux_codec_aac_adts_Header **out, moq_mux_codec_aac_adts_Error *err); -bool moq_mux_codec_aac_adts_Header_payload(const moq_mux_codec_aac_adts_Header *self, moq_buf packet, moq_buf *out, moq_mux_codec_aac_adts_Error *err, moq_status *status); +MOQ_MUST_USE bool moq_mux_codec_aac_adts_Header_parse(moq_buf data_, moq_mux_codec_aac_adts_Header **out, moq_mux_codec_aac_adts_Error *err); +MOQ_MUST_USE bool moq_mux_codec_aac_adts_Header_payload(const moq_mux_codec_aac_adts_Header *self, moq_buf packet, moq_buf *out, moq_mux_codec_aac_adts_Error *err, moq_status *status); void moq_mux_container_ts_passthrough_Finished_free(moq_mux_container_ts_passthrough_Finished *self); void moq_mux_container_ts_passthrough_Finished_drop(moq_mux_container_ts_passthrough_Finished *self, moq_status *status); -moq_buf moq_mux_container_ts_passthrough_Finished_track(const moq_mux_container_ts_passthrough_Finished *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_passthrough_Finished_track(const moq_mux_container_ts_passthrough_Finished *self, moq_status *status); void moq_mux_container_ts_passthrough_Finished_abort(moq_mux_container_ts_passthrough_Finished *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_passthrough_Finished_unit_free(moq_mux_container_ts_passthrough_Finished_unit *self); void moq_mux_container_ts_passthrough_Finished_unit_drop(moq_mux_container_ts_passthrough_Finished_unit *self, moq_status *status); -moq_buf moq_mux_container_ts_passthrough_Finished_unit_track(const moq_mux_container_ts_passthrough_Finished_unit *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_passthrough_Finished_unit_track(const moq_mux_container_ts_passthrough_Finished_unit *self, moq_status *status); void moq_mux_container_ts_passthrough_Finished_unit_abort(moq_mux_container_ts_passthrough_Finished_unit *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_passthrough_Finished_Extra_free(moq_mux_container_ts_passthrough_Finished_Extra *self); void moq_mux_container_ts_passthrough_Finished_Extra_drop(moq_mux_container_ts_passthrough_Finished_Extra *self, moq_status *status); -moq_buf moq_mux_container_ts_passthrough_Finished_Extra_track(const moq_mux_container_ts_passthrough_Finished_Extra *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_passthrough_Finished_Extra_track(const moq_mux_container_ts_passthrough_Finished_Extra *self, moq_status *status); void moq_mux_container_ts_passthrough_Finished_Extra_abort(moq_mux_container_ts_passthrough_Finished_Extra *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_programs_Finished_free(moq_mux_container_ts_programs_Finished *self); void moq_mux_container_ts_programs_Finished_drop(moq_mux_container_ts_programs_Finished *self, moq_status *status); -moq_vec_broadcast_Producer moq_mux_container_ts_programs_Finished_broadcasts(const moq_mux_container_ts_programs_Finished *self, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_programs_Finished_stats(const moq_mux_container_ts_programs_Finished *self, moq_status *status); +MOQ_MUST_USE moq_vec_broadcast_Producer moq_mux_container_ts_programs_Finished_broadcasts(const moq_mux_container_ts_programs_Finished *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_programs_Finished_stats(const moq_mux_container_ts_programs_Finished *self, moq_status *status); void moq_mux_container_ts_programs_Finished_abort(moq_mux_container_ts_programs_Finished *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_republish_Finished_free(moq_mux_container_ts_republish_Finished *self); void moq_mux_container_ts_republish_Finished_drop(moq_mux_container_ts_republish_Finished *self, moq_status *status); -moq_broadcast_Producer *moq_mux_container_ts_republish_Finished_broadcast(const moq_mux_container_ts_republish_Finished *self, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_republish_Finished_stats(const moq_mux_container_ts_republish_Finished *self, moq_status *status); +MOQ_MUST_USE moq_broadcast_Producer *moq_mux_container_ts_republish_Finished_broadcast(const moq_mux_container_ts_republish_Finished *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_republish_Finished_stats(const moq_mux_container_ts_republish_Finished *self, moq_status *status); void moq_mux_container_ts_republish_Finished_abort(moq_mux_container_ts_republish_Finished *self, moq_Error *err_, moq_status *status); void moq_mux_container_ts_stats_Report_free(moq_mux_container_ts_stats_Report *self); void moq_mux_container_ts_stats_Report_drop(moq_mux_container_ts_stats_Report *self, moq_status *status); -moq_mux_container_ts_stats_Report *moq_mux_container_ts_stats_Report_clone(const moq_mux_container_ts_stats_Report *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Report *moq_mux_container_ts_stats_Report_clone(const moq_mux_container_ts_stats_Report *self, moq_status *status); bool moq_mux_container_ts_stats_Report_eq(const moq_mux_container_ts_stats_Report *a, const moq_mux_container_ts_stats_Report *b, moq_status *status); -moq_buf moq_mux_container_ts_stats_Report_debug(const moq_mux_container_ts_stats_Report *self, moq_status *status); -moq_mux_container_ts_stats_Report *moq_mux_container_ts_stats_Report_default(void); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_stats_Report_mpegts_get(const moq_mux_container_ts_stats_Report *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_stats_Report_debug(const moq_mux_container_ts_stats_Report *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Report *moq_mux_container_ts_stats_Report_default(void); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_stats_Report_mpegts_get(const moq_mux_container_ts_stats_Report *self, moq_status *status); void moq_mux_container_ts_stats_Report_mpegts_set(moq_mux_container_ts_stats_Report *self, moq_mux_container_ts_stats_Snapshot *value, moq_status *status); -moq_mux_container_ts_stats_Release *moq_mux_container_ts_stats_Report_release_get(const moq_mux_container_ts_stats_Report *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Release *moq_mux_container_ts_stats_Report_release_get(const moq_mux_container_ts_stats_Report *self, moq_status *status); void moq_mux_container_ts_stats_Report_release_set(moq_mux_container_ts_stats_Report *self, moq_mux_container_ts_stats_Release *value, moq_status *status); void moq_mux_container_ts_stats_Snapshot_free(moq_mux_container_ts_stats_Snapshot *self); void moq_mux_container_ts_stats_Snapshot_drop(moq_mux_container_ts_stats_Snapshot *self, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_stats_Snapshot_clone(const moq_mux_container_ts_stats_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_stats_Snapshot_clone(const moq_mux_container_ts_stats_Snapshot *self, moq_status *status); bool moq_mux_container_ts_stats_Snapshot_eq(const moq_mux_container_ts_stats_Snapshot *a, const moq_mux_container_ts_stats_Snapshot *b, moq_status *status); -moq_buf moq_mux_container_ts_stats_Snapshot_debug(const moq_mux_container_ts_stats_Snapshot *self, moq_status *status); -moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_stats_Snapshot_default(void); -moq_vec_tuple_u16_mux_container_ts_stats_Stream moq_mux_container_ts_stats_Snapshot_streams_get(const moq_mux_container_ts_stats_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_stats_Snapshot_debug(const moq_mux_container_ts_stats_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Snapshot *moq_mux_container_ts_stats_Snapshot_default(void); +MOQ_MUST_USE moq_vec_tuple_u16_mux_container_ts_stats_Stream moq_mux_container_ts_stats_Snapshot_streams_get(const moq_mux_container_ts_stats_Snapshot *self, moq_status *status); void moq_mux_container_ts_stats_Snapshot_streams_set(moq_mux_container_ts_stats_Snapshot *self, moq_vec_tuple_u16_mux_container_ts_stats_Stream value, moq_status *status); uint64_t moq_mux_container_ts_stats_Snapshot_crc_error_get(const moq_mux_container_ts_stats_Snapshot *self, moq_status *status); void moq_mux_container_ts_stats_Snapshot_crc_error_set(moq_mux_container_ts_stats_Snapshot *self, uint64_t value, moq_status *status); @@ -8744,11 +8754,11 @@ void moq_mux_container_ts_stats_Snapshot_pts_error_set(moq_mux_container_ts_stat bool moq_mux_container_ts_stats_Snapshot_is_empty(const moq_mux_container_ts_stats_Snapshot *self, moq_status *status); void moq_mux_container_ts_stats_Stream_free(moq_mux_container_ts_stats_Stream *self); void moq_mux_container_ts_stats_Stream_drop(moq_mux_container_ts_stats_Stream *self, moq_status *status); -moq_mux_container_ts_stats_Stream *moq_mux_container_ts_stats_Stream_clone(const moq_mux_container_ts_stats_Stream *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Stream *moq_mux_container_ts_stats_Stream_clone(const moq_mux_container_ts_stats_Stream *self, moq_status *status); bool moq_mux_container_ts_stats_Stream_eq(const moq_mux_container_ts_stats_Stream *a, const moq_mux_container_ts_stats_Stream *b, moq_status *status); -moq_buf moq_mux_container_ts_stats_Stream_debug(const moq_mux_container_ts_stats_Stream *self, moq_status *status); -moq_mux_container_ts_stats_Stream *moq_mux_container_ts_stats_Stream_default(void); -moq_buf moq_mux_container_ts_stats_Stream_track_get(const moq_mux_container_ts_stats_Stream *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_stats_Stream_debug(const moq_mux_container_ts_stats_Stream *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Stream *moq_mux_container_ts_stats_Stream_default(void); +MOQ_MUST_USE moq_buf moq_mux_container_ts_stats_Stream_track_get(const moq_mux_container_ts_stats_Stream *self, moq_status *status); void moq_mux_container_ts_stats_Stream_track_set(moq_mux_container_ts_stats_Stream *self, moq_buf value, moq_status *status); moq_mux_container_ts_stats_Class moq_mux_container_ts_stats_Stream_class_get(const moq_mux_container_ts_stats_Stream *self, moq_status *status); void moq_mux_container_ts_stats_Stream_class_set(moq_mux_container_ts_stats_Stream *self, moq_mux_container_ts_stats_Class value, moq_status *status); @@ -8776,20 +8786,20 @@ uint64_t moq_mux_container_ts_stats_Stream_pts_error_get(const moq_mux_container void moq_mux_container_ts_stats_Stream_pts_error_set(moq_mux_container_ts_stats_Stream *self, uint64_t value, moq_status *status); void moq_mux_container_ts_stats_Export_free(moq_mux_container_ts_stats_Export *self); void moq_mux_container_ts_stats_Export_drop(moq_mux_container_ts_stats_Export *self, moq_status *status); -moq_mux_container_ts_stats_Export *moq_mux_container_ts_stats_Export_clone(const moq_mux_container_ts_stats_Export *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Export *moq_mux_container_ts_stats_Export_clone(const moq_mux_container_ts_stats_Export *self, moq_status *status); bool moq_mux_container_ts_stats_Export_eq(const moq_mux_container_ts_stats_Export *a, const moq_mux_container_ts_stats_Export *b, moq_status *status); -moq_buf moq_mux_container_ts_stats_Export_debug(const moq_mux_container_ts_stats_Export *self, moq_status *status); -moq_mux_container_ts_stats_Export *moq_mux_container_ts_stats_Export_default(void); -moq_vec_tuple_u16_mux_container_ts_stats_Stream moq_mux_container_ts_stats_Export_streams_get(const moq_mux_container_ts_stats_Export *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_mux_container_ts_stats_Export_debug(const moq_mux_container_ts_stats_Export *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Export *moq_mux_container_ts_stats_Export_default(void); +MOQ_MUST_USE moq_vec_tuple_u16_mux_container_ts_stats_Stream moq_mux_container_ts_stats_Export_streams_get(const moq_mux_container_ts_stats_Export *self, moq_status *status); void moq_mux_container_ts_stats_Export_streams_set(moq_mux_container_ts_stats_Export *self, moq_vec_tuple_u16_mux_container_ts_stats_Stream value, moq_status *status); -moq_mux_container_ts_stats_Release *moq_mux_container_ts_stats_Export_release_get(const moq_mux_container_ts_stats_Export *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Release *moq_mux_container_ts_stats_Export_release_get(const moq_mux_container_ts_stats_Export *self, moq_status *status); void moq_mux_container_ts_stats_Export_release_set(moq_mux_container_ts_stats_Export *self, moq_mux_container_ts_stats_Release *value, moq_status *status); void moq_mux_container_ts_stats_Release_free(moq_mux_container_ts_stats_Release *self); void moq_mux_container_ts_stats_Release_drop(moq_mux_container_ts_stats_Release *self, moq_status *status); -moq_mux_container_ts_stats_Release *moq_mux_container_ts_stats_Release_clone(const moq_mux_container_ts_stats_Release *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Release *moq_mux_container_ts_stats_Release_clone(const moq_mux_container_ts_stats_Release *self, moq_status *status); bool moq_mux_container_ts_stats_Release_eq(const moq_mux_container_ts_stats_Release *a, const moq_mux_container_ts_stats_Release *b, moq_status *status); -moq_buf moq_mux_container_ts_stats_Release_debug(const moq_mux_container_ts_stats_Release *self, moq_status *status); -moq_mux_container_ts_stats_Release *moq_mux_container_ts_stats_Release_default(void); +MOQ_MUST_USE moq_buf moq_mux_container_ts_stats_Release_debug(const moq_mux_container_ts_stats_Release *self, moq_status *status); +MOQ_MUST_USE moq_mux_container_ts_stats_Release *moq_mux_container_ts_stats_Release_default(void); uint64_t moq_mux_container_ts_stats_Release_dropped_get(const moq_mux_container_ts_stats_Release *self, moq_status *status); void moq_mux_container_ts_stats_Release_dropped_set(moq_mux_container_ts_stats_Release *self, uint64_t value, moq_status *status); uint64_t moq_mux_container_ts_stats_Release_trimmed_get(const moq_mux_container_ts_stats_Release *self, moq_status *status); @@ -8806,26 +8816,26 @@ uint64_t moq_mux_container_ts_stats_Release_out_of_tolerance_get(const moq_mux_c void moq_mux_container_ts_stats_Release_out_of_tolerance_set(moq_mux_container_ts_stats_Release *self, uint64_t value, moq_status *status); void moq_mux_container_ts_stats_Log_free(moq_mux_container_ts_stats_Log *self); void moq_mux_container_ts_stats_Log_drop(moq_mux_container_ts_stats_Log *self, moq_status *status); -moq_mux_container_ts_stats_Log *moq_mux_container_ts_stats_Log_default(void); +MOQ_MUST_USE moq_mux_container_ts_stats_Log *moq_mux_container_ts_stats_Log_default(void); moq_duration moq_mux_container_ts_stats_Log_INTERVAL(void); void moq_mux_container_ts_stats_Log_sample(moq_mux_container_ts_stats_Log *self, moq_mux_container_ts_stats_Snapshot *latest, moq_status *status); void moq_mux_container_ts_stats_Log_finish(const moq_mux_container_ts_stats_Log *self, const moq_mux_container_ts_stats_Snapshot *latest, moq_status *status); void moq_moq_tokio_Addrs_free(moq_moq_tokio_Addrs *self); void moq_moq_tokio_Addrs_drop(moq_moq_tokio_Addrs *self, moq_status *status); bool moq_moq_tokio_Addrs_borrowed(const moq_moq_tokio_Addrs *self); -moq_moq_tokio_Addrs *moq_moq_tokio_Addrs_clone(const moq_moq_tokio_Addrs *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_Addrs *moq_moq_tokio_Addrs_clone(const moq_moq_tokio_Addrs *self, moq_status *status); bool moq_moq_tokio_Addrs_eq(const moq_moq_tokio_Addrs *a, const moq_moq_tokio_Addrs *b, moq_status *status); -moq_buf moq_moq_tokio_Addrs_debug(const moq_moq_tokio_Addrs *self, moq_status *status); -moq_moq_tokio_Addrs *moq_moq_tokio_Addrs_new(moq_moq_tokio_connect_Addr *addr, moq_status *status); -moq_moq_tokio_Addrs *moq_moq_tokio_Addrs_or(moq_moq_tokio_Addrs *self, moq_moq_tokio_connect_Addr *addr, moq_status *status); -moq_moq_tokio_Addrs *moq_moq_tokio_Addrs_collect(moq_vec_moq_tokio_connect_Addr urls, moq_status *status); -moq_vec_moq_tokio_connect_Addr moq_moq_tokio_Addrs_as_slice(const moq_moq_tokio_Addrs *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_Addrs_debug(const moq_moq_tokio_Addrs *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_Addrs *moq_moq_tokio_Addrs_new(moq_moq_tokio_connect_Addr *addr, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_Addrs *moq_moq_tokio_Addrs_or(moq_moq_tokio_Addrs *self, moq_moq_tokio_connect_Addr *addr, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_Addrs *moq_moq_tokio_Addrs_collect(moq_vec_moq_tokio_connect_Addr urls, moq_status *status); +MOQ_MUST_USE moq_vec_moq_tokio_connect_Addr moq_moq_tokio_Addrs_as_slice(const moq_moq_tokio_Addrs *self, moq_status *status); void moq_moq_tokio_cli_Deprecated_free(moq_moq_tokio_cli_Deprecated *self); void moq_moq_tokio_cli_Deprecated_drop(moq_moq_tokio_cli_Deprecated *self, moq_status *status); -moq_moq_tokio_cli_Deprecated *moq_moq_tokio_cli_Deprecated_clone(const moq_moq_tokio_cli_Deprecated *self, moq_status *status); -moq_buf moq_moq_tokio_cli_Deprecated_to_string(const moq_moq_tokio_cli_Deprecated *self, moq_status *status); -moq_buf moq_moq_tokio_cli_Deprecated_debug(const moq_moq_tokio_cli_Deprecated *self, moq_status *status); -moq_moq_tokio_cli_Deprecated *moq_moq_tokio_cli_Deprecated_default(void); +MOQ_MUST_USE moq_moq_tokio_cli_Deprecated *moq_moq_tokio_cli_Deprecated_clone(const moq_moq_tokio_cli_Deprecated *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_cli_Deprecated_to_string(const moq_moq_tokio_cli_Deprecated *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_cli_Deprecated_debug(const moq_moq_tokio_cli_Deprecated *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_cli_Deprecated *moq_moq_tokio_cli_Deprecated_default(void); bool moq_moq_tokio_cli_Deprecated_is_empty(const moq_moq_tokio_cli_Deprecated *self, moq_status *status); void moq_moq_tokio_cli_Deprecated_extend(moq_moq_tokio_cli_Deprecated *self, moq_moq_tokio_cli_Deprecated *other, moq_status *status); void moq_moq_tokio_cli_Deprecated_flag(moq_moq_tokio_cli_Deprecated *self, moq_buf old, moq_buf env, moq_buf new_, moq_status *status); @@ -8834,62 +8844,62 @@ void moq_moq_tokio_cli_Deprecated_removed(moq_moq_tokio_cli_Deprecated *self, mo void moq_moq_tokio_cli_Deprecated_toml(moq_moq_tokio_cli_Deprecated *self, moq_buf old, moq_buf new_, moq_buf note, moq_status *status); void moq_moq_tokio_cli_Bound_free(moq_moq_tokio_cli_Bound *self); bool moq_moq_tokio_cli_Bound_borrowed(const moq_moq_tokio_cli_Bound *self); -moq_moq_tokio_cli_Bound *moq_moq_tokio_cli_Bound_clone(const moq_moq_tokio_cli_Bound *self); +MOQ_MUST_USE moq_moq_tokio_cli_Bound *moq_moq_tokio_cli_Bound_clone(const moq_moq_tokio_cli_Bound *self); bool moq_moq_tokio_cli_Bound_eq(const moq_moq_tokio_cli_Bound *a, const moq_moq_tokio_cli_Bound *b); uint64_t moq_moq_tokio_cli_Bound_hash(const moq_moq_tokio_cli_Bound *self); -moq_buf moq_moq_tokio_cli_Bound_to_string(const moq_moq_tokio_cli_Bound *self); -moq_buf moq_moq_tokio_cli_Bound_debug(const moq_moq_tokio_cli_Bound *self); -moq_moq_tokio_cli_Bound *moq_moq_tokio_cli_Bound_NONE(void); +MOQ_MUST_USE moq_buf moq_moq_tokio_cli_Bound_to_string(const moq_moq_tokio_cli_Bound *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_cli_Bound_debug(const moq_moq_tokio_cli_Bound *self); +MOQ_MUST_USE moq_moq_tokio_cli_Bound *moq_moq_tokio_cli_Bound_NONE(void); void moq_moq_tokio_tcp_TlsAcceptor_free(moq_moq_tokio_tcp_TlsAcceptor *self); -moq_moq_tokio_tcp_TlsAcceptor *moq_moq_tokio_tcp_TlsAcceptor_clone(const moq_moq_tokio_tcp_TlsAcceptor *self); -moq_rustls_ServerConfig *moq_moq_tokio_tcp_TlsAcceptor_config(const moq_moq_tokio_tcp_TlsAcceptor *self); +MOQ_MUST_USE moq_moq_tokio_tcp_TlsAcceptor *moq_moq_tokio_tcp_TlsAcceptor_clone(const moq_moq_tokio_tcp_TlsAcceptor *self); +MOQ_MUST_USE moq_rustls_ServerConfig *moq_moq_tokio_tcp_TlsAcceptor_config(const moq_moq_tokio_tcp_TlsAcceptor *self); bool moq_moq_tokio_tcp_TlsAcceptor_offered(const moq_moq_tokio_tcp_TlsAcceptor *self, moq_vec_bytes alpns); void moq_moq_tokio_accept_Health_free(moq_moq_tokio_accept_Health *self); bool moq_moq_tokio_accept_Health_borrowed(const moq_moq_tokio_accept_Health *self); -moq_moq_tokio_accept_Health *moq_moq_tokio_accept_Health_clone(const moq_moq_tokio_accept_Health *self); -moq_buf moq_moq_tokio_accept_Health_debug(const moq_moq_tokio_accept_Health *self); -moq_moq_tokio_accept_Health *moq_moq_tokio_accept_Health_new(moq_buf listener); -moq_buf moq_moq_tokio_accept_Health_listener(const moq_moq_tokio_accept_Health *self); +MOQ_MUST_USE moq_moq_tokio_accept_Health *moq_moq_tokio_accept_Health_clone(const moq_moq_tokio_accept_Health *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_accept_Health_debug(const moq_moq_tokio_accept_Health *self); +MOQ_MUST_USE moq_moq_tokio_accept_Health *moq_moq_tokio_accept_Health_new(moq_buf listener); +MOQ_MUST_USE moq_buf moq_moq_tokio_accept_Health_listener(const moq_moq_tokio_accept_Health *self); void moq_moq_tokio_accept_Health_accepted(const moq_moq_tokio_accept_Health *self); uint64_t moq_moq_tokio_accept_Health_failures(const moq_moq_tokio_accept_Health *self, moq_moq_tokio_accept_Failure failure); moq_option_duration moq_moq_tokio_accept_Health_stalled(const moq_moq_tokio_accept_Health *self); void moq_moq_json_Timed_Catalog_free(moq_moq_json_Timed_Catalog *self); void moq_moq_json_Timed_Catalog_drop(moq_moq_json_Timed_Catalog *self, moq_status *status); -moq_moq_json_Timed_Catalog *moq_moq_json_Timed_Catalog_clone(const moq_moq_json_Timed_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_moq_json_Timed_Catalog *moq_moq_json_Timed_Catalog_clone(const moq_moq_json_Timed_Catalog *self, moq_status *status); bool moq_moq_json_Timed_Catalog_eq(const moq_moq_json_Timed_Catalog *a, const moq_moq_json_Timed_Catalog *b, moq_status *status); -moq_buf moq_moq_json_Timed_Catalog_debug(const moq_moq_json_Timed_Catalog *self, moq_status *status); -moq_hang_Catalog *moq_moq_json_Timed_Catalog_value_get(const moq_moq_json_Timed_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_json_Timed_Catalog_debug(const moq_moq_json_Timed_Catalog *self, moq_status *status); +MOQ_MUST_USE moq_hang_Catalog *moq_moq_json_Timed_Catalog_value_get(const moq_moq_json_Timed_Catalog *self, moq_status *status); void moq_moq_json_Timed_Catalog_value_set(moq_moq_json_Timed_Catalog *self, moq_hang_Catalog *value, moq_status *status); moq_Timestamp moq_moq_json_Timed_Catalog_at_get(const moq_moq_json_Timed_Catalog *self, moq_status *status); void moq_moq_json_Timed_Catalog_at_set(moq_moq_json_Timed_Catalog *self, moq_Timestamp value, moq_status *status); -moq_moq_json_Timed_Catalog *moq_moq_json_Timed_Catalog_new(moq_hang_Catalog *value, moq_Timestamp at, moq_status *status); +MOQ_MUST_USE moq_moq_json_Timed_Catalog *moq_moq_json_Timed_Catalog_new(moq_hang_Catalog *value, moq_Timestamp at, moq_status *status); void moq_moq_json_Timed_Json_free(moq_moq_json_Timed_Json *self); void moq_moq_json_Timed_Json_drop(moq_moq_json_Timed_Json *self, moq_status *status); -moq_moq_json_Timed_Json *moq_moq_json_Timed_Json_clone(const moq_moq_json_Timed_Json *self, moq_status *status); +MOQ_MUST_USE moq_moq_json_Timed_Json *moq_moq_json_Timed_Json_clone(const moq_moq_json_Timed_Json *self, moq_status *status); bool moq_moq_json_Timed_Json_eq(const moq_moq_json_Timed_Json *a, const moq_moq_json_Timed_Json *b, moq_status *status); -moq_buf moq_moq_json_Timed_Json_debug(const moq_moq_json_Timed_Json *self, moq_status *status); -moq_Json *moq_moq_json_Timed_Json_value_get(const moq_moq_json_Timed_Json *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_json_Timed_Json_debug(const moq_moq_json_Timed_Json *self, moq_status *status); +MOQ_MUST_USE moq_Json *moq_moq_json_Timed_Json_value_get(const moq_moq_json_Timed_Json *self, moq_status *status); void moq_moq_json_Timed_Json_value_set(moq_moq_json_Timed_Json *self, moq_Json *value, moq_status *status); moq_Timestamp moq_moq_json_Timed_Json_at_get(const moq_moq_json_Timed_Json *self, moq_status *status); void moq_moq_json_Timed_Json_at_set(moq_moq_json_Timed_Json *self, moq_Timestamp value, moq_status *status); -moq_moq_json_Timed_Json *moq_moq_json_Timed_Json_new(moq_Json *value, moq_Timestamp at, moq_status *status); +MOQ_MUST_USE moq_moq_json_Timed_Json *moq_moq_json_Timed_Json_new(moq_Json *value, moq_Timestamp at, moq_status *status); void moq_rustls_ClientConfig_free(moq_rustls_ClientConfig *self); void moq_rustls_ClientConfig_drop(moq_rustls_ClientConfig *self, moq_status *status); -moq_rustls_ClientConfig *moq_rustls_ClientConfig_clone(const moq_rustls_ClientConfig *self, moq_status *status); -moq_buf moq_rustls_ClientConfig_debug(const moq_rustls_ClientConfig *self, moq_status *status); -moq_vec_bytes moq_rustls_ClientConfig_alpn_protocols_get(const moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_rustls_ClientConfig *moq_rustls_ClientConfig_clone(const moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_rustls_ClientConfig_debug(const moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_vec_bytes moq_rustls_ClientConfig_alpn_protocols_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_alpn_protocols_set(moq_rustls_ClientConfig *self, moq_vec_bytes value, moq_status *status); bool moq_rustls_ClientConfig_check_selected_alpn_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_check_selected_alpn_set(moq_rustls_ClientConfig *self, bool value, moq_status *status); -moq_rustls_client_Resumption *moq_rustls_ClientConfig_resumption_get(const moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_rustls_client_Resumption *moq_rustls_ClientConfig_resumption_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_resumption_set(moq_rustls_ClientConfig *self, moq_rustls_client_Resumption *value, moq_status *status); moq_option_usize moq_rustls_ClientConfig_max_fragment_size_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_max_fragment_size_set(moq_rustls_ClientConfig *self, moq_option_usize value, moq_status *status); -moq_rustls_ResolvesClientCert *moq_rustls_ClientConfig_client_auth_cert_resolver_get(const moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_rustls_ResolvesClientCert *moq_rustls_ClientConfig_client_auth_cert_resolver_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_client_auth_cert_resolver_set(moq_rustls_ClientConfig *self, moq_rustls_ResolvesClientCert *value, moq_status *status); bool moq_rustls_ClientConfig_enable_sni_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_enable_sni_set(moq_rustls_ClientConfig *self, bool value, moq_status *status); -moq_rustls_KeyLog *moq_rustls_ClientConfig_key_log_get(const moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_rustls_KeyLog *moq_rustls_ClientConfig_key_log_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_key_log_set(moq_rustls_ClientConfig *self, moq_rustls_KeyLog *value, moq_status *status); bool moq_rustls_ClientConfig_enable_secret_extraction_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_enable_secret_extraction_set(moq_rustls_ClientConfig *self, bool value, moq_status *status); @@ -8897,44 +8907,44 @@ bool moq_rustls_ClientConfig_enable_early_data_get(const moq_rustls_ClientConfig void moq_rustls_ClientConfig_enable_early_data_set(moq_rustls_ClientConfig *self, bool value, moq_status *status); bool moq_rustls_ClientConfig_require_ems_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_require_ems_set(moq_rustls_ClientConfig *self, bool value, moq_status *status); -moq_rustls_TimeProvider *moq_rustls_ClientConfig_time_provider_get(const moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_rustls_TimeProvider *moq_rustls_ClientConfig_time_provider_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_time_provider_set(moq_rustls_ClientConfig *self, moq_rustls_TimeProvider *value, moq_status *status); -moq_vec_rustls_CertDecompressor moq_rustls_ClientConfig_cert_decompressors_get(const moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_vec_rustls_CertDecompressor moq_rustls_ClientConfig_cert_decompressors_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_cert_decompressors_set(moq_rustls_ClientConfig *self, moq_vec_rustls_CertDecompressor value, moq_status *status); -moq_vec_rustls_CertCompressor moq_rustls_ClientConfig_cert_compressors_get(const moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_vec_rustls_CertCompressor moq_rustls_ClientConfig_cert_compressors_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_cert_compressors_set(moq_rustls_ClientConfig *self, moq_vec_rustls_CertCompressor value, moq_status *status); -moq_rustls_CompressionCache *moq_rustls_ClientConfig_cert_compression_cache_get(const moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_rustls_CompressionCache *moq_rustls_ClientConfig_cert_compression_cache_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_cert_compression_cache_set(moq_rustls_ClientConfig *self, moq_rustls_CompressionCache *value, moq_status *status); moq_option_rustls_client_TicketRequest moq_rustls_ClientConfig_send_ticket_request_get(const moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_ClientConfig_send_ticket_request_set(moq_rustls_ClientConfig *self, moq_option_rustls_client_TicketRequest value, moq_status *status); bool moq_rustls_ClientConfig_fips(const moq_rustls_ClientConfig *self, moq_status *status); -moq_rustls_CryptoProvider *moq_rustls_ClientConfig_crypto_provider(const moq_rustls_ClientConfig *self, moq_status *status); -moq_rustls_client_danger_DangerousClientConfig *moq_rustls_ClientConfig_dangerous(moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_rustls_CryptoProvider *moq_rustls_ClientConfig_crypto_provider(const moq_rustls_ClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_rustls_client_danger_DangerousClientConfig *moq_rustls_ClientConfig_dangerous(moq_rustls_ClientConfig *self, moq_status *status); void moq_rustls_RootCertStore_free(moq_rustls_RootCertStore *self); void moq_rustls_RootCertStore_drop(moq_rustls_RootCertStore *self, moq_status *status); -moq_rustls_RootCertStore *moq_rustls_RootCertStore_clone(const moq_rustls_RootCertStore *self, moq_status *status); -moq_buf moq_rustls_RootCertStore_debug(const moq_rustls_RootCertStore *self, moq_status *status); -moq_vec_rustls_pki_types_TrustAnchor moq_rustls_RootCertStore_roots_get(const moq_rustls_RootCertStore *self, moq_status *status); +MOQ_MUST_USE moq_rustls_RootCertStore *moq_rustls_RootCertStore_clone(const moq_rustls_RootCertStore *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_rustls_RootCertStore_debug(const moq_rustls_RootCertStore *self, moq_status *status); +MOQ_MUST_USE moq_vec_rustls_pki_types_TrustAnchor moq_rustls_RootCertStore_roots_get(const moq_rustls_RootCertStore *self, moq_status *status); void moq_rustls_RootCertStore_roots_set(moq_rustls_RootCertStore *self, moq_vec_rustls_pki_types_TrustAnchor value, moq_status *status); -moq_rustls_RootCertStore *moq_rustls_RootCertStore_empty(void); +MOQ_MUST_USE moq_rustls_RootCertStore *moq_rustls_RootCertStore_empty(void); void moq_rustls_RootCertStore_add_parsable_certificates(moq_rustls_RootCertStore *self, moq_vec_rustls_pki_types_CertificateDer der_certs, size_t *out0, size_t *out1, moq_status *status); -bool moq_rustls_RootCertStore_add(moq_rustls_RootCertStore *self, moq_rustls_pki_types_CertificateDer *der, moq_buf *err, moq_status *status); -moq_vec_rustls_DistinguishedName moq_rustls_RootCertStore_subjects(const moq_rustls_RootCertStore *self, moq_status *status); +MOQ_MUST_USE bool moq_rustls_RootCertStore_add(moq_rustls_RootCertStore *self, moq_rustls_pki_types_CertificateDer *der, moq_buf *err, moq_status *status); +MOQ_MUST_USE moq_vec_rustls_DistinguishedName moq_rustls_RootCertStore_subjects(const moq_rustls_RootCertStore *self, moq_status *status); bool moq_rustls_RootCertStore_is_empty(const moq_rustls_RootCertStore *self, moq_status *status); size_t moq_rustls_RootCertStore_len(const moq_rustls_RootCertStore *self, moq_status *status); void moq_rustls_pki_types_CertificateDer_free(moq_rustls_pki_types_CertificateDer *self); void moq_rustls_pki_types_CertificateDer_drop(moq_rustls_pki_types_CertificateDer *self, moq_status *status); bool moq_rustls_pki_types_CertificateDer_borrowed(const moq_rustls_pki_types_CertificateDer *self); -moq_rustls_pki_types_CertificateDer *moq_rustls_pki_types_CertificateDer_clone(const moq_rustls_pki_types_CertificateDer *self, moq_status *status); +MOQ_MUST_USE moq_rustls_pki_types_CertificateDer *moq_rustls_pki_types_CertificateDer_clone(const moq_rustls_pki_types_CertificateDer *self, moq_status *status); bool moq_rustls_pki_types_CertificateDer_eq(const moq_rustls_pki_types_CertificateDer *a, const moq_rustls_pki_types_CertificateDer *b, moq_status *status); uint64_t moq_rustls_pki_types_CertificateDer_hash(const moq_rustls_pki_types_CertificateDer *self, moq_status *status); -moq_buf moq_rustls_pki_types_CertificateDer_debug(const moq_rustls_pki_types_CertificateDer *self, moq_status *status); -moq_rustls_pki_types_CertificateDer *moq_rustls_pki_types_CertificateDer_from_slice(moq_buf bytes); -moq_rustls_pki_types_CertificateDer *moq_rustls_pki_types_CertificateDer_into_owned(moq_rustls_pki_types_CertificateDer *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_rustls_pki_types_CertificateDer_debug(const moq_rustls_pki_types_CertificateDer *self, moq_status *status); +MOQ_MUST_USE moq_rustls_pki_types_CertificateDer *moq_rustls_pki_types_CertificateDer_from_slice(moq_buf bytes); +MOQ_MUST_USE moq_rustls_pki_types_CertificateDer *moq_rustls_pki_types_CertificateDer_into_owned(moq_rustls_pki_types_CertificateDer *self, moq_status *status); void moq_moq_tokio_connect_Resolved_free(moq_moq_tokio_connect_Resolved *self); void moq_moq_tokio_connect_Resolved_drop(moq_moq_tokio_connect_Resolved *self, moq_status *status); -moq_moq_tokio_connect_Resolved *moq_moq_tokio_connect_Resolved_clone(const moq_moq_tokio_connect_Resolved *self, moq_status *status); -moq_buf moq_moq_tokio_connect_Resolved_debug(const moq_moq_tokio_connect_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_connect_Resolved *moq_moq_tokio_connect_Resolved_clone(const moq_moq_tokio_connect_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_connect_Resolved_debug(const moq_moq_tokio_connect_Resolved *self, moq_status *status); moq_socket_addr moq_moq_tokio_connect_Resolved_bind_get(const moq_moq_tokio_connect_Resolved *self, moq_status *status); void moq_moq_tokio_connect_Resolved_bind_set(moq_moq_tokio_connect_Resolved *self, moq_socket_addr value, moq_status *status); moq_duration moq_moq_tokio_connect_Resolved_race_get(const moq_moq_tokio_connect_Resolved *self, moq_status *status); @@ -8945,104 +8955,104 @@ moq_option_duration moq_moq_tokio_connect_Resolved_timeout_get(const moq_moq_tok void moq_moq_tokio_connect_Resolved_timeout_set(moq_moq_tokio_connect_Resolved *self, moq_option_duration value, moq_status *status); void moq_moq_tokio_connection_Handover_free(moq_moq_tokio_connection_Handover *self); void moq_moq_tokio_connection_Handover_drop(moq_moq_tokio_connection_Handover *self, moq_status *status); -moq_moq_tokio_connection_Handover *moq_moq_tokio_connection_Handover_clone(const moq_moq_tokio_connection_Handover *self, moq_status *status); -moq_buf moq_moq_tokio_connection_Handover_debug(const moq_moq_tokio_connection_Handover *self, moq_status *status); -moq_moq_tokio_connection_Handover *moq_moq_tokio_connection_Handover_default(void); +MOQ_MUST_USE moq_moq_tokio_connection_Handover *moq_moq_tokio_connection_Handover_clone(const moq_moq_tokio_connection_Handover *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_connection_Handover_debug(const moq_moq_tokio_connection_Handover *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_connection_Handover *moq_moq_tokio_connection_Handover_default(void); moq_moq_tokio_Redirect moq_moq_tokio_connection_Handover_redirect_get(const moq_moq_tokio_connection_Handover *self, moq_status *status); void moq_moq_tokio_connection_Handover_redirect_set(moq_moq_tokio_connection_Handover *self, moq_moq_tokio_Redirect value, moq_status *status); -moq_tokio_Duration *moq_moq_tokio_connection_Handover_handover_get(const moq_moq_tokio_connection_Handover *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Duration *moq_moq_tokio_connection_Handover_handover_get(const moq_moq_tokio_connection_Handover *self, moq_status *status); void moq_moq_tokio_connection_Handover_handover_set(moq_moq_tokio_connection_Handover *self, const moq_tokio_Duration *value, moq_status *status); void moq_moq_tokio_websocket_Config_free(moq_moq_tokio_websocket_Config *self); void moq_moq_tokio_websocket_Config_drop(moq_moq_tokio_websocket_Config *self, moq_status *status); -moq_moq_tokio_websocket_Config *moq_moq_tokio_websocket_Config_clone(const moq_moq_tokio_websocket_Config *self, moq_status *status); -moq_buf moq_moq_tokio_websocket_Config_debug(const moq_moq_tokio_websocket_Config *self, moq_status *status); -moq_moq_tokio_websocket_Config *moq_moq_tokio_websocket_Config_default(void); +MOQ_MUST_USE moq_moq_tokio_websocket_Config *moq_moq_tokio_websocket_Config_clone(const moq_moq_tokio_websocket_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_websocket_Config_debug(const moq_moq_tokio_websocket_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_websocket_Config *moq_moq_tokio_websocket_Config_default(void); moq_option_bool moq_moq_tokio_websocket_Config_enabled_get(const moq_moq_tokio_websocket_Config *self, moq_status *status); void moq_moq_tokio_websocket_Config_enabled_set(moq_moq_tokio_websocket_Config *self, moq_option_bool value, moq_status *status); -moq_tokio_Duration *moq_moq_tokio_websocket_Config_delay_get(const moq_moq_tokio_websocket_Config *self, moq_status *status); +MOQ_MUST_USE moq_tokio_Duration *moq_moq_tokio_websocket_Config_delay_get(const moq_moq_tokio_websocket_Config *self, moq_status *status); void moq_moq_tokio_websocket_Config_delay_set(moq_moq_tokio_websocket_Config *self, const moq_tokio_Duration *value, moq_status *status); -moq_moq_tokio_websocket_Resolved *moq_moq_tokio_websocket_Config_resolve(const moq_moq_tokio_websocket_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_websocket_Resolved *moq_moq_tokio_websocket_Config_resolve(const moq_moq_tokio_websocket_Config *self, moq_status *status); void moq_moq_tokio_connection_Observation_free(moq_moq_tokio_connection_Observation *self); void moq_moq_tokio_connection_Observation_drop(moq_moq_tokio_connection_Observation *self, moq_status *status); -moq_moq_tokio_connection_Observation *moq_moq_tokio_connection_Observation_clone(const moq_moq_tokio_connection_Observation *self, moq_status *status); -moq_buf moq_moq_tokio_connection_Observation_debug(const moq_moq_tokio_connection_Observation *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_connection_Observation *moq_moq_tokio_connection_Observation_clone(const moq_moq_tokio_connection_Observation *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_connection_Observation_debug(const moq_moq_tokio_connection_Observation *self, moq_status *status); uint64_t moq_moq_tokio_connection_Observation_revision_get(const moq_moq_tokio_connection_Observation *self, moq_status *status); void moq_moq_tokio_connection_Observation_revision_set(moq_moq_tokio_connection_Observation *self, uint64_t value, moq_status *status); uint64_t moq_moq_tokio_connection_Observation_connects_get(const moq_moq_tokio_connection_Observation *self, moq_status *status); void moq_moq_tokio_connection_Observation_connects_set(moq_moq_tokio_connection_Observation *self, uint64_t value, moq_status *status); moq_option_clock_Instant moq_moq_tokio_connection_Observation_last_connected_get(const moq_moq_tokio_connection_Observation *self, moq_status *status); void moq_moq_tokio_connection_Observation_last_connected_set(moq_moq_tokio_connection_Observation *self, moq_option_clock_Instant value, moq_status *status); -moq_moq_tokio_connection_Phase *moq_moq_tokio_connection_Observation_phase_get(const moq_moq_tokio_connection_Observation *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_connection_Phase *moq_moq_tokio_connection_Observation_phase_get(const moq_moq_tokio_connection_Observation *self, moq_status *status); void moq_moq_tokio_connection_Observation_phase_set(moq_moq_tokio_connection_Observation *self, moq_moq_tokio_connection_Phase *value, moq_status *status); void moq_moq_tokio_connection_Snapshot_free(moq_moq_tokio_connection_Snapshot *self); void moq_moq_tokio_connection_Snapshot_drop(moq_moq_tokio_connection_Snapshot *self, moq_status *status); -moq_session_Stats *moq_moq_tokio_connection_Snapshot_stats_get(const moq_moq_tokio_connection_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_session_Stats *moq_moq_tokio_connection_Snapshot_stats_get(const moq_moq_tokio_connection_Snapshot *self, moq_status *status); void moq_moq_tokio_connection_Snapshot_stats_set(moq_moq_tokio_connection_Snapshot *self, const moq_session_Stats *value, moq_status *status); -moq_Version *moq_moq_tokio_connection_Snapshot_version_get(const moq_moq_tokio_connection_Snapshot *self, moq_status *status); +MOQ_MUST_USE moq_Version *moq_moq_tokio_connection_Snapshot_version_get(const moq_moq_tokio_connection_Snapshot *self, moq_status *status); void moq_moq_tokio_connection_Snapshot_version_set(moq_moq_tokio_connection_Snapshot *self, const moq_Version *value, moq_status *status); void moq_moq_tokio_listen_Resolved_free(moq_moq_tokio_listen_Resolved *self); void moq_moq_tokio_listen_Resolved_drop(moq_moq_tokio_listen_Resolved *self, moq_status *status); -moq_moq_tokio_listen_Resolved *moq_moq_tokio_listen_Resolved_clone(const moq_moq_tokio_listen_Resolved *self, moq_status *status); -moq_buf moq_moq_tokio_listen_Resolved_debug(const moq_moq_tokio_listen_Resolved *self, moq_status *status); -moq_option_tokio_listen_Bind moq_moq_tokio_listen_Resolved_bind_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_listen_Resolved *moq_moq_tokio_listen_Resolved_clone(const moq_moq_tokio_listen_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_listen_Resolved_debug(const moq_moq_tokio_listen_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_option_tokio_listen_Bind moq_moq_tokio_listen_Resolved_bind_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); void moq_moq_tokio_listen_Resolved_bind_set(moq_moq_tokio_listen_Resolved *self, moq_option_tokio_listen_Bind value, moq_status *status); -moq_Versions *moq_moq_tokio_listen_Resolved_versions_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_Versions *moq_moq_tokio_listen_Resolved_versions_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); void moq_moq_tokio_listen_Resolved_versions_set(moq_moq_tokio_listen_Resolved *self, moq_Versions *value, moq_status *status); -moq_buf moq_moq_tokio_listen_Resolved_implementation_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_listen_Resolved_implementation_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); void moq_moq_tokio_listen_Resolved_implementation_set(moq_moq_tokio_listen_Resolved *self, moq_buf value, moq_status *status); moq_option_duration moq_moq_tokio_listen_Resolved_timeout_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); void moq_moq_tokio_listen_Resolved_timeout_set(moq_moq_tokio_listen_Resolved *self, moq_option_duration value, moq_status *status); -moq_tokio_tls_Listen *moq_moq_tokio_listen_Resolved_tls_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_tokio_tls_Listen *moq_moq_tokio_listen_Resolved_tls_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); void moq_moq_tokio_listen_Resolved_tls_set(moq_moq_tokio_listen_Resolved *self, moq_tokio_tls_Listen *value, moq_status *status); moq_option_socket_addr_v4 moq_moq_tokio_listen_Resolved_preferred_v4_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); void moq_moq_tokio_listen_Resolved_preferred_v4_set(moq_moq_tokio_listen_Resolved *self, moq_option_socket_addr_v4 value, moq_status *status); moq_option_socket_addr_v6 moq_moq_tokio_listen_Resolved_preferred_v6_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); void moq_moq_tokio_listen_Resolved_preferred_v6_set(moq_moq_tokio_listen_Resolved *self, moq_option_socket_addr_v6 value, moq_status *status); -moq_moq_tokio_listen_LoadBalancer *moq_moq_tokio_listen_Resolved_lb_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_listen_LoadBalancer *moq_moq_tokio_listen_Resolved_lb_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); void moq_moq_tokio_listen_Resolved_lb_set(moq_moq_tokio_listen_Resolved *self, moq_moq_tokio_listen_LoadBalancer *value, moq_status *status); -moq_buf moq_moq_tokio_listen_Resolved_reset_secret_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_listen_Resolved_reset_secret_get(const moq_moq_tokio_listen_Resolved *self, moq_status *status); void moq_moq_tokio_listen_Resolved_reset_secret_set(moq_moq_tokio_listen_Resolved *self, moq_buf value, moq_status *status); void moq_moq_tokio_tcp_Config_free(moq_moq_tokio_tcp_Config *self); void moq_moq_tokio_tcp_Config_drop(moq_moq_tokio_tcp_Config *self, moq_status *status); -moq_moq_tokio_tcp_Config *moq_moq_tokio_tcp_Config_clone(const moq_moq_tokio_tcp_Config *self, moq_status *status); -moq_buf moq_moq_tokio_tcp_Config_debug(const moq_moq_tokio_tcp_Config *self, moq_status *status); -moq_moq_tokio_tcp_Config *moq_moq_tokio_tcp_Config_default(void); +MOQ_MUST_USE moq_moq_tokio_tcp_Config *moq_moq_tokio_tcp_Config_clone(const moq_moq_tokio_tcp_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_tcp_Config_debug(const moq_moq_tokio_tcp_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_tcp_Config *moq_moq_tokio_tcp_Config_default(void); moq_option_socket_addr moq_moq_tokio_tcp_Config_bind_get(const moq_moq_tokio_tcp_Config *self, moq_status *status); void moq_moq_tokio_tcp_Config_bind_set(moq_moq_tokio_tcp_Config *self, moq_option_socket_addr value, moq_status *status); moq_option_bool moq_moq_tokio_tcp_Config_tls_get(const moq_moq_tokio_tcp_Config *self, moq_status *status); void moq_moq_tokio_tcp_Config_tls_set(moq_moq_tokio_tcp_Config *self, moq_option_bool value, moq_status *status); void moq_moq_tokio_unix_Config_free(moq_moq_tokio_unix_Config *self); void moq_moq_tokio_unix_Config_drop(moq_moq_tokio_unix_Config *self, moq_status *status); -moq_moq_tokio_unix_Config *moq_moq_tokio_unix_Config_clone(const moq_moq_tokio_unix_Config *self, moq_status *status); -moq_buf moq_moq_tokio_unix_Config_debug(const moq_moq_tokio_unix_Config *self, moq_status *status); -moq_moq_tokio_unix_Config *moq_moq_tokio_unix_Config_default(void); -moq_buf moq_moq_tokio_unix_Config_bind_get(const moq_moq_tokio_unix_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_unix_Config *moq_moq_tokio_unix_Config_clone(const moq_moq_tokio_unix_Config *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_unix_Config_debug(const moq_moq_tokio_unix_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_unix_Config *moq_moq_tokio_unix_Config_default(void); +MOQ_MUST_USE moq_buf moq_moq_tokio_unix_Config_bind_get(const moq_moq_tokio_unix_Config *self, moq_status *status); void moq_moq_tokio_unix_Config_bind_set(moq_moq_tokio_unix_Config *self, moq_buf value, moq_status *status); -moq_moq_tokio_unix_Allow *moq_moq_tokio_unix_Config_allow_get(const moq_moq_tokio_unix_Config *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_unix_Allow *moq_moq_tokio_unix_Config_allow_get(const moq_moq_tokio_unix_Config *self, moq_status *status); void moq_moq_tokio_unix_Config_allow_set(moq_moq_tokio_unix_Config *self, moq_moq_tokio_unix_Allow *value, moq_status *status); void moq_moq_tokio_listen_LoadBalancer_free(moq_moq_tokio_listen_LoadBalancer *self); void moq_moq_tokio_listen_LoadBalancer_drop(moq_moq_tokio_listen_LoadBalancer *self, moq_status *status); -moq_moq_tokio_listen_LoadBalancer *moq_moq_tokio_listen_LoadBalancer_clone(const moq_moq_tokio_listen_LoadBalancer *self, moq_status *status); -moq_buf moq_moq_tokio_listen_LoadBalancer_debug(const moq_moq_tokio_listen_LoadBalancer *self, moq_status *status); -moq_moq_tokio_listen_LoadBalancer *moq_moq_tokio_listen_LoadBalancer_default(void); -moq_moq_tokio_quic_ServerId *moq_moq_tokio_listen_LoadBalancer_id_get(const moq_moq_tokio_listen_LoadBalancer *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_listen_LoadBalancer *moq_moq_tokio_listen_LoadBalancer_clone(const moq_moq_tokio_listen_LoadBalancer *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_listen_LoadBalancer_debug(const moq_moq_tokio_listen_LoadBalancer *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_listen_LoadBalancer *moq_moq_tokio_listen_LoadBalancer_default(void); +MOQ_MUST_USE moq_moq_tokio_quic_ServerId *moq_moq_tokio_listen_LoadBalancer_id_get(const moq_moq_tokio_listen_LoadBalancer *self, moq_status *status); void moq_moq_tokio_listen_LoadBalancer_id_set(moq_moq_tokio_listen_LoadBalancer *self, moq_moq_tokio_quic_ServerId *value, moq_status *status); moq_option_usize moq_moq_tokio_listen_LoadBalancer_nonce_get(const moq_moq_tokio_listen_LoadBalancer *self, moq_status *status); void moq_moq_tokio_listen_LoadBalancer_nonce_set(moq_moq_tokio_listen_LoadBalancer *self, moq_option_usize value, moq_status *status); -moq_moq_tokio_listen_Forward *moq_moq_tokio_listen_LoadBalancer_forward_get(const moq_moq_tokio_listen_LoadBalancer *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_listen_Forward *moq_moq_tokio_listen_LoadBalancer_forward_get(const moq_moq_tokio_listen_LoadBalancer *self, moq_status *status); void moq_moq_tokio_listen_LoadBalancer_forward_set(moq_moq_tokio_listen_LoadBalancer *self, moq_moq_tokio_listen_Forward *value, moq_status *status); void moq_moq_tokio_listen_Reset_free(moq_moq_tokio_listen_Reset *self); void moq_moq_tokio_listen_Reset_drop(moq_moq_tokio_listen_Reset *self, moq_status *status); -moq_moq_tokio_listen_Reset *moq_moq_tokio_listen_Reset_clone(const moq_moq_tokio_listen_Reset *self, moq_status *status); -moq_buf moq_moq_tokio_listen_Reset_debug(const moq_moq_tokio_listen_Reset *self, moq_status *status); -moq_moq_tokio_listen_Reset *moq_moq_tokio_listen_Reset_default(void); -moq_buf moq_moq_tokio_listen_Reset_secret_get(const moq_moq_tokio_listen_Reset *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_listen_Reset *moq_moq_tokio_listen_Reset_clone(const moq_moq_tokio_listen_Reset *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_listen_Reset_debug(const moq_moq_tokio_listen_Reset *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_listen_Reset *moq_moq_tokio_listen_Reset_default(void); +MOQ_MUST_USE moq_buf moq_moq_tokio_listen_Reset_secret_get(const moq_moq_tokio_listen_Reset *self, moq_status *status); void moq_moq_tokio_listen_Reset_secret_set(moq_moq_tokio_listen_Reset *self, moq_buf value, moq_status *status); void moq_moq_tokio_quic_Resolved_free(moq_moq_tokio_quic_Resolved *self); void moq_moq_tokio_quic_Resolved_drop(moq_moq_tokio_quic_Resolved *self, moq_status *status); -moq_moq_tokio_quic_Resolved *moq_moq_tokio_quic_Resolved_clone(const moq_moq_tokio_quic_Resolved *self, moq_status *status); -moq_buf moq_moq_tokio_quic_Resolved_debug(const moq_moq_tokio_quic_Resolved *self, moq_status *status); -moq_moq_tokio_quic_Resolved *moq_moq_tokio_quic_Resolved_default(void); +MOQ_MUST_USE moq_moq_tokio_quic_Resolved *moq_moq_tokio_quic_Resolved_clone(const moq_moq_tokio_quic_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_quic_Resolved_debug(const moq_moq_tokio_quic_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_quic_Resolved *moq_moq_tokio_quic_Resolved_default(void); uint64_t moq_moq_tokio_quic_Resolved_max_streams_get(const moq_moq_tokio_quic_Resolved *self, moq_status *status); void moq_moq_tokio_quic_Resolved_max_streams_set(moq_moq_tokio_quic_Resolved *self, uint64_t value, moq_status *status); moq_option_bool moq_moq_tokio_quic_Resolved_gso_get(const moq_moq_tokio_quic_Resolved *self, moq_status *status); @@ -9061,49 +9071,49 @@ uint64_t moq_moq_tokio_quic_Resolved_stream_receive_window_get(const moq_moq_tok void moq_moq_tokio_quic_Resolved_stream_receive_window_set(moq_moq_tokio_quic_Resolved *self, uint64_t value, moq_status *status); uint64_t moq_moq_tokio_quic_Resolved_send_window_get(const moq_moq_tokio_quic_Resolved *self, moq_status *status); void moq_moq_tokio_quic_Resolved_send_window_set(moq_moq_tokio_quic_Resolved *self, uint64_t value, moq_status *status); -moq_buf moq_moq_tokio_quic_Resolved_qlog_get(const moq_moq_tokio_quic_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_quic_Resolved_qlog_get(const moq_moq_tokio_quic_Resolved *self, moq_status *status); void moq_moq_tokio_quic_Resolved_qlog_set(moq_moq_tokio_quic_Resolved *self, moq_buf value, moq_status *status); -moq_buf moq_moq_tokio_quic_Resolved_keylog_get(const moq_moq_tokio_quic_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_quic_Resolved_keylog_get(const moq_moq_tokio_quic_Resolved *self, moq_status *status); void moq_moq_tokio_quic_Resolved_keylog_set(moq_moq_tokio_quic_Resolved *self, moq_buf value, moq_status *status); moq_duration moq_moq_tokio_quic_Resolved_keep_alive_interval(const moq_moq_tokio_quic_Resolved *self, moq_status *status); -moq_moq_quic_Limits *moq_moq_tokio_quic_Resolved_limits(const moq_moq_tokio_quic_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_moq_quic_Limits *moq_moq_tokio_quic_Resolved_limits(const moq_moq_tokio_quic_Resolved *self, moq_status *status); void moq_moq_tokio_websocket_Listener_free(moq_moq_tokio_websocket_Listener *self); void moq_moq_tokio_websocket_Listener_drop(moq_moq_tokio_websocket_Listener *self, moq_status *status); typedef struct moq_moq_tokio_websocket_Listener_bind_future moq_moq_tokio_websocket_Listener_bind_future; -moq_moq_tokio_websocket_Listener_bind_future *moq_moq_tokio_websocket_Listener_bind(moq_socket_addr addr); -moq_poll moq_moq_tokio_websocket_Listener_bind_start(moq_socket_addr addr, moq_moq_tokio_websocket_Listener **out, moq_moq_tokio_websocket_Error **err, moq_moq_tokio_websocket_Listener_bind_future **future); -moq_poll moq_moq_tokio_websocket_Listener_bind_poll(moq_moq_tokio_websocket_Listener_bind_future *future, moq_waker waker, moq_moq_tokio_websocket_Listener **out, moq_moq_tokio_websocket_Error **err); +MOQ_MUST_USE moq_moq_tokio_websocket_Listener_bind_future *moq_moq_tokio_websocket_Listener_bind(moq_socket_addr addr); +MOQ_MUST_USE moq_poll moq_moq_tokio_websocket_Listener_bind_start(moq_socket_addr addr, moq_moq_tokio_websocket_Listener **out, moq_moq_tokio_websocket_Error **err, moq_moq_tokio_websocket_Listener_bind_future **future); +MOQ_MUST_USE moq_poll moq_moq_tokio_websocket_Listener_bind_poll(moq_moq_tokio_websocket_Listener_bind_future *future, moq_waker waker, moq_moq_tokio_websocket_Listener **out, moq_moq_tokio_websocket_Error **err); void moq_moq_tokio_websocket_Listener_bind_future_free(moq_moq_tokio_websocket_Listener_bind_future *future); -bool moq_moq_tokio_websocket_Listener_with_protocols(moq_moq_tokio_websocket_Listener *self, moq_vec_string protocols, moq_moq_tokio_websocket_Listener **out, moq_moq_tokio_websocket_Error **err, moq_status *status); -moq_moq_tokio_websocket_Listener *moq_moq_tokio_websocket_Listener_with_quic(moq_moq_tokio_websocket_Listener *self, const moq_moq_tokio_quic_Resolved *quic, moq_status *status); -bool moq_moq_tokio_websocket_Listener_local_addr(const moq_moq_tokio_websocket_Listener *self, moq_socket_addr *out, moq_moq_tokio_websocket_Error **err, moq_status *status); -moq_moq_tokio_accept_Health *moq_moq_tokio_websocket_Listener_accept_health(const moq_moq_tokio_websocket_Listener *self, moq_status *status); +MOQ_MUST_USE bool moq_moq_tokio_websocket_Listener_with_protocols(moq_moq_tokio_websocket_Listener *self, moq_vec_string protocols, moq_moq_tokio_websocket_Listener **out, moq_moq_tokio_websocket_Error **err, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_websocket_Listener *moq_moq_tokio_websocket_Listener_with_quic(moq_moq_tokio_websocket_Listener *self, const moq_moq_tokio_quic_Resolved *quic, moq_status *status); +MOQ_MUST_USE bool moq_moq_tokio_websocket_Listener_local_addr(const moq_moq_tokio_websocket_Listener *self, moq_socket_addr *out, moq_moq_tokio_websocket_Error **err, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_accept_Health *moq_moq_tokio_websocket_Listener_accept_health(const moq_moq_tokio_websocket_Listener *self, moq_status *status); typedef struct moq_moq_tokio_websocket_Listener_accept_future moq_moq_tokio_websocket_Listener_accept_future; -moq_moq_tokio_websocket_Listener_accept_future *moq_moq_tokio_websocket_Listener_accept(const moq_moq_tokio_websocket_Listener *self, moq_status *status); -moq_poll moq_moq_tokio_websocket_Listener_accept_start(const moq_moq_tokio_websocket_Listener *self, moq_qmux_Session **out, moq_moq_tokio_websocket_Error **err, moq_moq_tokio_websocket_Listener_accept_future **future, moq_status *status); -moq_poll moq_moq_tokio_websocket_Listener_accept_poll(moq_moq_tokio_websocket_Listener_accept_future *future, moq_waker waker, moq_qmux_Session **out, moq_moq_tokio_websocket_Error **err); +MOQ_MUST_USE moq_moq_tokio_websocket_Listener_accept_future *moq_moq_tokio_websocket_Listener_accept(const moq_moq_tokio_websocket_Listener *self, moq_status *status); +MOQ_MUST_USE moq_poll moq_moq_tokio_websocket_Listener_accept_start(const moq_moq_tokio_websocket_Listener *self, moq_qmux_Session **out, moq_moq_tokio_websocket_Error **err, moq_moq_tokio_websocket_Listener_accept_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_moq_tokio_websocket_Listener_accept_poll(moq_moq_tokio_websocket_Listener_accept_future *future, moq_waker waker, moq_qmux_Session **out, moq_moq_tokio_websocket_Error **err); void moq_moq_tokio_websocket_Listener_accept_future_free(moq_moq_tokio_websocket_Listener_accept_future *future); void moq_moq_tokio_quic_demux_Demux_free(moq_moq_tokio_quic_demux_Demux *self); void moq_moq_tokio_quic_demux_Demux_drop(moq_moq_tokio_quic_demux_Demux *self, moq_status *status); -moq_moq_tokio_quic_demux_Demux *moq_moq_tokio_quic_demux_Demux_clone(const moq_moq_tokio_quic_demux_Demux *self, moq_status *status); -moq_buf moq_moq_tokio_quic_demux_Demux_debug(const moq_moq_tokio_quic_demux_Demux *self, moq_status *status); -moq_moq_tokio_quic_demux_Demux *moq_moq_tokio_quic_demux_Demux_default(void); -moq_moq_sock_demux_Counters *moq_moq_tokio_quic_demux_Demux_counters(const moq_moq_tokio_quic_demux_Demux *self, moq_status *status); -moq_moq_tokio_quic_demux_WebRtc *moq_moq_tokio_quic_demux_Demux_webrtc(const moq_moq_tokio_quic_demux_Demux *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_quic_demux_Demux *moq_moq_tokio_quic_demux_Demux_clone(const moq_moq_tokio_quic_demux_Demux *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_quic_demux_Demux_debug(const moq_moq_tokio_quic_demux_Demux *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_quic_demux_Demux *moq_moq_tokio_quic_demux_Demux_default(void); +MOQ_MUST_USE moq_moq_sock_demux_Counters *moq_moq_tokio_quic_demux_Demux_counters(const moq_moq_tokio_quic_demux_Demux *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_quic_demux_WebRtc *moq_moq_tokio_quic_demux_Demux_webrtc(const moq_moq_tokio_quic_demux_Demux *self, moq_status *status); void moq_moq_tokio_server_Streams_free(moq_moq_tokio_server_Streams *self); void moq_moq_tokio_server_Streams_drop(moq_moq_tokio_server_Streams *self, moq_status *status); -moq_buf moq_moq_tokio_server_Streams_debug(const moq_moq_tokio_server_Streams *self, moq_status *status); -moq_moq_tokio_server_Streams *moq_moq_tokio_server_Streams_default(void); +MOQ_MUST_USE moq_buf moq_moq_tokio_server_Streams_debug(const moq_moq_tokio_server_Streams *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_server_Streams *moq_moq_tokio_server_Streams_default(void); void moq_moq_tokio_server_QuicLimits_free(moq_moq_tokio_server_QuicLimits *self); -moq_moq_tokio_server_QuicLimits *moq_moq_tokio_server_QuicLimits_clone(const moq_moq_tokio_server_QuicLimits *self); -moq_buf moq_moq_tokio_server_QuicLimits_debug(const moq_moq_tokio_server_QuicLimits *self); -bool moq_moq_tokio_server_QuicLimits_set(const moq_moq_tokio_server_QuicLimits *self, const moq_moq_quic_Limits *limits, moq_buf *err, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_server_QuicLimits *moq_moq_tokio_server_QuicLimits_clone(const moq_moq_tokio_server_QuicLimits *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_server_QuicLimits_debug(const moq_moq_tokio_server_QuicLimits *self); +MOQ_MUST_USE bool moq_moq_tokio_server_QuicLimits_set(const moq_moq_tokio_server_QuicLimits *self, const moq_moq_quic_Limits *limits, moq_buf *err, moq_status *status); void moq_moq_quic_Limits_free(moq_moq_quic_Limits *self); void moq_moq_quic_Limits_drop(moq_moq_quic_Limits *self, moq_status *status); -moq_moq_quic_Limits *moq_moq_quic_Limits_clone(const moq_moq_quic_Limits *self, moq_status *status); +MOQ_MUST_USE moq_moq_quic_Limits *moq_moq_quic_Limits_clone(const moq_moq_quic_Limits *self, moq_status *status); bool moq_moq_quic_Limits_eq(const moq_moq_quic_Limits *a, const moq_moq_quic_Limits *b, moq_status *status); -moq_buf moq_moq_quic_Limits_debug(const moq_moq_quic_Limits *self, moq_status *status); -moq_moq_quic_Limits *moq_moq_quic_Limits_default(void); +MOQ_MUST_USE moq_buf moq_moq_quic_Limits_debug(const moq_moq_quic_Limits *self, moq_status *status); +MOQ_MUST_USE moq_moq_quic_Limits *moq_moq_quic_Limits_default(void); moq_option_non_zero_u64 moq_moq_quic_Limits_max_streams_get(const moq_moq_quic_Limits *self, moq_status *status); void moq_moq_quic_Limits_max_streams_set(moq_moq_quic_Limits *self, moq_option_non_zero_u64 value, moq_status *status); moq_option_non_zero_u64 moq_moq_quic_Limits_receive_window_get(const moq_moq_quic_Limits *self, moq_status *status); @@ -9116,172 +9126,172 @@ moq_option_moq_quic_Rate moq_moq_quic_Limits_receive_rate_get(const moq_moq_quic void moq_moq_quic_Limits_receive_rate_set(moq_moq_quic_Limits *self, moq_option_moq_quic_Rate value, moq_status *status); moq_option_moq_quic_Rate moq_moq_quic_Limits_send_rate_get(const moq_moq_quic_Limits *self, moq_status *status); void moq_moq_quic_Limits_send_rate_set(moq_moq_quic_Limits *self, moq_option_moq_quic_Rate value, moq_status *status); -bool moq_moq_quic_Limits_validate(const moq_moq_quic_Limits *self, moq_buf *err, moq_status *status); +MOQ_MUST_USE bool moq_moq_quic_Limits_validate(const moq_moq_quic_Limits *self, moq_buf *err, moq_status *status); void moq_moq_tokio_connect_Addr_free(moq_moq_tokio_connect_Addr *self); void moq_moq_tokio_connect_Addr_drop(moq_moq_tokio_connect_Addr *self, moq_status *status); bool moq_moq_tokio_connect_Addr_borrowed(const moq_moq_tokio_connect_Addr *self); -moq_moq_tokio_connect_Addr *moq_moq_tokio_connect_Addr_clone(const moq_moq_tokio_connect_Addr *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_connect_Addr *moq_moq_tokio_connect_Addr_clone(const moq_moq_tokio_connect_Addr *self, moq_status *status); bool moq_moq_tokio_connect_Addr_eq(const moq_moq_tokio_connect_Addr *a, const moq_moq_tokio_connect_Addr *b, moq_status *status); -moq_buf moq_moq_tokio_connect_Addr_debug(const moq_moq_tokio_connect_Addr *self, moq_status *status); -moq_moq_tokio_connect_Addr *moq_moq_tokio_connect_Addr_new(moq_Url *url, moq_status *status); -bool moq_moq_tokio_connect_Addr_pinned(moq_Url *url, moq_vec_socket_addr addrs, moq_moq_tokio_connect_Addr **out, moq_moq_tokio_connect_Error *err, moq_status *status); -moq_Url *moq_moq_tokio_connect_Addr_url(const moq_moq_tokio_connect_Addr *self, moq_status *status); -moq_vec_socket_addr moq_moq_tokio_connect_Addr_addresses(const moq_moq_tokio_connect_Addr *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_connect_Addr_debug(const moq_moq_tokio_connect_Addr *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_connect_Addr *moq_moq_tokio_connect_Addr_new(moq_Url *url, moq_status *status); +MOQ_MUST_USE bool moq_moq_tokio_connect_Addr_pinned(moq_Url *url, moq_vec_socket_addr addrs, moq_moq_tokio_connect_Addr **out, moq_moq_tokio_connect_Error *err, moq_status *status); +MOQ_MUST_USE moq_Url *moq_moq_tokio_connect_Addr_url(const moq_moq_tokio_connect_Addr *self, moq_status *status); +MOQ_MUST_USE moq_vec_socket_addr moq_moq_tokio_connect_Addr_addresses(const moq_moq_tokio_connect_Addr *self, moq_status *status); void moq_rustls_pki_types_TrustAnchor_free(moq_rustls_pki_types_TrustAnchor *self); void moq_rustls_pki_types_TrustAnchor_drop(moq_rustls_pki_types_TrustAnchor *self, moq_status *status); -moq_rustls_pki_types_TrustAnchor *moq_rustls_pki_types_TrustAnchor_clone(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); +MOQ_MUST_USE moq_rustls_pki_types_TrustAnchor *moq_rustls_pki_types_TrustAnchor_clone(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); bool moq_rustls_pki_types_TrustAnchor_eq(const moq_rustls_pki_types_TrustAnchor *a, const moq_rustls_pki_types_TrustAnchor *b, moq_status *status); uint64_t moq_rustls_pki_types_TrustAnchor_hash(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); -moq_buf moq_rustls_pki_types_TrustAnchor_debug(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); -moq_rustls_pki_types_Der *moq_rustls_pki_types_TrustAnchor_subject_get(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_rustls_pki_types_TrustAnchor_debug(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); +MOQ_MUST_USE moq_rustls_pki_types_Der *moq_rustls_pki_types_TrustAnchor_subject_get(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); void moq_rustls_pki_types_TrustAnchor_subject_set(moq_rustls_pki_types_TrustAnchor *self, moq_rustls_pki_types_Der *value, moq_status *status); -moq_rustls_pki_types_Der *moq_rustls_pki_types_TrustAnchor_subject_public_key_info_get(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); +MOQ_MUST_USE moq_rustls_pki_types_Der *moq_rustls_pki_types_TrustAnchor_subject_public_key_info_get(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); void moq_rustls_pki_types_TrustAnchor_subject_public_key_info_set(moq_rustls_pki_types_TrustAnchor *self, moq_rustls_pki_types_Der *value, moq_status *status); -moq_rustls_pki_types_Der *moq_rustls_pki_types_TrustAnchor_name_constraints_get(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); +MOQ_MUST_USE moq_rustls_pki_types_Der *moq_rustls_pki_types_TrustAnchor_name_constraints_get(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); void moq_rustls_pki_types_TrustAnchor_name_constraints_set(moq_rustls_pki_types_TrustAnchor *self, moq_rustls_pki_types_Der *value, moq_status *status); -moq_rustls_pki_types_TrustAnchor *moq_rustls_pki_types_TrustAnchor_to_owned(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); +MOQ_MUST_USE moq_rustls_pki_types_TrustAnchor *moq_rustls_pki_types_TrustAnchor_to_owned(const moq_rustls_pki_types_TrustAnchor *self, moq_status *status); void moq_moq_tokio_connection_Phase_free(moq_moq_tokio_connection_Phase *self); void moq_moq_tokio_connection_Phase_drop(moq_moq_tokio_connection_Phase *self, moq_status *status); bool moq_moq_tokio_connection_Phase_borrowed(const moq_moq_tokio_connection_Phase *self); -moq_moq_tokio_connection_Phase *moq_moq_tokio_connection_Phase_clone(const moq_moq_tokio_connection_Phase *self, moq_status *status); -moq_buf moq_moq_tokio_connection_Phase_debug(const moq_moq_tokio_connection_Phase *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_connection_Phase *moq_moq_tokio_connection_Phase_clone(const moq_moq_tokio_connection_Phase *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_connection_Phase_debug(const moq_moq_tokio_connection_Phase *self, moq_status *status); void moq_moq_tokio_quic_ServerId_free(moq_moq_tokio_quic_ServerId *self); void moq_moq_tokio_quic_ServerId_drop(moq_moq_tokio_quic_ServerId *self, moq_status *status); bool moq_moq_tokio_quic_ServerId_borrowed(const moq_moq_tokio_quic_ServerId *self); -moq_moq_tokio_quic_ServerId *moq_moq_tokio_quic_ServerId_clone(const moq_moq_tokio_quic_ServerId *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_quic_ServerId *moq_moq_tokio_quic_ServerId_clone(const moq_moq_tokio_quic_ServerId *self, moq_status *status); bool moq_moq_tokio_quic_ServerId_eq(const moq_moq_tokio_quic_ServerId *a, const moq_moq_tokio_quic_ServerId *b, moq_status *status); uint64_t moq_moq_tokio_quic_ServerId_hash(const moq_moq_tokio_quic_ServerId *self, moq_status *status); -moq_buf moq_moq_tokio_quic_ServerId_debug(const moq_moq_tokio_quic_ServerId *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_quic_ServerId_debug(const moq_moq_tokio_quic_ServerId *self, moq_status *status); void moq_moq_tokio_listen_Forward_free(moq_moq_tokio_listen_Forward *self); void moq_moq_tokio_listen_Forward_drop(moq_moq_tokio_listen_Forward *self, moq_status *status); -moq_moq_tokio_listen_Forward *moq_moq_tokio_listen_Forward_clone(const moq_moq_tokio_listen_Forward *self, moq_status *status); -moq_buf moq_moq_tokio_listen_Forward_debug(const moq_moq_tokio_listen_Forward *self, moq_status *status); -moq_moq_tokio_listen_Forward *moq_moq_tokio_listen_Forward_default(void); +MOQ_MUST_USE moq_moq_tokio_listen_Forward *moq_moq_tokio_listen_Forward_clone(const moq_moq_tokio_listen_Forward *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_listen_Forward_debug(const moq_moq_tokio_listen_Forward *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_listen_Forward *moq_moq_tokio_listen_Forward_default(void); moq_option_socket_addr moq_moq_tokio_listen_Forward_bind_get(const moq_moq_tokio_listen_Forward *self, moq_status *status); void moq_moq_tokio_listen_Forward_bind_set(moq_moq_tokio_listen_Forward *self, moq_option_socket_addr value, moq_status *status); -moq_buf moq_moq_tokio_listen_Forward_key_get(const moq_moq_tokio_listen_Forward *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_listen_Forward_key_get(const moq_moq_tokio_listen_Forward *self, moq_status *status); void moq_moq_tokio_listen_Forward_key_set(moq_moq_tokio_listen_Forward *self, moq_buf value, moq_status *status); -moq_buf moq_moq_tokio_listen_Forward_peers_get(const moq_moq_tokio_listen_Forward *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_listen_Forward_peers_get(const moq_moq_tokio_listen_Forward *self, moq_status *status); void moq_moq_tokio_listen_Forward_peers_set(moq_moq_tokio_listen_Forward *self, moq_buf value, moq_status *status); void moq_rustls_client_danger_DangerousClientConfig_free(moq_rustls_client_danger_DangerousClientConfig *self); void moq_rustls_client_danger_DangerousClientConfig_drop(moq_rustls_client_danger_DangerousClientConfig *self, moq_status *status); -moq_buf moq_rustls_client_danger_DangerousClientConfig_debug(const moq_rustls_client_danger_DangerousClientConfig *self, moq_status *status); -moq_rustls_ClientConfig *moq_rustls_client_danger_DangerousClientConfig_cfg_get(const moq_rustls_client_danger_DangerousClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_rustls_client_danger_DangerousClientConfig_debug(const moq_rustls_client_danger_DangerousClientConfig *self, moq_status *status); +MOQ_MUST_USE moq_rustls_ClientConfig *moq_rustls_client_danger_DangerousClientConfig_cfg_get(const moq_rustls_client_danger_DangerousClientConfig *self, moq_status *status); void moq_rustls_client_Resumption_free(moq_rustls_client_Resumption *self); void moq_rustls_client_Resumption_drop(moq_rustls_client_Resumption *self, moq_status *status); bool moq_rustls_client_Resumption_borrowed(const moq_rustls_client_Resumption *self); -moq_rustls_client_Resumption *moq_rustls_client_Resumption_clone(const moq_rustls_client_Resumption *self, moq_status *status); -moq_buf moq_rustls_client_Resumption_debug(const moq_rustls_client_Resumption *self, moq_status *status); -moq_rustls_client_Resumption *moq_rustls_client_Resumption_default(void); -moq_rustls_client_Resumption *moq_rustls_client_Resumption_in_memory_sessions(size_t num); -moq_rustls_client_Resumption *moq_rustls_client_Resumption_disabled(void); -moq_rustls_client_Resumption *moq_rustls_client_Resumption_tls12_resumption(moq_rustls_client_Resumption *self, moq_rustls_client_Tls12Resumption tls12, moq_status *status); +MOQ_MUST_USE moq_rustls_client_Resumption *moq_rustls_client_Resumption_clone(const moq_rustls_client_Resumption *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_rustls_client_Resumption_debug(const moq_rustls_client_Resumption *self, moq_status *status); +MOQ_MUST_USE moq_rustls_client_Resumption *moq_rustls_client_Resumption_default(void); +MOQ_MUST_USE moq_rustls_client_Resumption *moq_rustls_client_Resumption_in_memory_sessions(size_t num); +MOQ_MUST_USE moq_rustls_client_Resumption *moq_rustls_client_Resumption_disabled(void); +MOQ_MUST_USE moq_rustls_client_Resumption *moq_rustls_client_Resumption_tls12_resumption(moq_rustls_client_Resumption *self, moq_rustls_client_Tls12Resumption tls12, moq_status *status); void moq_rustls_DistinguishedName_free(moq_rustls_DistinguishedName *self); bool moq_rustls_DistinguishedName_borrowed(const moq_rustls_DistinguishedName *self); -moq_rustls_DistinguishedName *moq_rustls_DistinguishedName_clone(const moq_rustls_DistinguishedName *self); -moq_buf moq_rustls_DistinguishedName_debug(const moq_rustls_DistinguishedName *self); -moq_rustls_DistinguishedName *moq_rustls_DistinguishedName_in_sequence(moq_buf bytes); +MOQ_MUST_USE moq_rustls_DistinguishedName *moq_rustls_DistinguishedName_clone(const moq_rustls_DistinguishedName *self); +MOQ_MUST_USE moq_buf moq_rustls_DistinguishedName_debug(const moq_rustls_DistinguishedName *self); +MOQ_MUST_USE moq_rustls_DistinguishedName *moq_rustls_DistinguishedName_in_sequence(moq_buf bytes); void moq_moq_tokio_websocket_Resolved_free(moq_moq_tokio_websocket_Resolved *self); void moq_moq_tokio_websocket_Resolved_drop(moq_moq_tokio_websocket_Resolved *self, moq_status *status); -moq_moq_tokio_websocket_Resolved *moq_moq_tokio_websocket_Resolved_clone(const moq_moq_tokio_websocket_Resolved *self, moq_status *status); -moq_buf moq_moq_tokio_websocket_Resolved_debug(const moq_moq_tokio_websocket_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_websocket_Resolved *moq_moq_tokio_websocket_Resolved_clone(const moq_moq_tokio_websocket_Resolved *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_websocket_Resolved_debug(const moq_moq_tokio_websocket_Resolved *self, moq_status *status); bool moq_moq_tokio_websocket_Resolved_enabled_get(const moq_moq_tokio_websocket_Resolved *self, moq_status *status); void moq_moq_tokio_websocket_Resolved_enabled_set(moq_moq_tokio_websocket_Resolved *self, bool value, moq_status *status); moq_duration moq_moq_tokio_websocket_Resolved_delay_get(const moq_moq_tokio_websocket_Resolved *self, moq_status *status); void moq_moq_tokio_websocket_Resolved_delay_set(moq_moq_tokio_websocket_Resolved *self, moq_duration value, moq_status *status); void moq_moq_tokio_unix_Allow_free(moq_moq_tokio_unix_Allow *self); void moq_moq_tokio_unix_Allow_drop(moq_moq_tokio_unix_Allow *self, moq_status *status); -moq_moq_tokio_unix_Allow *moq_moq_tokio_unix_Allow_clone(const moq_moq_tokio_unix_Allow *self, moq_status *status); -moq_buf moq_moq_tokio_unix_Allow_debug(const moq_moq_tokio_unix_Allow *self, moq_status *status); -moq_moq_tokio_unix_Allow *moq_moq_tokio_unix_Allow_default(void); -moq_vec_u32 moq_moq_tokio_unix_Allow_uid_get(const moq_moq_tokio_unix_Allow *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_unix_Allow *moq_moq_tokio_unix_Allow_clone(const moq_moq_tokio_unix_Allow *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_unix_Allow_debug(const moq_moq_tokio_unix_Allow *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_unix_Allow *moq_moq_tokio_unix_Allow_default(void); +MOQ_MUST_USE moq_vec_u32 moq_moq_tokio_unix_Allow_uid_get(const moq_moq_tokio_unix_Allow *self, moq_status *status); void moq_moq_tokio_unix_Allow_uid_set(moq_moq_tokio_unix_Allow *self, moq_vec_u32 value, moq_status *status); -moq_vec_u32 moq_moq_tokio_unix_Allow_gid_get(const moq_moq_tokio_unix_Allow *self, moq_status *status); +MOQ_MUST_USE moq_vec_u32 moq_moq_tokio_unix_Allow_gid_get(const moq_moq_tokio_unix_Allow *self, moq_status *status); void moq_moq_tokio_unix_Allow_gid_set(moq_moq_tokio_unix_Allow *self, moq_vec_u32 value, moq_status *status); -moq_vec_i32 moq_moq_tokio_unix_Allow_pid_get(const moq_moq_tokio_unix_Allow *self, moq_status *status); +MOQ_MUST_USE moq_vec_i32 moq_moq_tokio_unix_Allow_pid_get(const moq_moq_tokio_unix_Allow *self, moq_status *status); void moq_moq_tokio_unix_Allow_pid_set(moq_moq_tokio_unix_Allow *self, moq_vec_i32 value, moq_status *status); void moq_moq_tokio_websocket_Error_free(moq_moq_tokio_websocket_Error *self); -moq_buf moq_moq_tokio_websocket_Error_to_string(const moq_moq_tokio_websocket_Error *self); -moq_buf moq_moq_tokio_websocket_Error_debug(const moq_moq_tokio_websocket_Error *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_websocket_Error_to_string(const moq_moq_tokio_websocket_Error *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_websocket_Error_debug(const moq_moq_tokio_websocket_Error *self); void moq_qmux_Session_free(moq_qmux_Session *self); void moq_qmux_Session_drop(moq_qmux_Session *self, moq_status *status); bool moq_qmux_Session_borrowed(const moq_qmux_Session *self); -moq_qmux_Session *moq_qmux_Session_clone(const moq_qmux_Session *self, moq_status *status); -moq_buf moq_qmux_Session_debug(const moq_qmux_Session *self, moq_status *status); -moq_buf moq_qmux_Session_protocol(const moq_qmux_Session *self, moq_status *status); +MOQ_MUST_USE moq_qmux_Session *moq_qmux_Session_clone(const moq_qmux_Session *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_qmux_Session_debug(const moq_qmux_Session *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_qmux_Session_protocol(const moq_qmux_Session *self, moq_status *status); moq_moq_quic_connection_mux_Version moq_qmux_Session_version(const moq_qmux_Session *self, moq_status *status); -bool moq_qmux_Session_set_limits(const moq_qmux_Session *self, const moq_moq_quic_Limits *limits, moq_buf *err, moq_status *status); -moq_vec_rustls_pki_types_CertificateDer moq_qmux_Session_peer_certificates(const moq_qmux_Session *self, moq_status *status); -moq_buf moq_qmux_Session_server_name(const moq_qmux_Session *self, moq_status *status); +MOQ_MUST_USE bool moq_qmux_Session_set_limits(const moq_qmux_Session *self, const moq_moq_quic_Limits *limits, moq_buf *err, moq_status *status); +MOQ_MUST_USE moq_vec_rustls_pki_types_CertificateDer moq_qmux_Session_peer_certificates(const moq_qmux_Session *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_qmux_Session_server_name(const moq_qmux_Session *self, moq_status *status); void moq_moq_sock_demux_Counters_free(moq_moq_sock_demux_Counters *self); bool moq_moq_sock_demux_Counters_borrowed(const moq_moq_sock_demux_Counters *self); -moq_moq_sock_demux_Counters *moq_moq_sock_demux_Counters_clone(const moq_moq_sock_demux_Counters *self); -moq_buf moq_moq_sock_demux_Counters_debug(const moq_moq_sock_demux_Counters *self); -moq_moq_sock_demux_Counters *moq_moq_sock_demux_Counters_default(void); +MOQ_MUST_USE moq_moq_sock_demux_Counters *moq_moq_sock_demux_Counters_clone(const moq_moq_sock_demux_Counters *self); +MOQ_MUST_USE moq_buf moq_moq_sock_demux_Counters_debug(const moq_moq_sock_demux_Counters *self); +MOQ_MUST_USE moq_moq_sock_demux_Counters *moq_moq_sock_demux_Counters_default(void); void moq_moq_sock_demux_Counters_discard(const moq_moq_sock_demux_Counters *self, moq_moq_sock_demux_Discard reason); uint64_t moq_moq_sock_demux_Counters_get(const moq_moq_sock_demux_Counters *self, moq_moq_sock_demux_Discard reason); void moq_moq_tokio_quic_demux_WebRtc_free(moq_moq_tokio_quic_demux_WebRtc *self); -moq_buf moq_moq_tokio_quic_demux_WebRtc_debug(const moq_moq_tokio_quic_demux_WebRtc *self); +MOQ_MUST_USE moq_buf moq_moq_tokio_quic_demux_WebRtc_debug(const moq_moq_tokio_quic_demux_WebRtc *self); typedef struct moq_moq_tokio_quic_demux_WebRtc_recv_future moq_moq_tokio_quic_demux_WebRtc_recv_future; -moq_moq_tokio_quic_demux_WebRtc_recv_future *moq_moq_tokio_quic_demux_WebRtc_recv(const moq_moq_tokio_quic_demux_WebRtc *self); -moq_poll moq_moq_tokio_quic_demux_WebRtc_recv_start(const moq_moq_tokio_quic_demux_WebRtc *self, moq_moq_tokio_quic_demux_Datagram **out, moq_moq_tokio_quic_demux_WebRtc_recv_future **future); -moq_poll moq_moq_tokio_quic_demux_WebRtc_recv_poll(moq_moq_tokio_quic_demux_WebRtc_recv_future *future, moq_waker waker, moq_moq_tokio_quic_demux_Datagram **out); +MOQ_MUST_USE moq_moq_tokio_quic_demux_WebRtc_recv_future *moq_moq_tokio_quic_demux_WebRtc_recv(const moq_moq_tokio_quic_demux_WebRtc *self); +MOQ_MUST_USE moq_poll moq_moq_tokio_quic_demux_WebRtc_recv_start(const moq_moq_tokio_quic_demux_WebRtc *self, moq_moq_tokio_quic_demux_Datagram **out, moq_moq_tokio_quic_demux_WebRtc_recv_future **future); +MOQ_MUST_USE moq_poll moq_moq_tokio_quic_demux_WebRtc_recv_poll(moq_moq_tokio_quic_demux_WebRtc_recv_future *future, moq_waker waker, moq_moq_tokio_quic_demux_Datagram **out); void moq_moq_tokio_quic_demux_WebRtc_recv_future_free(moq_moq_tokio_quic_demux_WebRtc_recv_future *future); -moq_moq_sock_demux_Pin *moq_moq_tokio_quic_demux_WebRtc_pin(const moq_moq_tokio_quic_demux_WebRtc *self, moq_socket_addr remote); +MOQ_MUST_USE moq_moq_sock_demux_Pin *moq_moq_tokio_quic_demux_WebRtc_pin(const moq_moq_tokio_quic_demux_WebRtc *self, moq_socket_addr remote); void moq_rustls_pki_types_Der_free(moq_rustls_pki_types_Der *self); void moq_rustls_pki_types_Der_drop(moq_rustls_pki_types_Der *self, moq_status *status); bool moq_rustls_pki_types_Der_borrowed(const moq_rustls_pki_types_Der *self); -moq_rustls_pki_types_Der *moq_rustls_pki_types_Der_clone(const moq_rustls_pki_types_Der *self, moq_status *status); +MOQ_MUST_USE moq_rustls_pki_types_Der *moq_rustls_pki_types_Der_clone(const moq_rustls_pki_types_Der *self, moq_status *status); bool moq_rustls_pki_types_Der_eq(const moq_rustls_pki_types_Der *a, const moq_rustls_pki_types_Der *b, moq_status *status); uint64_t moq_rustls_pki_types_Der_hash(const moq_rustls_pki_types_Der *self, moq_status *status); -moq_buf moq_rustls_pki_types_Der_debug(const moq_rustls_pki_types_Der *self, moq_status *status); -moq_rustls_pki_types_Der *moq_rustls_pki_types_Der_from_slice(moq_buf der); +MOQ_MUST_USE moq_buf moq_rustls_pki_types_Der_debug(const moq_rustls_pki_types_Der *self, moq_status *status); +MOQ_MUST_USE moq_rustls_pki_types_Der *moq_rustls_pki_types_Der_from_slice(moq_buf der); void moq_moq_tokio_quic_demux_Datagram_free(moq_moq_tokio_quic_demux_Datagram *self); void moq_moq_tokio_quic_demux_Datagram_drop(moq_moq_tokio_quic_demux_Datagram *self, moq_status *status); -moq_moq_tokio_quic_demux_Datagram *moq_moq_tokio_quic_demux_Datagram_clone(const moq_moq_tokio_quic_demux_Datagram *self, moq_status *status); -moq_buf moq_moq_tokio_quic_demux_Datagram_debug(const moq_moq_tokio_quic_demux_Datagram *self, moq_status *status); +MOQ_MUST_USE moq_moq_tokio_quic_demux_Datagram *moq_moq_tokio_quic_demux_Datagram_clone(const moq_moq_tokio_quic_demux_Datagram *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_quic_demux_Datagram_debug(const moq_moq_tokio_quic_demux_Datagram *self, moq_status *status); moq_socket_addr moq_moq_tokio_quic_demux_Datagram_remote_get(const moq_moq_tokio_quic_demux_Datagram *self, moq_status *status); void moq_moq_tokio_quic_demux_Datagram_remote_set(moq_moq_tokio_quic_demux_Datagram *self, moq_socket_addr value, moq_status *status); moq_option_ip_addr moq_moq_tokio_quic_demux_Datagram_local_get(const moq_moq_tokio_quic_demux_Datagram *self, moq_status *status); void moq_moq_tokio_quic_demux_Datagram_local_set(moq_moq_tokio_quic_demux_Datagram *self, moq_option_ip_addr value, moq_status *status); -moq_buf moq_moq_tokio_quic_demux_Datagram_data_get(const moq_moq_tokio_quic_demux_Datagram *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_moq_tokio_quic_demux_Datagram_data_get(const moq_moq_tokio_quic_demux_Datagram *self, moq_status *status); void moq_moq_tokio_quic_demux_Datagram_data_set(moq_moq_tokio_quic_demux_Datagram *self, moq_buf value, moq_status *status); void moq_moq_sock_demux_Pin_free(moq_moq_sock_demux_Pin *self); -moq_buf moq_moq_sock_demux_Pin_debug(const moq_moq_sock_demux_Pin *self); +MOQ_MUST_USE moq_buf moq_moq_sock_demux_Pin_debug(const moq_moq_sock_demux_Pin *self); void moq_Url_free(moq_Url *self); void moq_Url_drop(moq_Url *self, moq_status *status); bool moq_Url_borrowed(const moq_Url *self); -moq_Url *moq_Url_clone(const moq_Url *self, moq_status *status); +MOQ_MUST_USE moq_Url *moq_Url_clone(const moq_Url *self, moq_status *status); bool moq_Url_eq(const moq_Url *a, const moq_Url *b, moq_status *status); uint64_t moq_Url_hash(const moq_Url *self, moq_status *status); -moq_buf moq_Url_to_string(const moq_Url *self, moq_status *status); -moq_buf moq_Url_debug(const moq_Url *self, moq_status *status); -bool moq_Url_parse(moq_buf input, moq_Url **out, moq_buf *err); +MOQ_MUST_USE moq_buf moq_Url_to_string(const moq_Url *self, moq_status *status); +MOQ_MUST_USE moq_buf moq_Url_debug(const moq_Url *self, moq_status *status); +MOQ_MUST_USE bool moq_Url_parse(moq_buf input, moq_Url **out, moq_buf *err); void moq_Json_free(moq_Json *self); void moq_Json_drop(moq_Json *self, moq_status *status); -bool moq_Json_parse(moq_buf input, moq_Json **out, moq_buf *err); -moq_buf moq_Json_to_text(const moq_Json *self, moq_status *status); +MOQ_MUST_USE bool moq_Json_parse(moq_buf input, moq_Json **out, moq_buf *err); +MOQ_MUST_USE moq_buf moq_Json_to_text(const moq_Json *self, moq_status *status); void moq_Instant_free(moq_Instant *self); bool moq_Instant_borrowed(const moq_Instant *self); -moq_Instant *moq_Instant_clone(const moq_Instant *self); +MOQ_MUST_USE moq_Instant *moq_Instant_clone(const moq_Instant *self); bool moq_Instant_eq(const moq_Instant *a, const moq_Instant *b); uint64_t moq_Instant_hash(const moq_Instant *self); -moq_buf moq_Instant_debug(const moq_Instant *self); +MOQ_MUST_USE moq_buf moq_Instant_debug(const moq_Instant *self); void moq_rustls_ServerConfig_free(moq_rustls_ServerConfig *self); bool moq_rustls_ServerConfig_borrowed(const moq_rustls_ServerConfig *self); -moq_rustls_ServerConfig *moq_rustls_ServerConfig_clone(const moq_rustls_ServerConfig *self); +MOQ_MUST_USE moq_rustls_ServerConfig *moq_rustls_ServerConfig_clone(const moq_rustls_ServerConfig *self); void moq_rustls_ResolvesClientCert_free(moq_rustls_ResolvesClientCert *self); void moq_rustls_ResolvesClientCert_drop(moq_rustls_ResolvesClientCert *self, moq_status *status); bool moq_rustls_ResolvesClientCert_borrowed(const moq_rustls_ResolvesClientCert *self); -moq_rustls_ResolvesClientCert *moq_rustls_ResolvesClientCert_clone(const moq_rustls_ResolvesClientCert *self, moq_status *status); +MOQ_MUST_USE moq_rustls_ResolvesClientCert *moq_rustls_ResolvesClientCert_clone(const moq_rustls_ResolvesClientCert *self, moq_status *status); void moq_rustls_KeyLog_free(moq_rustls_KeyLog *self); void moq_rustls_KeyLog_drop(moq_rustls_KeyLog *self, moq_status *status); bool moq_rustls_KeyLog_borrowed(const moq_rustls_KeyLog *self); -moq_rustls_KeyLog *moq_rustls_KeyLog_clone(const moq_rustls_KeyLog *self, moq_status *status); +MOQ_MUST_USE moq_rustls_KeyLog *moq_rustls_KeyLog_clone(const moq_rustls_KeyLog *self, moq_status *status); void moq_rustls_TimeProvider_free(moq_rustls_TimeProvider *self); void moq_rustls_TimeProvider_drop(moq_rustls_TimeProvider *self, moq_status *status); bool moq_rustls_TimeProvider_borrowed(const moq_rustls_TimeProvider *self); -moq_rustls_TimeProvider *moq_rustls_TimeProvider_clone(const moq_rustls_TimeProvider *self, moq_status *status); +MOQ_MUST_USE moq_rustls_TimeProvider *moq_rustls_TimeProvider_clone(const moq_rustls_TimeProvider *self, moq_status *status); void moq_rustls_CertDecompressor_free(moq_rustls_CertDecompressor *self); void moq_rustls_CertDecompressor_drop(moq_rustls_CertDecompressor *self, moq_status *status); void moq_rustls_CertCompressor_free(moq_rustls_CertCompressor *self); @@ -9289,89 +9299,89 @@ void moq_rustls_CertCompressor_drop(moq_rustls_CertCompressor *self, moq_status void moq_rustls_CompressionCache_free(moq_rustls_CompressionCache *self); void moq_rustls_CompressionCache_drop(moq_rustls_CompressionCache *self, moq_status *status); bool moq_rustls_CompressionCache_borrowed(const moq_rustls_CompressionCache *self); -moq_rustls_CompressionCache *moq_rustls_CompressionCache_clone(const moq_rustls_CompressionCache *self, moq_status *status); +MOQ_MUST_USE moq_rustls_CompressionCache *moq_rustls_CompressionCache_clone(const moq_rustls_CompressionCache *self, moq_status *status); void moq_rustls_CryptoProvider_free(moq_rustls_CryptoProvider *self); bool moq_rustls_CryptoProvider_borrowed(const moq_rustls_CryptoProvider *self); -moq_rustls_CryptoProvider *moq_rustls_CryptoProvider_clone(const moq_rustls_CryptoProvider *self); -moq_buf moq_IMPLEMENTATION(void); -moq_vec_string moq_ALPNS(void); -moq_buf moq_escape(moq_buf content); -moq_buf moq_unescape(moq_buf segment); +MOQ_MUST_USE moq_rustls_CryptoProvider *moq_rustls_CryptoProvider_clone(const moq_rustls_CryptoProvider *self); +MOQ_MUST_USE moq_buf moq_IMPLEMENTATION(void); +MOQ_MUST_USE moq_vec_string moq_ALPNS(void); +MOQ_MUST_USE moq_buf moq_escape(moq_buf content); +MOQ_MUST_USE moq_buf moq_unescape(moq_buf segment); moq_clock_Instant moq_clock_now(void); moq_clock_Wall moq_clock_wall(void); void moq_clock_origin(moq_clock_Instant *out0, moq_clock_Wall *out1); -moq_clock_Rng *moq_clock_rng(void); -moq_clock_Rng *moq_clock_rng_homed(void); +MOQ_MUST_USE moq_clock_Rng *moq_clock_rng(void); +MOQ_MUST_USE moq_clock_Rng *moq_clock_rng_homed(void); uint64_t moq_clock_seed(void); void moq_clock_host_time(void); typedef struct moq_clock_drive_future moq_clock_drive_future; -moq_clock_drive_future *moq_clock_drive(bool (*poll)(void *data, moq_clock_Instant, const moq_Waiter *, moq_option_clock_Instant *, moq_buf *), void *poll_data, void (*poll_free)(void *data)); -moq_poll moq_clock_drive_start(bool (*poll)(void *data, moq_clock_Instant, const moq_Waiter *, moq_option_clock_Instant *, moq_buf *), void *poll_data, void (*poll_free)(void *data), moq_buf *out, moq_clock_drive_future **future); -moq_poll moq_clock_drive_poll(moq_clock_drive_future *future, moq_waker waker, moq_buf *out); +MOQ_MUST_USE moq_clock_drive_future *moq_clock_drive(bool (*poll)(void *data, moq_clock_Instant, const moq_Waiter *, moq_option_clock_Instant *, moq_buf *), void *poll_data, void (*poll_free)(void *data)); +MOQ_MUST_USE moq_poll moq_clock_drive_start(bool (*poll)(void *data, moq_clock_Instant, const moq_Waiter *, moq_option_clock_Instant *, moq_buf *), void *poll_data, void (*poll_free)(void *data), moq_buf *out, moq_clock_drive_future **future); +MOQ_MUST_USE moq_poll moq_clock_drive_poll(moq_clock_drive_future *future, moq_waker waker, moq_buf *out); void moq_clock_drive_future_free(moq_clock_drive_future *future); -moq_clock_Interval *moq_clock_interval(moq_duration period); -moq_clock_Interval *moq_clock_interval_at(moq_clock_Instant start, moq_duration period); +MOQ_MUST_USE moq_clock_Interval *moq_clock_interval(moq_duration period); +MOQ_MUST_USE moq_clock_Interval *moq_clock_interval_at(moq_clock_Instant start, moq_duration period); typedef struct moq_clock_sleep_future moq_clock_sleep_future; -moq_clock_sleep_future *moq_clock_sleep(moq_duration duration); -moq_poll moq_clock_sleep_start(moq_duration duration, moq_clock_sleep_future **future); -moq_poll moq_clock_sleep_poll(moq_clock_sleep_future *future, moq_waker waker); +MOQ_MUST_USE moq_clock_sleep_future *moq_clock_sleep(moq_duration duration); +MOQ_MUST_USE moq_poll moq_clock_sleep_start(moq_duration duration, moq_clock_sleep_future **future); +MOQ_MUST_USE moq_poll moq_clock_sleep_poll(moq_clock_sleep_future *future, moq_waker waker); void moq_clock_sleep_future_free(moq_clock_sleep_future *future); typedef struct moq_clock_sleep_until_future moq_clock_sleep_until_future; -moq_clock_sleep_until_future *moq_clock_sleep_until(moq_clock_Instant at); -moq_poll moq_clock_sleep_until_start(moq_clock_Instant at, moq_clock_sleep_until_future **future); -moq_poll moq_clock_sleep_until_poll(moq_clock_sleep_until_future *future, moq_waker waker); +MOQ_MUST_USE moq_clock_sleep_until_future *moq_clock_sleep_until(moq_clock_Instant at); +MOQ_MUST_USE moq_poll moq_clock_sleep_until_start(moq_clock_Instant at, moq_clock_sleep_until_future **future); +MOQ_MUST_USE moq_poll moq_clock_sleep_until_poll(moq_clock_sleep_until_future *future, moq_waker waker); void moq_clock_sleep_until_future_free(moq_clock_sleep_until_future *future); typedef struct moq_clock_timeout_future moq_clock_timeout_future; -moq_clock_timeout_future *moq_clock_timeout(moq_duration duration, moq_foreign_future future_); -moq_poll moq_clock_timeout_start(moq_duration duration, moq_foreign_future future_, moq_clock_Elapsed *err, moq_clock_timeout_future **future); -moq_poll moq_clock_timeout_poll(moq_clock_timeout_future *future, moq_waker waker, moq_clock_Elapsed *err); +MOQ_MUST_USE moq_clock_timeout_future *moq_clock_timeout(moq_duration duration, moq_foreign_future future_); +MOQ_MUST_USE moq_poll moq_clock_timeout_start(moq_duration duration, moq_foreign_future future_, moq_clock_Elapsed *err, moq_clock_timeout_future **future); +MOQ_MUST_USE moq_poll moq_clock_timeout_poll(moq_clock_timeout_future *future, moq_waker waker, moq_clock_Elapsed *err); void moq_clock_timeout_future_free(moq_clock_timeout_future *future); typedef struct moq_clock_timeout_at_future moq_clock_timeout_at_future; -moq_clock_timeout_at_future *moq_clock_timeout_at(moq_clock_Instant deadline, moq_foreign_future future_); -moq_poll moq_clock_timeout_at_start(moq_clock_Instant deadline, moq_foreign_future future_, moq_clock_Elapsed *err, moq_clock_timeout_at_future **future); -moq_poll moq_clock_timeout_at_poll(moq_clock_timeout_at_future *future, moq_waker waker, moq_clock_Elapsed *err); +MOQ_MUST_USE moq_clock_timeout_at_future *moq_clock_timeout_at(moq_clock_Instant deadline, moq_foreign_future future_); +MOQ_MUST_USE moq_poll moq_clock_timeout_at_start(moq_clock_Instant deadline, moq_foreign_future future_, moq_clock_Elapsed *err, moq_clock_timeout_at_future **future); +MOQ_MUST_USE moq_poll moq_clock_timeout_at_poll(moq_clock_timeout_at_future *future, moq_waker waker, moq_clock_Elapsed *err); void moq_clock_timeout_at_future_free(moq_clock_timeout_at_future *future); moq_duration moq_server_DEFAULT_TIMEOUT(void); typedef struct moq_time_run_Driver_future moq_time_run_Driver_future; -moq_time_run_Driver_future *moq_time_run_Driver(moq_Driver *driver, moq_status *status); -moq_poll moq_time_run_Driver_start(moq_Driver *driver, moq_Error **out, moq_time_run_Driver_future **future, moq_status *status); -moq_poll moq_time_run_Driver_poll(moq_time_run_Driver_future *future, moq_waker waker, moq_Error **out); +MOQ_MUST_USE moq_time_run_Driver_future *moq_time_run_Driver(moq_Driver *driver, moq_status *status); +MOQ_MUST_USE moq_poll moq_time_run_Driver_start(moq_Driver *driver, moq_Error **out, moq_time_run_Driver_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_time_run_Driver_poll(moq_time_run_Driver_future *future, moq_waker waker, moq_Error **out); void moq_time_run_Driver_future_free(moq_time_run_Driver_future *future); typedef struct moq_time_run_origin_Driver_future moq_time_run_origin_Driver_future; -moq_time_run_origin_Driver_future *moq_time_run_origin_Driver(moq_origin_Driver *driver, moq_status *status); -moq_poll moq_time_run_origin_Driver_start(moq_origin_Driver *driver, moq_Error **out, moq_time_run_origin_Driver_future **future, moq_status *status); -moq_poll moq_time_run_origin_Driver_poll(moq_time_run_origin_Driver_future *future, moq_waker waker, moq_Error **out); +MOQ_MUST_USE moq_time_run_origin_Driver_future *moq_time_run_origin_Driver(moq_origin_Driver *driver, moq_status *status); +MOQ_MUST_USE moq_poll moq_time_run_origin_Driver_start(moq_origin_Driver *driver, moq_Error **out, moq_time_run_origin_Driver_future **future, moq_status *status); +MOQ_MUST_USE moq_poll moq_time_run_origin_Driver_poll(moq_time_run_origin_Driver_future *future, moq_waker waker, moq_Error **out); void moq_time_run_origin_Driver_future_free(moq_time_run_origin_Driver_future *future); -bool moq_varint_decode_quic(moq_buf r, moq_buf *r_out, uint64_t *out, moq_DecodeError **err); -bool moq_varint_encode_quic(uint64_t value, moq_buf w, moq_buf *w_out, moq_EncodeError *err); +MOQ_MUST_USE bool moq_varint_decode_quic(moq_buf r, moq_buf *r_out, uint64_t *out, moq_DecodeError **err); +MOQ_MUST_USE bool moq_varint_encode_quic(uint64_t value, moq_buf w, moq_buf *w_out, moq_EncodeError *err); moq_duration moq_cache_DEFAULT_EXPIRY(void); -moq_buf moq_hang_echo_SUFFIX(void); -moq_buf moq_hang_echo_TRACK(void); +MOQ_MUST_USE moq_buf moq_hang_echo_SUFFIX(void); +MOQ_MUST_USE moq_buf moq_hang_echo_TRACK(void); bool moq_hang_echo_is_echo(const moq_Path *path, moq_status *status); moq_hang_catalog_Priorities moq_hang_catalog_PRIORITY(void); moq_duration moq_hang_container_MAX_AGE(void); moq_Timescale moq_hang_container_TIMESCALE(void); -moq_track_Info *moq_hang_container_track_info(int8_t priority); +MOQ_MUST_USE moq_track_Info *moq_hang_container_track_info(int8_t priority); moq_duration moq_mux_container_DELAY_MAX(void); moq_duration moq_mux_rate_RETRY(void); -bool moq_tokio_tls_parse_fingerprint(moq_buf value, moq_array_u8_32 *out, moq_tokio_tls_Error **err); -moq_origin_Producer *moq_tokio_origin_spawn(void); +MOQ_MUST_USE bool moq_tokio_tls_parse_fingerprint(moq_buf value, moq_array_u8_32 *out, moq_tokio_tls_Error **err); +MOQ_MUST_USE moq_origin_Producer *moq_tokio_origin_spawn(void); void moq_transport_memory_pair(moq_transport_memory_Config *config, moq_transport_memory_Session **out0, moq_transport_memory_Session **out1, moq_status *status); -bool moq_mux_codec_aac_config(moq_buf init, moq_hang_catalog_AudioConfig **out, moq_mux_Error **err); -moq_buf moq_mux_codec_annexb_START_CODE(void); -bool moq_mux_codec_annexb_from_length_prefixed(moq_buf payload, size_t length_size, moq_buf prefix, moq_buf *out, moq_mux_codec_annexb_Error **err); -moq_buf moq_mux_codec_annexb_build_prefix(moq_vec_bytes nals); -bool moq_mux_codec_annexb_length_prefixed_to_annexb(moq_buf data_, size_t length_size, moq_buf out_, moq_buf *out__out, moq_mux_codec_annexb_Error **err); -bool moq_mux_codec_annexb_after_start_code(moq_buf b, moq_option_usize *out, moq_mux_codec_annexb_Error **err); +MOQ_MUST_USE bool moq_mux_codec_aac_config(moq_buf init, moq_hang_catalog_AudioConfig **out, moq_mux_Error **err); +MOQ_MUST_USE moq_buf moq_mux_codec_annexb_START_CODE(void); +MOQ_MUST_USE bool moq_mux_codec_annexb_from_length_prefixed(moq_buf payload, size_t length_size, moq_buf prefix, moq_buf *out, moq_mux_codec_annexb_Error **err); +MOQ_MUST_USE moq_buf moq_mux_codec_annexb_build_prefix(moq_vec_bytes nals); +MOQ_MUST_USE bool moq_mux_codec_annexb_length_prefixed_to_annexb(moq_buf data_, size_t length_size, moq_buf out_, moq_buf *out__out, moq_mux_codec_annexb_Error **err); +MOQ_MUST_USE bool moq_mux_codec_annexb_after_start_code(moq_buf b, moq_option_usize *out, moq_mux_codec_annexb_Error **err); moq_option_tuple_usize_usize moq_mux_codec_annexb_find_start_code(moq_buf b); -bool moq_mux_codec_flac_config(moq_buf init, moq_hang_catalog_AudioConfig **out, moq_mux_Error **err); -bool moq_mux_codec_h264_config(moq_buf buf, moq_hang_catalog_VideoConfig **out, moq_mux_Error **err); -bool moq_mux_codec_h265_config(moq_buf buf, moq_hang_catalog_VideoConfig **out, moq_mux_Error **err); -bool moq_mux_codec_mp3_config(moq_buf init, moq_hang_catalog_AudioConfig **out, moq_mux_Error **err); +MOQ_MUST_USE bool moq_mux_codec_flac_config(moq_buf init, moq_hang_catalog_AudioConfig **out, moq_mux_Error **err); +MOQ_MUST_USE bool moq_mux_codec_h264_config(moq_buf buf, moq_hang_catalog_VideoConfig **out, moq_mux_Error **err); +MOQ_MUST_USE bool moq_mux_codec_h265_config(moq_buf buf, moq_hang_catalog_VideoConfig **out, moq_mux_Error **err); +MOQ_MUST_USE bool moq_mux_codec_mp3_config(moq_buf init, moq_hang_catalog_AudioConfig **out, moq_mux_Error **err); moq_duration moq_mux_codec_opus_WARMUP(void); moq_option_u32 moq_mux_codec_opus_packet_samples(moq_buf packet); -bool moq_mux_codec_opus_config(moq_buf init, moq_hang_catalog_AudioConfig **out, moq_mux_Error **err); -bool moq_mux_container_mp4_repair(moq_foreign_reader file, moq_mux_container_mp4_Finish **out, moq_mux_Error **err); +MOQ_MUST_USE bool moq_mux_codec_opus_config(moq_buf init, moq_hang_catalog_AudioConfig **out, moq_mux_Error **err); +MOQ_MUST_USE bool moq_mux_container_mp4_repair(moq_foreign_reader file, moq_mux_container_mp4_Finish **out, moq_mux_Error **err); #ifdef __cplusplus } #endif diff --git a/ffi/surface/moq/cpp.hpp b/ffi/surface/moq/cpp.hpp index 506d1989b..f29b358f4 100644 --- a/ffi/surface/moq/cpp.hpp +++ b/ffi/surface/moq/cpp.hpp @@ -7413,6 +7413,8 @@ namespace moq { #endif namespace moq { #if defined(__clang__) + #define RUST2_FFI_OWNER(T) [[gsl::Owner(T)]] + #define RUST2_FFI_POINTER(T) [[gsl::Pointer(T)]] #define RUST2_FFI_LIFETIMEBOUND [[clang::lifetimebound]] #define RUST2_FFI_CONSUMABLE [[clang::consumable(unconsumed)]] #define RUST2_FFI_CALLABLE [[clang::callable_when("unconsumed", "unknown")]] @@ -7420,6 +7422,8 @@ namespace moq { #define RUST2_FFI_UNCONSUMED [[clang::return_typestate(unconsumed)]] #define RUST2_FFI_MOVED_FROM [[clang::return_typestate(consumed)]] #else + #define RUST2_FFI_OWNER(T) + #define RUST2_FFI_POINTER(T) #define RUST2_FFI_LIFETIMEBOUND #define RUST2_FFI_CONSUMABLE #define RUST2_FFI_CALLABLE @@ -7435,7 +7439,7 @@ namespace moq { borrow &operator=(const borrow &) = delete; T *operator->() const noexcept; }; - class view { + class RUST2_FFI_POINTER(::std::uint8_t) view { view() noexcept : data_(detail::bytes(nullptr, 0)), size_(0); view(const void *data, ::std::size_t size) noexcept : data_(detail::bytes(data, size)), size_(size); view(const char *text) noexcept : view(text, ::std::strlen(text)); @@ -7447,7 +7451,26 @@ namespace moq { const ::std::uint8_t *end() const noexcept; ::std::string_view str() const noexcept; }; - class buf { + #if defined(__GNUC__) && !defined(__clang__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Winit-list-lifetime" + #endif + template class RUST2_FFI_POINTER(T) slice { + slice() noexcept : data_(nullptr), size_(0); + slice(const T *data, ::std::size_t size) noexcept : data_(data), size_(size); + template <::std::size_t N> slice(const T (&array RUST2_FFI_LIFETIMEBOUND)[N]) noexcept : data_(array), size_(N); + slice(::std::initializer_list list RUST2_FFI_LIFETIMEBOUND) noexcept : data_(list.begin()), size_(list.size()); + template ().data())>>, T>>, class = decltype(::std::declval().size())> slice(const R &range RUST2_FFI_LIFETIMEBOUND) noexcept : data_(range.data()), size_(range.size()); + const T *data() const noexcept; + ::std::size_t size() const noexcept; + bool empty() const noexcept; + const T *begin() const noexcept; + const T *end() const noexcept; + }; + #if defined(__GNUC__) && !defined(__clang__) + #pragma GCC diagnostic pop + #endif + class [[nodiscard]] RUST2_FFI_OWNER(::std::uint8_t) buf { buf() noexcept; explicit buf(view bytes) : buf(); buf(const buf &other) : buf(); @@ -7472,7 +7495,7 @@ namespace moq { input &operator=(input &&) = delete; ~input(); }; - template class items { + template class RUST2_FFI_POINTER(T) items { items(const ::std::vector &vector RUST2_FFI_LIFETIMEBOUND) noexcept : data_(vector.data()), size_(vector.size()); items(::std::initializer_list list) : converted_(list), data_(converted_.data()), size_(converted_.size()); template , ::std::vector> && !::std::is_same_v<::std::decay_t, items> && detail::lasting && ::std::is_convertible_v())), T>>> items(const R &range RUST2_FFI_LIFETIMEBOUND); @@ -7494,7 +7517,7 @@ namespace moq { ::std::size_t size() const noexcept; bool empty() const noexcept; }; - template class result { + template class [[nodiscard]] result { static result ok(T value); static result err(E error); bool has_value() const noexcept; @@ -7511,7 +7534,7 @@ namespace moq { const E &error() const &; E &&error() &&; }; - template class result { + template class [[nodiscard]] result { static result ok(); static result err(E error); bool has_value() const noexcept; @@ -7530,13 +7553,13 @@ namespace moq { }; template using poll_t = ::std::conditional_t<::std::is_void_v, bool, ::std::optional>; class task; - class task { + class [[nodiscard]] task { task() noexcept = default; task(task &&other) noexcept : node_(::std::exchange(other.node_, nullptr)); task &operator=(task &&other) noexcept; ~task(); }; - template class future { + template class [[nodiscard]] future { using output = typename Op::output; future(future &&other) noexcept : raw_(::std::exchange(other.raw_, nullptr)), last_(::std::exchange(other.last_, nullptr)); future &operator=(future &&other) noexcept; @@ -9544,11 +9567,11 @@ namespace moq { RUST2_FFI_CALLABLE ::moq::buf debug() const; static moq_tokio_unix_Allow default_(); RUST2_FFI_CALLABLE ::std::vector<::std::uint32_t> uid_get() const; - RUST2_FFI_CALLABLE void uid_set(const ::std::vector<::std::uint32_t> &value); + RUST2_FFI_CALLABLE void uid_set(::moq::slice<::std::uint32_t> value); RUST2_FFI_CALLABLE ::std::vector<::std::uint32_t> gid_get() const; - RUST2_FFI_CALLABLE void gid_set(const ::std::vector<::std::uint32_t> &value); + RUST2_FFI_CALLABLE void gid_set(::moq::slice<::std::uint32_t> value); RUST2_FFI_CALLABLE ::std::vector<::std::int32_t> pid_get() const; - RUST2_FFI_CALLABLE void pid_set(const ::std::vector<::std::int32_t> &value); + RUST2_FFI_CALLABLE void pid_set(::moq::slice<::std::int32_t> value); }; class RUST2_FFI_CONSUMABLE moq_tokio_websocket_Error { RUST2_FFI_UNCONSUMED moq_tokio_websocket_Error(moq_tokio_websocket_Error &&other RUST2_FFI_MOVED_FROM) noexcept = default; diff --git a/ffi/surface/surface.py b/ffi/surface/surface.py index bf7cb6ccd..7979a54dd 100644 --- a/ffi/surface/surface.py +++ b/ffi/surface/surface.py @@ -215,6 +215,7 @@ def c_header(text): DART_TYPE = re.compile( r"^(?:@\S+\s+)*(?:(?:abstract|sealed|final|base|interface|mixin)\s+)*(class|mixin|enum|extension)\b") ACCESS = re.compile(r"^(public|private|protected)$") +ATTRIBUTE = re.compile(r"\[\[.*?\]\]|\b[A-Z][A-Z0-9_]*\([^()]*\)") def braced(text, lang): @@ -325,7 +326,10 @@ def nested(self, hmask): if head.startswith('extern "') or head == "extern _": return "namespace" m = CPP_TYPE.match(head) - if m and first(hmask, re.compile(r"\(")) is None or (m and m.group(1) == "namespace"): + # A type's attributes, such as `[[nodiscard]]` or a macro's `RUST2_FFI_OWNER(T)`, + # hold the only parentheses its header may. + bare = ATTRIBUTE.sub(" ", hmask) + if m and first(bare, re.compile(r"\(")) is None or (m and m.group(1) == "namespace"): return m.group(1) return None m = DART_TYPE.match(head) diff --git a/ffi/surface/test_surface.py b/ffi/surface/test_surface.py index 62cebcb93..9b982ff77 100644 --- a/ffi/surface/test_surface.py +++ b/ffi/surface/test_surface.py @@ -217,6 +217,20 @@ class Marker { "}", ]) + def test_attributed_type(self): + source = """ +template +class [[nodiscard]] API_POINTER(T) span { +public: + const T *data() const noexcept { return nullptr; } +}; +""" + self.assertEqual(self.outline(source), [ + "template class [[nodiscard]] API_POINTER(T) span {", + "\tconst T *data() const noexcept;", + "};", + ]) + class Dart(unittest.TestCase): def outline(self, text): diff --git a/ffi/tests/api.c b/ffi/tests/api.c index 3113d1263..f3423d578 100644 --- a/ffi/tests/api.c +++ b/ffi/tests/api.c @@ -31,6 +31,8 @@ static void print(const char *before, api_buf buf, const char *after) { api_buf_free(buf); } +/* Drops a must-use result on purpose: before C23, GCC warns of one even cast to void. */ +#define DISCARD(call) ((void)!(call)) static int wakes = 0; static int drops = 0; @@ -863,7 +865,9 @@ static void checks(void) { /* A counter a closure was lent, which it fails to move out, then reads as it was. */ static bool move_lent_status(void *data, api_Counter *counter) { api_status *status = data; - api_Counter_into_label(counter, (api_option_Point){0}, status); + /* The refused call returns a zeroed label, which holds nothing to free. */ + api_Label refused = api_Counter_into_label(counter, (api_option_Point){0}, status); + (void)refused; return *status == API_STATUS_LENT && api_Counter_get(counter, NULL) == 0; } @@ -885,7 +889,7 @@ static void *use_elsewhere(void *data) { api_Local_bump(e->local, &e->bumped); uint32_t out = 0; e->poll = api_local_later_poll(e->later, (api_waker){0}, &out, &e->polled); - api_Local_poll_count_poll(e->count, (api_waker){0}, &out, &e->counted); + DISCARD(api_Local_poll_count_poll(e->count, (api_waker){0}, &out, &e->counted)); api_Local_free(e->local); api_local_later_future_free(e->later); api_Local_poll_count_future_free(e->count); @@ -1260,7 +1264,7 @@ static int statuses(void) { api_Ledger *ledger = api_Ledger_new(); api_Draft *draft; api_Error err; - api_Ledger_edit(ledger, &draft, &err, NULL); + DISCARD(api_Ledger_edit(ledger, &draft, &err, NULL)); status = 0; api_Ledger_published(ledger, &status); if (status != API_STATUS_EXCLUSIVE) { @@ -1305,7 +1309,7 @@ static int statuses(void) { } api_Draft_free(draft); /* A close gives it back too, publishing what the draft marked. */ - api_Ledger_edit(ledger, &draft, &err, NULL); + DISCARD(api_Ledger_edit(ledger, &draft, &err, NULL)); api_Draft_write(draft, str("y"), NULL); status = 0; api_Draft_drop(draft, &status); @@ -1315,7 +1319,7 @@ static int statuses(void) { } api_Draft_free(draft); /* The ledger freed while lent drops once the draft does, which still works. */ - api_Ledger_edit(ledger, &draft, &err, NULL); + DISCARD(api_Ledger_edit(ledger, &draft, &err, NULL)); api_Ledger_free(ledger); api_Draft_write(draft, str("z"), NULL); status = 0; @@ -1389,7 +1393,7 @@ static int statuses(void) { api_Slip *twin = api_Slip_clone(slip, NULL); api_Slip_free(slip); status = 0; - api_Slip_receipt_get(twin, &status); + DISCARD(api_Slip_receipt_get(twin, &status)); if (status != API_STATUS_LENT || api_Slip_count(twin, NULL) != 0) { fprintf(stderr, "a lent slip's receipt wrote %d\n", status); failed = 1; @@ -1596,18 +1600,18 @@ static int broken(const char *which) { api_Channel_clear(channel, NULL); } else if (strcmp(which, "utf8") == 0) { api_buf bad = {.ptr = (const uint8_t *)"\xff", .len = 1}; - api_greet(bad, API_SHAPE_CIRCLE); + api_buf_free(api_greet(bad, API_SHAPE_CIRCLE)); } else if (strcmp(which, "finished") == 0) { api_Channel *channel = api_Channel_new(); api_Channel_send(channel, str("x"), NULL); api_Channel_recv_future *recv = api_Channel_recv(channel, NULL); api_waker waker = {0}; api_buf payload; - api_Channel_recv_poll(recv, waker, &payload); + DISCARD(api_Channel_recv_poll(recv, waker, &payload)); api_buf_free(payload); - api_Channel_recv_poll(recv, waker, &payload); + DISCARD(api_Channel_recv_poll(recv, waker, &payload)); } else if (strcmp(which, "enum") == 0) { - api_greet(str("x"), (api_Shape)2); + api_buf_free(api_greet(str("x"), (api_Shape)2)); } else if (strcmp(which, "lent") == 0 || strcmp(which, "lent moved") == 0) { api_Registry *registry = api_Registry_new(api_Counter_new(str("c"), 0), NULL); api_Registry_edit(registry, strcmp(which, "lent") == 0 ? free_lent : move_lent, NULL, NULL); @@ -1623,26 +1627,26 @@ static int broken(const char *which) { api_Registry *registry = api_Registry_new(api_Counter_new(str("c"), 0), NULL); api_Registry_edit(registry, NULL, NULL, NULL); } else if (strcmp(which, "returned") == 0) { - api_made(1, made_view, NULL); + api_buf_free(api_made(1, made_view, NULL)); } else if (strcmp(which, "reader") == 0) { api_buf bytes; uint64_t at; api_buf err; - api_tail((api_foreign_reader){0}, 1, &bytes, &at, &err); + DISCARD(api_tail((api_foreign_reader){0}, 1, &bytes, &at, &err)); } else if (strcmp(which, "bound") == 0) { api_count((api_bounds_u64){.start = {.kind = (api_bound)3}}); } else if (strcmp(which, "future") == 0) { /* A future with no poll. */ - api_after((api_foreign_future){0}, 1); + DISCARD(api_after((api_foreign_future){0}, 1)); } else if (strcmp(which, "started") == 0) { /* A future with no poll, through a start, which the abort names. */ uint32_t out; api_after_future *after; - api_after_start((api_foreign_future){0}, 1, &out, &after); + DISCARD(api_after_start((api_foreign_future){0}, 1, &out, &after)); } else if (strcmp(which, "start") == 0) { /* A start with nowhere to put the handle of a future that pends. */ uint32_t out; - api_yielded_start(1, &out, NULL); + DISCARD(api_yielded_start(1, &out, NULL)); } else if (strcmp(which, "array") == 0) { api_vec_u16 ports = api_ports((api_vec_socket_addr){0}); ports.len = 1; diff --git a/ffi/tests/api.cpp b/ffi/tests/api.cpp index 435194d51..8330f5aa2 100644 --- a/ffi/tests/api.cpp +++ b/ffi/tests/api.cpp @@ -302,7 +302,7 @@ void channel() { } // The send happens at the call: the future is dropped unpolled. - channel.send_later("eager"); + (void)channel.send_later("eager"); { api::Channel_recv_future recv = channel.recv(); if (auto payload = recv.poll(waker)) { @@ -1075,6 +1075,28 @@ int lifetimes() { check(api::dropped() == before + 1, "bytes free their owner"); } + // Numbers lent in place, from wherever the caller holds them, with no copy on C++'s side. + { + const std::uint32_t array[] = {1, 2, 3}; + std::vector vector(array, array + 3); + std::array std_array = {1, 2, 3}; + const std::uint32_t *samples = vector.data(); + check(api::sum_u32(array) == 6, "a C array is a slice"); + check(api::sum_u32(vector) == 6 && api::sum_u32(std_array) == 6, "a contiguous range is a slice"); + check(api::sum_u32({samples, 2}) == 3, "a pointer and a count are a slice"); + check(api::sum_u32({}) == 0 && api::sum_u32({nullptr, 0}) == 0, "an empty slice is one"); + const std::int32_t owned[] = {1, 2}; + check(api::sum_lists(owned, std::nullopt, std::vector{4}) == 7 && + api::sum_lists({}, api::slice(owned), std::nullopt) == 3, + "a slice stands in for an owned Vec and in an option"); +#ifdef __cpp_lib_span + std::span span = vector; + check(api::sum_u32(span) == 6, "a span is a slice"); + std::span back = api::slice(vector); + check(back.size() == 3 && back[2] == 3, "a slice converts to a span"); +#endif + } + forwarding(); std::printf("lifetimes ok\n"); @@ -1156,7 +1178,7 @@ int broken(const char *which) { return api::result::ok(0); } } file; - api::tail(file, 1); + (void)api::tail(file, 1); } else if (std::strcmp(which, "lent kept") == 0) { static std::optional kept; api::Registry registry = api::Registry::new_(api::Counter::new_("c", 0)); diff --git a/ffi/tests/api_strict.cpp b/ffi/tests/api_strict.cpp index 88f178dfa..546546066 100644 --- a/ffi/tests/api_strict.cpp +++ b/ffi/tests/api_strict.cpp @@ -1,6 +1,6 @@ -// What Clang refuses under `-Wconsumed -Wdangling -Werror`: each case, built alone as -// `-DCASE=n`, breaks a contract `tests/api.cpp` otherwise reaches only at run time, or not -// at all. With no case it builds clean. +// What Clang 23 refuses under `-Wconsumed -Wdangling -Wlifetime-safety -Werror`: each case, +// built alone as `-DCASE=n`, breaks a contract `tests/api.cpp` otherwise reaches only at +// run time, or not at all. With no case it builds clean. #include #include #include @@ -94,5 +94,21 @@ void broken() { // Handles lent rather than moved in: the call would empty the caller's vector unasked. std::vector> counters; api::Board::new_(counters); +#elif CASE == 10 + // A task dropped at once, which cancels its future before the callback runs. + auto inline_ = [](auto job) { job(); }; + api::yielded(7).then(inline_, [](std::uint32_t) {}); +#elif CASE == 11 + // A failure dropped unseen. + api::Counter c = api::Counter::new_("c", 0); + c.add(1); +#elif CASE == 12 + // A view of a buffer kept past the buffer, across statements. + api::view name; + { + api::buf bytes = api::Counter::new_("c", 0).name(); + name = bytes; + } + (void)name.size(); #endif } diff --git a/ffi/tests/fixtures.rs b/ffi/tests/fixtures.rs index 35d53fe40..d156f3c37 100644 --- a/ffi/tests/fixtures.rs +++ b/ffi/tests/fixtures.rs @@ -771,18 +771,33 @@ int main() {} ); } -/// Clang's ownership checks: the whole script builds clean under them, and each case of -/// `tests/api_strict.cpp` fails with its diagnostic. +/// Clang's ownership and must-use checks: the whole script builds clean under them, and +/// each case of `tests/api_strict.cpp` fails with its diagnostic. The dev shell's Clang 23, +/// `RUST2_CLANG`, adds `-Wlifetime-safety`; Linux, where the merge gate runs, requires it, +/// and elsewhere without it, as on the nightly's Apple Clang leg, the platform's `clang++` +/// runs every check but that one. fn cpp_strict(link: &Link) { let include = &link.include; let generated = link .generated .as_deref() .expect("tests/api.cpp includes its transcript"); + let clang23 = std::env::var_os("RUST2_CLANG"); + assert!( + clang23.is_some() || !cfg!(target_os = "linux"), + "RUST2_CLANG names Clang 23's clang++: run this in the dev shell" + ); + let lifetimes = clang23.is_some(); + let compiler = clang23.unwrap_or_else(|| "clang++".into()); // What each case printed, kept apart from the others'; its object is not. let clang = |src: &Path, case: u8| { - let mut cmd = Command::new("clang++"); - cmd.args(["-std=c++17", "-Wconsumed", "-Wdangling", "-Werror", "-c", "-I"]) + let mut cmd = Command::new(&compiler); + cmd.args(["-std=c++17", "-Wconsumed", "-Wdangling", "-Werror"]); + if lifetimes { + cmd.arg("-Wlifetime-safety"); + } + cmd.arg("-c") + .arg("-I") .arg(include) .arg("-I") .arg(generated) @@ -834,7 +849,16 @@ fn cpp_strict(link: &Link) { 9, "no viable conversion from 'std::vector>'", ), + ( + 10, + "ignoring return value of type 'task' declared with 'nodiscard' attribute", + ), + (11, "ignoring return value of type 'result<"), + (12, "local variable 'bytes' does not live long enough"), ] { + if case == 12 && !lifetimes { + continue; + } let output = clang(&tests.join("api_strict.cpp"), case); assert!(!output.status.success(), "case {case} built"); let stderr = String::from_utf8_lossy(&output.stderr); diff --git a/flake.nix b/flake.nix index a538dd878..417d2b8ac 100644 --- a/flake.nix +++ b/flake.nix @@ -293,6 +293,9 @@ nativeBuildInputs = pkgs.lib.optional (!pkgs.swift.swiftc.meta.broken) pkgs.swift; RUST2_TS_TOOLCHAIN = tsToolchain; RUST2_TS_SYSROOT = rust2-ts-std; + # rust2-ffi's strict C++ build needs Clang 23's `-Wlifetime-safety`, which no + # compiler on PATH has. + RUST2_CLANG = "${pkgs.llvmPackages_23.clang}/bin/clang++"; KOTLINX_COROUTINES = "${kotlinx-coroutines}"; # The free-threaded CPython the generated Python must refuse. By path, since its # python3 would shadow the GIL build's on PATH. diff --git a/quest/m1/ffi-export/README.md b/quest/m1/ffi-export/README.md index 090867f63..a76929d9d 100644 --- a/quest/m1/ffi-export/README.md +++ b/quest/m1/ffi-export/README.md @@ -97,7 +97,7 @@ Decided with the maintainer on 2026-11-18, in the per-language audit: - ✅ Breaking changes to a generated API that the audit found are children here, and land as soon as possible: "You're allowed to break the API absolutely. Do it sooner." They are the API surface lock (`ffi/surface/`), which landed first, - [C and C++](/quest/m1/ffi-export/cpp-idioms.md), Swift (landed), + C and C++, Swift (landed), Kotlin (landed), Python (landed), [Dart](/quest/m1/ffi-export/dart-analyze.md), and docs. Rejected: only the surface lock holding the pin; all of them after the pin. diff --git a/quest/m1/ffi-export/cpp-idioms.md b/quest/m1/ffi-export/cpp-idioms.md deleted file mode 100644 index 455a02a53..000000000 --- a/quest/m1/ffi-export/cpp-idioms.md +++ /dev/null @@ -1,33 +0,0 @@ -# [S] C and C++: zero-copy numeric slices, must-use returns, lifetime checks - -## Goal - -- A borrowed numeric slice parameter (`&[f32]`, `&[u64]`, any element Rust borrows in - place) takes a pointer-and-length view in C++ that converts from any contiguous range - and, from C++20, `std::span`, instead of `const std::vector&`, so a caller holding a - C array or an audio callback's `float*` no longer allocates and copies. -- `result`, `future`, `task`, and `buf` are `[[nodiscard]]`; the C header marks every - function that returns a handle, a `buf`, a `vec`, or a fallible `bool` with C23 - `[[nodiscard]]` or `__attribute__((warn_unused_result))`. -- `buf` is `[[gsl::Owner]]` and `view`/`items` are `[[gsl::Pointer]]`, and the strict - build adds Clang's `-Wlifetime-safety`, so a view outliving its `buf` across statements - fails to compile. -- The C header's comments are `/** */`, which Doxygen reads. - -`tests/api_strict.cpp` gains a failing case for a discarded task, a discarded result, -and a view kept past its buffer. - -## Plan - -Found by the 2026-11-18 language audit. Evidence: `ffi/src/cpp.rs:258-265` returns -`std::vector` for block element types; `nodiscard` appears nowhere in -`ffi/runtime/rt.hpp` or `ffi/src/cpp.rs`, and destroying a `task` cancels it -(`rt.hpp:752-777`), so `std::move(f).then(exec, cb);` never runs the callback; -`comment()` in `ffi/src/c.rs:610` emits `/* */`. - -Decided with the maintainer on 2026-11-18: ✅ breaking changes land in this epic before -moq pins, as soon as possible (rejected: after the pin). - -Public API: breaking for C++ callers passing `std::vector` lvalues to numeric slice -parameters only where no implicit conversion applies; C and C++ callers that drop a -must-use return now get a warning, an error under `-Werror`. diff --git a/quest/m1/ffi-export/ship.md b/quest/m1/ffi-export/ship.md index fea62ae78..728d5efb8 100644 --- a/quest/m1/ffi-export/ship.md +++ b/quest/m1/ffi-export/ship.md @@ -19,5 +19,4 @@ then see change. A sibling planned later adds itself to `Required` here. ## Required -- [C and C++ idioms](/quest/m1/ffi-export/cpp-idioms.md) - numeric slice views and must-use returns change the C++ API - [Dart analysis](/quest/m1/ffi-export/dart-analyze.md) - lint fixes may rename generated Dart diff --git a/quest/m1/ffi-speed/README.md b/quest/m1/ffi-speed/README.md index b7d2aefab..a881b1b0c 100644 --- a/quest/m1/ffi-speed/README.md +++ b/quest/m1/ffi-speed/README.md @@ -11,7 +11,7 @@ every child has merged. Decided with the maintainer on 2026-11-18, in the per-language audit: ✅ all of the speed findings are kept (rejected: any subset). The zero-copy buffer findings change generated APIs, so they are children of [the exporter epic](/quest/m1/ffi-export/README.md) instead: -[C++](/quest/m1/ffi-export/cpp-idioms.md), Swift (landed), and +C++, Swift (landed), and Kotlin (landed). This epic changes no generated API and does not hold moq's pin.