oct 0.36.2

// Copyright 2024-2026 Gabriel Bjørnager Jensen.
//
// SPDX: MIT OR Apache-2.0

//! The [`MaxSerialisedSize`] trait.

mod test;

use core::cell::{
	Cell,
	LazyCell,
	OnceCell,
	Ref,
	RefCell,
	RefMut,
	UnsafeCell,
};
use core::cmp::{self, Reverse};
use core::convert::Infallible;
use core::marker::{PhantomData, PhantomPinned};
use core::mem::ManuallyDrop;
use core::net::{
	IpAddr,
	Ipv4Addr,
	Ipv6Addr,
	SocketAddr,
	SocketAddrV4,
	SocketAddrV6,
};
use core::num::{NonZero, Saturating, Wrapping};
use core::ops::{
	Bound,
	Range,
	RangeFrom,
	RangeFull,
	RangeInclusive,
	RangeTo,
	RangeToInclusive,
};
use core::time::Duration;

#[allow(unused_imports)]
use core::sync::atomic::Ordering;

#[cfg(feature = "alloc")]
use alloc::borrow::{Cow, ToOwned};

#[cfg(feature = "alloc")]
use alloc::boxed::Box;

#[cfg(feature = "alloc")]
use alloc::rc::{self, Rc};

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
use alloc::sync::{self, Arc};

#[cfg(feature = "ascii")]
use core::ascii;

#[cfg(feature = "simd")]
use core::simd::{self, MaskElement, Simd, SimdElement};

#[cfg(feature = "std")]
use std::io::Cursor;

#[cfg(feature = "std")]
use std::net::Shutdown;

#[cfg(feature = "std")]
use std::sync::{LazyLock, Mutex, OnceLock, RwLock};

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
use core::arch::aarch64 as arch;

#[cfg(target_arch = "wasm32")]
use core::arch::wasm32 as arch;

#[cfg(target_arch = "x86")]
use core::arch::x86 as arch;

#[cfg(target_arch = "x86_64")]
use core::arch::x86_64 as arch;

#[cfg(target_has_atomic = "8")]
use core::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};

#[cfg(target_has_atomic = "16")]
use core::sync::atomic::{AtomicI16, AtomicU16};

#[cfg(target_has_atomic = "32")]
use core::sync::atomic::{AtomicI32, AtomicU32};

#[cfg(target_has_atomic = "64")]
use core::sync::atomic::{AtomicI64, AtomicU64};

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
use core::sync::atomic::{AtomicI128, AtomicU128};

#[cfg(target_has_atomic = "ptr")]
use core::sync::atomic::{AtomicIsize, AtomicUsize};

/// Denotes a type with an upper bound on
/// serialisation sizes.
///
/// Usually, a type that implements this trait
/// should also either implement [`Serialise`] or
/// [`Deserialise`].
///
/// [`Serialise`]: oct::serdes::Serialise
/// [`Deserialise`]: oct::serdes::Deserialise
#[doc(alias = "Serialize")]
#[doc(alias = "Encode")]
pub trait MaxSerialisedSize {
	/// The maximum, possible size of a serialised
	/// object.
	const MAX_SERIALISED_SIZE: usize;
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
impl<T: ?Sized + MaxSerialisedSize> MaxSerialisedSize for Arc<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

// SORT: array
impl<T: MaxSerialisedSize, const N: usize> MaxSerialisedSize for [T; N] {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

#[cfg(target_has_atomic = "8")]
impl MaxSerialisedSize for AtomicBool {
	const MAX_SERIALISED_SIZE: usize = <bool as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
impl MaxSerialisedSize for AtomicI128 {
	const MAX_SERIALISED_SIZE: usize = <i128 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(target_has_atomic = "16")]
impl MaxSerialisedSize for AtomicI16 {
	const MAX_SERIALISED_SIZE: usize = <i16 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(target_has_atomic = "32")]
impl MaxSerialisedSize for AtomicI32 {
	const MAX_SERIALISED_SIZE: usize = <i32 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(target_has_atomic = "64")]
impl MaxSerialisedSize for AtomicI64 {
	const MAX_SERIALISED_SIZE: usize = <i64 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(target_has_atomic = "8")]
impl MaxSerialisedSize for AtomicI8 {
	const MAX_SERIALISED_SIZE: usize = <i8 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(target_has_atomic = "ptr")]
impl MaxSerialisedSize for AtomicIsize {
	const MAX_SERIALISED_SIZE: usize = <isize as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
impl MaxSerialisedSize for AtomicU128 {
	const MAX_SERIALISED_SIZE: usize = <u128 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(target_has_atomic = "16")]
impl MaxSerialisedSize for AtomicU16 {
	const MAX_SERIALISED_SIZE: usize = <u16 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(target_has_atomic = "32")]
impl MaxSerialisedSize for AtomicU32 {
	const MAX_SERIALISED_SIZE: usize = <u32 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(target_has_atomic = "64")]
impl MaxSerialisedSize for AtomicU64 {
	const MAX_SERIALISED_SIZE: usize = <u64 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(target_has_atomic = "8")]
impl MaxSerialisedSize for AtomicU8 {
	const MAX_SERIALISED_SIZE: usize = <u8 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(target_has_atomic = "ptr")]
impl MaxSerialisedSize for AtomicUsize {
	const MAX_SERIALISED_SIZE: usize = <usize as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for bool {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for Bound<T> {
	const MAX_SERIALISED_SIZE: usize = {
		let discriminant_size = <u8 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
		let inner_size        = T::MAX_SERIALISED_SIZE;
		discriminant_size + inner_size
	};
}

#[cfg(feature = "alloc")]
impl<T: ?Sized + MaxSerialisedSize> MaxSerialisedSize for Box<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for Cell<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for char {
	const MAX_SERIALISED_SIZE: usize = <u32 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(feature = "ascii")]
impl MaxSerialisedSize for ascii::Char {
	const MAX_SERIALISED_SIZE: usize = <u8 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(feature = "alloc")]
impl<B: ?Sized + ToOwned + MaxSerialisedSize> MaxSerialisedSize for Cow<'_, B> {
	// NOTE: This type is always serialised borrowed.
	const MAX_SERIALISED_SIZE: usize = B::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl MaxSerialisedSize for arch::CpuidResult {
	const MAX_SERIALISED_SIZE: usize = <u32 as MaxSerialisedSize>::MAX_SERIALISED_SIZE * 4;
}

#[cfg(feature = "std")]
impl<T: MaxSerialisedSize> MaxSerialisedSize for Cursor<T> {
	const MAX_SERIALISED_SIZE: usize = {
		let position_size = <u64 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
		let inner_size    = T::MAX_SERIALISED_SIZE;

		position_size + inner_size
	};
}

impl MaxSerialisedSize for Duration {
	const MAX_SERIALISED_SIZE: usize = {
		let secs_size  = <u64 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
		let nanos_size = <u32 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;

		secs_size + nanos_size
	};
}

#[cfg(feature = "f16")]
impl MaxSerialisedSize for f16 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl MaxSerialisedSize for f32 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl MaxSerialisedSize for f64 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

#[cfg(feature = "f128")]
impl MaxSerialisedSize for f128 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl MaxSerialisedSize for arch::float16x4_t {
	// FIXME(f16): Use `f16` instead.
	const MAX_SERIALISED_SIZE: usize = <[u16; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl MaxSerialisedSize for arch::float16x4x2_t {
	// FIXME(f16): Use `f16` instead.
	const MAX_SERIALISED_SIZE: usize = <[u16; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl MaxSerialisedSize for arch::float16x4x3_t {
	// FIXME(f16): Use `f16` instead.
	const MAX_SERIALISED_SIZE: usize = <[u16; 12] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl MaxSerialisedSize for arch::float16x4x4_t {
	// FIXME(f16): Use `f16` instead.
	const MAX_SERIALISED_SIZE: usize = <[u16; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl MaxSerialisedSize for arch::float16x8_t {
	// FIXME(f16): Use `f16` instead.
	const MAX_SERIALISED_SIZE: usize = <[u16; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl MaxSerialisedSize for arch::float16x8x2_t {
	// FIXME(f16): Use `f16` instead.
	const MAX_SERIALISED_SIZE: usize = <[u16; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl MaxSerialisedSize for arch::float16x8x3_t {
	// FIXME(f16): Use `f16` instead.
	const MAX_SERIALISED_SIZE: usize = <[u16; 24] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
impl MaxSerialisedSize for arch::float16x8x4_t {
	// FIXME(f16): Use `f16` instead.
	const MAX_SERIALISED_SIZE: usize = <[u16; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::float32x2_t {
	const MAX_SERIALISED_SIZE: usize = <[f32; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::float32x2x2_t {
	const MAX_SERIALISED_SIZE: usize = <[f32; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::float32x2x3_t {
	const MAX_SERIALISED_SIZE: usize = <[f32; 6] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::float32x2x4_t {
	const MAX_SERIALISED_SIZE: usize = <[f32; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::float32x4_t {
	const MAX_SERIALISED_SIZE: usize = <[f32; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::float32x4x2_t {
	const MAX_SERIALISED_SIZE: usize = <[f32; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::float32x4x3_t {
	const MAX_SERIALISED_SIZE: usize = <[f32; 12] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::float32x4x4_t {
	const MAX_SERIALISED_SIZE: usize = <[f32; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl MaxSerialisedSize for arch::float64x1_t {
	const MAX_SERIALISED_SIZE: usize = <[f64; 1] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl MaxSerialisedSize for arch::float64x1x2_t {
	const MAX_SERIALISED_SIZE: usize = <[f64; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl MaxSerialisedSize for arch::float64x1x3_t {
	const MAX_SERIALISED_SIZE: usize = <[f64; 3] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl MaxSerialisedSize for arch::float64x1x4_t {
	const MAX_SERIALISED_SIZE: usize = <[f64; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl MaxSerialisedSize for arch::float64x2_t {
	const MAX_SERIALISED_SIZE: usize = <[f64; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl MaxSerialisedSize for arch::float64x2x2_t {
	const MAX_SERIALISED_SIZE: usize = <[f64; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl MaxSerialisedSize for arch::float64x2x3_t {
	const MAX_SERIALISED_SIZE: usize = <[f64; 6] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
impl MaxSerialisedSize for arch::float64x2x4_t {
	const MAX_SERIALISED_SIZE: usize = <[f64; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for i128 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl MaxSerialisedSize for i16 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl MaxSerialisedSize for i32 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl MaxSerialisedSize for i64 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl MaxSerialisedSize for i8 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl MaxSerialisedSize for Infallible {
	const MAX_SERIALISED_SIZE: usize = 0;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int16x4_t {
	const MAX_SERIALISED_SIZE: usize = <[i16; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int16x4x2_t {
	const MAX_SERIALISED_SIZE: usize = <[i16; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int16x4x3_t {
	const MAX_SERIALISED_SIZE: usize = <[i16; 12] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int16x4x4_t {
	const MAX_SERIALISED_SIZE: usize = <[i16; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int16x8_t {
	const MAX_SERIALISED_SIZE: usize = <[i16; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int16x8x2_t {
	const MAX_SERIALISED_SIZE: usize = <[i16; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int16x8x3_t {
	const MAX_SERIALISED_SIZE: usize = <[i16; 24] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int16x8x4_t {
	const MAX_SERIALISED_SIZE: usize = <[i16; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int32x2_t {
	const MAX_SERIALISED_SIZE: usize = <[i32; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int32x2x2_t {
	const MAX_SERIALISED_SIZE: usize = <[i32; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int32x2x3_t {
	const MAX_SERIALISED_SIZE: usize = <[i32; 6] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int32x2x4_t {
	const MAX_SERIALISED_SIZE: usize = <[i32; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int32x4_t {
	const MAX_SERIALISED_SIZE: usize = <[i32; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int32x4x2_t {
	const MAX_SERIALISED_SIZE: usize = <[i32; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int32x4x3_t {
	const MAX_SERIALISED_SIZE: usize = <[i32; 12] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int32x4x4_t {
	const MAX_SERIALISED_SIZE: usize = <[i32; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int64x1_t {
	const MAX_SERIALISED_SIZE: usize = <[i64; 1] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int64x1x2_t {
	const MAX_SERIALISED_SIZE: usize = <[i64; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int64x1x3_t {
	const MAX_SERIALISED_SIZE: usize = <[i64; 3] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int64x1x4_t {
	const MAX_SERIALISED_SIZE: usize = <[i64; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int64x2_t {
	const MAX_SERIALISED_SIZE: usize = <[i64; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int64x2x2_t {
	const MAX_SERIALISED_SIZE: usize = <[i64; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int64x2x3_t {
	const MAX_SERIALISED_SIZE: usize = <[i64; 6] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int64x2x4_t {
	const MAX_SERIALISED_SIZE: usize = <[i64; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int8x16_t {
	const MAX_SERIALISED_SIZE: usize = <[i8; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int8x16x2_t {
	const MAX_SERIALISED_SIZE: usize = <[i8; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int8x16x3_t {
	const MAX_SERIALISED_SIZE: usize = <[i8; 48] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int8x16x4_t {
	const MAX_SERIALISED_SIZE: usize = <[i8; 64] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int8x8_t {
	const MAX_SERIALISED_SIZE: usize = <[i8; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int8x8x2_t {
	const MAX_SERIALISED_SIZE: usize = <[i8; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int8x8x3_t {
	const MAX_SERIALISED_SIZE: usize = <[i8; 24] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::int8x8x4_t {
	const MAX_SERIALISED_SIZE: usize = <[i8; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for IpAddr {
	const MAX_SERIALISED_SIZE: usize = {
		let discriminant_size = <u8 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
		let inner_size        = <Ipv6Addr as MaxSerialisedSize>::MAX_SERIALISED_SIZE;

		discriminant_size + inner_size
	};
}

impl MaxSerialisedSize for Ipv4Addr {
	const MAX_SERIALISED_SIZE: usize = <u32 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for Ipv6Addr {
	const MAX_SERIALISED_SIZE: usize = <u128 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for isize {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for LazyCell<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

#[cfg(feature = "std")]
impl<T: MaxSerialisedSize> MaxSerialisedSize for LazyLock<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl MaxSerialisedSize for arch::__m128 {
	const MAX_SERIALISED_SIZE: usize = <[f32; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
#[expect(clippy::incompatible_msrv)]
impl MaxSerialisedSize for arch::__m128bh {
	const MAX_SERIALISED_SIZE: usize = <[u16; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl MaxSerialisedSize for arch::__m128d {
	const MAX_SERIALISED_SIZE: usize = <[f64; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
#[expect(clippy::incompatible_msrv)]
impl MaxSerialisedSize for arch::__m128h {
	// FIXME(f16): Use `f16` instead.
	const MAX_SERIALISED_SIZE: usize = <[u16; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl MaxSerialisedSize for arch::__m128i {
	const MAX_SERIALISED_SIZE: usize = <[u128; 1] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl MaxSerialisedSize for arch::__m256 {
	const MAX_SERIALISED_SIZE: usize = <[f32; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
#[expect(clippy::incompatible_msrv)]
impl MaxSerialisedSize for arch::__m256bh {
	const MAX_SERIALISED_SIZE: usize = <[u16; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl MaxSerialisedSize for arch::__m256d {
	const MAX_SERIALISED_SIZE: usize = <[f64; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
#[expect(clippy::incompatible_msrv)]
impl MaxSerialisedSize for arch::__m256h {
	// FIXME(f16): Use `f16` instead.
	const MAX_SERIALISED_SIZE: usize = <[u16; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl MaxSerialisedSize for arch::__m256i {
	const MAX_SERIALISED_SIZE: usize = <[u128; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl MaxSerialisedSize for arch::__m512 {
	const MAX_SERIALISED_SIZE: usize = <[f32; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
#[expect(clippy::incompatible_msrv)]
impl MaxSerialisedSize for arch::__m512bh {
	const MAX_SERIALISED_SIZE: usize = <[u16; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl MaxSerialisedSize for arch::__m512d {
	const MAX_SERIALISED_SIZE: usize = <[f64; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
#[expect(clippy::incompatible_msrv)]
impl MaxSerialisedSize for arch::__m512h {
	// FIXME(f16): Use `f16` instead.
	const MAX_SERIALISED_SIZE: usize = <[u16; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
impl MaxSerialisedSize for arch::__m512i {
	const MAX_SERIALISED_SIZE: usize = <[u128; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for ManuallyDrop<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

#[cfg(feature = "simd")]
impl<T: MaskElement, const N: usize> MaxSerialisedSize for simd::Mask<T, N> {
	const MAX_SERIALISED_SIZE: usize = <[bool; N] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(feature = "std")]
impl<T: MaxSerialisedSize> MaxSerialisedSize for Mutex<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<i128> {
	const MAX_SERIALISED_SIZE: usize = <i128 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<i16> {
	const MAX_SERIALISED_SIZE: usize = <i16 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<i32> {
	const MAX_SERIALISED_SIZE: usize = <i32 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<i64> {
	const MAX_SERIALISED_SIZE: usize = <i64 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<i8> {
	const MAX_SERIALISED_SIZE: usize = <i8 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<isize> {
	const MAX_SERIALISED_SIZE: usize = <isize as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<u128> {
	const MAX_SERIALISED_SIZE: usize = <u128 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<u16> {
	const MAX_SERIALISED_SIZE: usize = <u16 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<u32> {
	const MAX_SERIALISED_SIZE: usize = <u32 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<u64> {
	const MAX_SERIALISED_SIZE: usize = <u64 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<u8> {
	const MAX_SERIALISED_SIZE: usize = <u8 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for NonZero<usize> {
	const MAX_SERIALISED_SIZE: usize = <usize as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for OnceCell<T> {
	const MAX_SERIALISED_SIZE: usize = <Option<T> as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(feature = "std")]
impl<T: MaxSerialisedSize> MaxSerialisedSize for OnceLock<T> {
	const MAX_SERIALISED_SIZE: usize = <Option<T> as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for Option<T> {
	const MAX_SERIALISED_SIZE: usize = {
		let discriminant_size = <bool as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
		let inner_size        = T::MAX_SERIALISED_SIZE;

		discriminant_size + inner_size
	};
}

impl MaxSerialisedSize for cmp::Ordering {
	const MAX_SERIALISED_SIZE: usize = <i8 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl<T: ?Sized> MaxSerialisedSize for PhantomData<T> {
	const MAX_SERIALISED_SIZE: usize = 0;
}

impl MaxSerialisedSize for PhantomPinned {
	const MAX_SERIALISED_SIZE: usize = 0;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly16x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly16x4x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly16x4x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 12] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly16x4x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly16x8_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly16x8x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly16x8x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 24] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly16x8x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly64x1_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 1] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly64x1x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly64x1x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 3] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly64x1x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly64x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly64x2x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly64x2x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 6] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly64x2x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly8x16_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly8x16x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly8x16x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 48] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly8x16x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 64] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly8x8_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly8x8x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly8x8x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 24] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::poly8x8x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for Range<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE * 2;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for RangeFrom<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for RangeFull {
	const MAX_SERIALISED_SIZE: usize = 0;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for RangeInclusive<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE * 2;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for RangeTo<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for RangeToInclusive<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

#[cfg(feature = "alloc")]
impl<T: ?Sized + MaxSerialisedSize> MaxSerialisedSize for Rc<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

impl<T: ?Sized + MaxSerialisedSize> MaxSerialisedSize for Ref<'_, T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

// SORT: reference
impl<T: ?Sized + MaxSerialisedSize> MaxSerialisedSize for &T {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

// SORT: reference
impl<T: ?Sized + MaxSerialisedSize> MaxSerialisedSize for &mut T {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

impl<T: ?Sized + MaxSerialisedSize> MaxSerialisedSize for RefCell<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

impl<T: ?Sized + MaxSerialisedSize> MaxSerialisedSize for RefMut<'_, T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

impl<T: MaxSerialisedSize, E: MaxSerialisedSize> MaxSerialisedSize for Result<T, E> {
	const MAX_SERIALISED_SIZE: usize = {
		let discriminant_size = <bool as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
		let ok_size           = T::MAX_SERIALISED_SIZE;
		let err_size          = E::MAX_SERIALISED_SIZE;

		let inner_size = if ok_size >= err_size {
			ok_size
		} else {
			err_size
		};

		discriminant_size + inner_size
	};
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for Reverse<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

#[cfg(feature = "std")]
impl<T: ?Sized + MaxSerialisedSize> MaxSerialisedSize for RwLock<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for Saturating<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

#[cfg(feature = "std")]
impl MaxSerialisedSize for Shutdown {
	const MAX_SERIALISED_SIZE: usize = <u8 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(feature = "simd")]
impl<T: SimdElement + MaxSerialisedSize, const N: usize> MaxSerialisedSize for Simd<T, N> {
	const MAX_SERIALISED_SIZE: usize = <[T; N] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for SocketAddr {
	const MAX_SERIALISED_SIZE: usize = {
		let discriminant_size = <u8 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
		let inner_size        = <SocketAddrV6 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;

		discriminant_size + inner_size
	};
}

impl MaxSerialisedSize for SocketAddrV4 {
	const MAX_SERIALISED_SIZE: usize = {
		let ip_size   = <Ipv4Addr as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
		let port_size = <u16 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;

		ip_size + port_size
	};
}

impl MaxSerialisedSize for SocketAddrV6 {
	const MAX_SERIALISED_SIZE: usize = {
		let ip_size       = <Ipv6Addr as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
		let port_size     = <u16 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
		let flowinfo_size = <u32 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
		let scope_id_size = <u32 as MaxSerialisedSize>::MAX_SERIALISED_SIZE;

		ip_size + port_size + flowinfo_size + scope_id_size
	};
}

// SORT: tuple
/// Implemented for tuples with up to twelve
/// members.
#[cfg_attr(feature = "unstable_docs", doc(fake_variadic))]
impl<T: MaxSerialisedSize> MaxSerialisedSize for (T,) {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1> MaxSerialisedSize for (T0, T1)
where
	T0: MaxSerialisedSize,
	T1: MaxSerialisedSize,
{
	const MAX_SERIALISED_SIZE: usize = T0::MAX_SERIALISED_SIZE
		+ T1::MAX_SERIALISED_SIZE;
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2> MaxSerialisedSize for (T0, T1, T2)
where
	T0: MaxSerialisedSize,
	T1: MaxSerialisedSize,
	T2: MaxSerialisedSize,
{
	const MAX_SERIALISED_SIZE: usize = T0::MAX_SERIALISED_SIZE
		+ T1::MAX_SERIALISED_SIZE
		+ T2::MAX_SERIALISED_SIZE;
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3> MaxSerialisedSize for (T0, T1, T2, T3)
where
	T0: MaxSerialisedSize,
	T1: MaxSerialisedSize,
	T2: MaxSerialisedSize,
	T3: MaxSerialisedSize,
{
	const MAX_SERIALISED_SIZE: usize = T0::MAX_SERIALISED_SIZE
		+ T1::MAX_SERIALISED_SIZE
		+ T2::MAX_SERIALISED_SIZE
		+ T3::MAX_SERIALISED_SIZE;
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4> MaxSerialisedSize for (T0, T1, T2, T3, T4)
where
	T0: MaxSerialisedSize,
	T1: MaxSerialisedSize,
	T2: MaxSerialisedSize,
	T3: MaxSerialisedSize,
	T4: MaxSerialisedSize,
{
	const MAX_SERIALISED_SIZE: usize = T0::MAX_SERIALISED_SIZE
		+ T1::MAX_SERIALISED_SIZE
		+ T2::MAX_SERIALISED_SIZE
		+ T3::MAX_SERIALISED_SIZE
		+ T4::MAX_SERIALISED_SIZE;
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5> MaxSerialisedSize for (T0, T1, T2, T3, T4, T5)
where
	T0: MaxSerialisedSize,
	T1: MaxSerialisedSize,
	T2: MaxSerialisedSize,
	T3: MaxSerialisedSize,
	T4: MaxSerialisedSize,
	T5: MaxSerialisedSize,
{
	const MAX_SERIALISED_SIZE: usize = T0::MAX_SERIALISED_SIZE
		+ T1::MAX_SERIALISED_SIZE
		+ T2::MAX_SERIALISED_SIZE
		+ T3::MAX_SERIALISED_SIZE
		+ T4::MAX_SERIALISED_SIZE
		+ T5::MAX_SERIALISED_SIZE;
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6> MaxSerialisedSize for (T0, T1, T2, T3, T4, T5, T6)
where
	T0: MaxSerialisedSize,
	T1: MaxSerialisedSize,
	T2: MaxSerialisedSize,
	T3: MaxSerialisedSize,
	T4: MaxSerialisedSize,
	T5: MaxSerialisedSize,
	T6: MaxSerialisedSize,
{
	const MAX_SERIALISED_SIZE: usize = T0::MAX_SERIALISED_SIZE
		+ T1::MAX_SERIALISED_SIZE
		+ T2::MAX_SERIALISED_SIZE
		+ T3::MAX_SERIALISED_SIZE
		+ T4::MAX_SERIALISED_SIZE
		+ T5::MAX_SERIALISED_SIZE
		+ T6::MAX_SERIALISED_SIZE;
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7> MaxSerialisedSize for (T0, T1, T2, T3, T4, T5, T6, T7)
where
	T0: MaxSerialisedSize,
	T1: MaxSerialisedSize,
	T2: MaxSerialisedSize,
	T3: MaxSerialisedSize,
	T4: MaxSerialisedSize,
	T5: MaxSerialisedSize,
	T6: MaxSerialisedSize,
	T7: MaxSerialisedSize,
{
	const MAX_SERIALISED_SIZE: usize = T0::MAX_SERIALISED_SIZE
		+ T1::MAX_SERIALISED_SIZE
		+ T2::MAX_SERIALISED_SIZE
		+ T3::MAX_SERIALISED_SIZE
		+ T4::MAX_SERIALISED_SIZE
		+ T5::MAX_SERIALISED_SIZE
		+ T6::MAX_SERIALISED_SIZE
		+ T7::MAX_SERIALISED_SIZE;
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> MaxSerialisedSize for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
where
	T0: MaxSerialisedSize,
	T1: MaxSerialisedSize,
	T2: MaxSerialisedSize,
	T3: MaxSerialisedSize,
	T4: MaxSerialisedSize,
	T5: MaxSerialisedSize,
	T6: MaxSerialisedSize,
	T7: MaxSerialisedSize,
	T8: MaxSerialisedSize,
{
	const MAX_SERIALISED_SIZE: usize = T0::MAX_SERIALISED_SIZE
		+ T1::MAX_SERIALISED_SIZE
		+ T2::MAX_SERIALISED_SIZE
		+ T3::MAX_SERIALISED_SIZE
		+ T4::MAX_SERIALISED_SIZE
		+ T5::MAX_SERIALISED_SIZE
		+ T6::MAX_SERIALISED_SIZE
		+ T7::MAX_SERIALISED_SIZE
		+ T8::MAX_SERIALISED_SIZE;
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> MaxSerialisedSize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where
	T0: MaxSerialisedSize,
	T1: MaxSerialisedSize,
	T2: MaxSerialisedSize,
	T3: MaxSerialisedSize,
	T4: MaxSerialisedSize,
	T5: MaxSerialisedSize,
	T6: MaxSerialisedSize,
	T7: MaxSerialisedSize,
	T8: MaxSerialisedSize,
	T9: MaxSerialisedSize,
{
	const MAX_SERIALISED_SIZE: usize = T0::MAX_SERIALISED_SIZE
		+ T1::MAX_SERIALISED_SIZE
		+ T2::MAX_SERIALISED_SIZE
		+ T3::MAX_SERIALISED_SIZE
		+ T4::MAX_SERIALISED_SIZE
		+ T5::MAX_SERIALISED_SIZE
		+ T6::MAX_SERIALISED_SIZE
		+ T7::MAX_SERIALISED_SIZE
		+ T8::MAX_SERIALISED_SIZE
		+ T9::MAX_SERIALISED_SIZE;
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> MaxSerialisedSize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
where
	T0:  MaxSerialisedSize,
	T1:  MaxSerialisedSize,
	T2:  MaxSerialisedSize,
	T3:  MaxSerialisedSize,
	T4:  MaxSerialisedSize,
	T5:  MaxSerialisedSize,
	T6:  MaxSerialisedSize,
	T7:  MaxSerialisedSize,
	T8:  MaxSerialisedSize,
	T9:  MaxSerialisedSize,
	T10: MaxSerialisedSize,
{
	const MAX_SERIALISED_SIZE: usize = T0::MAX_SERIALISED_SIZE
		+ T1::MAX_SERIALISED_SIZE
		+ T2::MAX_SERIALISED_SIZE
		+ T3::MAX_SERIALISED_SIZE
		+ T4::MAX_SERIALISED_SIZE
		+ T5::MAX_SERIALISED_SIZE
		+ T6::MAX_SERIALISED_SIZE
		+ T7::MAX_SERIALISED_SIZE
		+ T8::MAX_SERIALISED_SIZE
		+ T9::MAX_SERIALISED_SIZE
		+ T10::MAX_SERIALISED_SIZE;
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> MaxSerialisedSize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
where
	T0:  MaxSerialisedSize,
	T1:  MaxSerialisedSize,
	T2:  MaxSerialisedSize,
	T3:  MaxSerialisedSize,
	T4:  MaxSerialisedSize,
	T5:  MaxSerialisedSize,
	T6:  MaxSerialisedSize,
	T7:  MaxSerialisedSize,
	T8:  MaxSerialisedSize,
	T9:  MaxSerialisedSize,
	T10: MaxSerialisedSize,
	T11: MaxSerialisedSize,
{
	const MAX_SERIALISED_SIZE: usize = T0::MAX_SERIALISED_SIZE
		+ T1::MAX_SERIALISED_SIZE
		+ T2::MAX_SERIALISED_SIZE
		+ T3::MAX_SERIALISED_SIZE
		+ T4::MAX_SERIALISED_SIZE
		+ T5::MAX_SERIALISED_SIZE
		+ T6::MAX_SERIALISED_SIZE
		+ T7::MAX_SERIALISED_SIZE
		+ T8::MAX_SERIALISED_SIZE
		+ T9::MAX_SERIALISED_SIZE
		+ T10::MAX_SERIALISED_SIZE
		+ T11::MAX_SERIALISED_SIZE;
}

// SORT: unit
impl MaxSerialisedSize for () {
	const MAX_SERIALISED_SIZE: usize = 0;
}

impl MaxSerialisedSize for u128 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl MaxSerialisedSize for u16 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl MaxSerialisedSize for u32 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl MaxSerialisedSize for u64 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

impl MaxSerialisedSize for u8 {
	const MAX_SERIALISED_SIZE: usize = size_of::<Self>();
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint16x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint16x4x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint16x4x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 12] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint16x4x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint16x8_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint16x8x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint16x8x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 24] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint16x8x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u16; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint32x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u32; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint32x2x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u32; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint32x2x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u32; 6] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint32x2x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u32; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint32x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u32; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint32x4x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u32; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint32x4x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u32; 12] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint32x4x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u32; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint64x1_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 1] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint64x1x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint64x1x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 3] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint64x1x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint64x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 2] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint64x2x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 4] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint64x2x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 6] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint64x2x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u64; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint8x16_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint8x16x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint8x16x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 48] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint8x16x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 64] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint8x8_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 8] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint8x8x2_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 16] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint8x8x3_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 24] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
impl MaxSerialisedSize for arch::uint8x8x4_t {
	const MAX_SERIALISED_SIZE: usize = <[u8; 32] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for UnsafeCell<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}

impl MaxSerialisedSize for usize {
	const MAX_SERIALISED_SIZE: Self = size_of::<Self>();
}

#[cfg(target_arch = "wasm32")]
impl MaxSerialisedSize for arch::v128 {
	const MAX_SERIALISED_SIZE: usize = <[u128; 1] as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(feature = "alloc")]
impl<T: MaxSerialisedSize> MaxSerialisedSize for rc::Weak<T> {
	const MAX_SERIALISED_SIZE: usize = <Option<T> as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
impl<T: MaxSerialisedSize> MaxSerialisedSize for sync::Weak<T> {
	const MAX_SERIALISED_SIZE: usize = <Option<T> as MaxSerialisedSize>::MAX_SERIALISED_SIZE;
}

impl<T: MaxSerialisedSize> MaxSerialisedSize for Wrapping<T> {
	const MAX_SERIALISED_SIZE: usize = T::MAX_SERIALISED_SIZE;
}