Trait ClusterAsyncHandler 

pub trait ClusterAsyncHandler {
    const CLUSTER: Cluster<'static>;

    // Required methods
    fn dataver(&self) -> u32;
    fn dataver_changed(&self);
    async fn boolean(&self, ctx: impl ReadContext) -> Result<bool, Error>;
    async fn bitmap_8(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Bitmap8MaskMap, Error>;
    async fn bitmap_16(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Bitmap16MaskMap, Error>;
    async fn bitmap_32(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Bitmap32MaskMap, Error>;
    async fn bitmap_64(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Bitmap64MaskMap, Error>;
    async fn int_8_u(&self, ctx: impl ReadContext) -> Result<u8, Error>;
    async fn int_16_u(&self, ctx: impl ReadContext) -> Result<u16, Error>;
    async fn int_24_u(&self, ctx: impl ReadContext) -> Result<u32, Error>;
    async fn int_32_u(&self, ctx: impl ReadContext) -> Result<u32, Error>;
    async fn int_40_u(&self, ctx: impl ReadContext) -> Result<u64, Error>;
    async fn int_48_u(&self, ctx: impl ReadContext) -> Result<u64, Error>;
    async fn int_56_u(&self, ctx: impl ReadContext) -> Result<u64, Error>;
    async fn int_64_u(&self, ctx: impl ReadContext) -> Result<u64, Error>;
    async fn int_8_s(&self, ctx: impl ReadContext) -> Result<i8, Error>;
    async fn int_16_s(&self, ctx: impl ReadContext) -> Result<i16, Error>;
    async fn int_24_s(&self, ctx: impl ReadContext) -> Result<i32, Error>;
    async fn int_32_s(&self, ctx: impl ReadContext) -> Result<i32, Error>;
    async fn int_40_s(&self, ctx: impl ReadContext) -> Result<i64, Error>;
    async fn int_48_s(&self, ctx: impl ReadContext) -> Result<i64, Error>;
    async fn int_56_s(&self, ctx: impl ReadContext) -> Result<i64, Error>;
    async fn int_64_s(&self, ctx: impl ReadContext) -> Result<i64, Error>;
    async fn enum_8(&self, ctx: impl ReadContext) -> Result<u8, Error>;
    async fn enum_16(&self, ctx: impl ReadContext) -> Result<u16, Error>;
    async fn float_single(&self, ctx: impl ReadContext) -> Result<f32, Error>;
    async fn float_double(&self, ctx: impl ReadContext) -> Result<f64, Error>;
    async fn octet_string<P>(
        &self,
        ctx: impl ReadContext,
        builder: OctetsBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn list_int_8_u<P>(
        &self,
        ctx: impl ReadContext,
        builder: ArrayAttributeRead<ToTLVArrayBuilder<P, u8>, ToTLVBuilder<P, u8>>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn list_octet_string<P>(
        &self,
        ctx: impl ReadContext,
        builder: ArrayAttributeRead<OctetsArrayBuilder<P>, OctetsBuilder<P>>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn list_struct_octet_string<P>(
        &self,
        ctx: impl ReadContext,
        builder: ArrayAttributeRead<TestListStructOctetArrayBuilder<P>, TestListStructOctetBuilder<P>>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn long_octet_string<P>(
        &self,
        ctx: impl ReadContext,
        builder: OctetsBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn char_string<P>(
        &self,
        ctx: impl ReadContext,
        builder: Utf8StrBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn long_char_string<P>(
        &self,
        ctx: impl ReadContext,
        builder: Utf8StrBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn epoch_us(&self, ctx: impl ReadContext) -> Result<u64, Error>;
    async fn epoch_s(&self, ctx: impl ReadContext) -> Result<u32, Error>;
    async fn vendor_id(&self, ctx: impl ReadContext) -> Result<u16, Error>;
    async fn list_nullables_and_optionals_struct<P>(
        &self,
        ctx: impl ReadContext,
        builder: ArrayAttributeRead<NullablesAndOptionalsStructArrayBuilder<P>, NullablesAndOptionalsStructBuilder<P>>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn enum_attr(
        &self,
        ctx: impl ReadContext,
    ) -> Result<SimpleEnum, Error>;
    async fn struct_attr<P>(
        &self,
        ctx: impl ReadContext,
        builder: SimpleStructBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn range_restricted_int_8_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<u8, Error>;
    async fn range_restricted_int_8_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<i8, Error>;
    async fn range_restricted_int_16_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<u16, Error>;
    async fn range_restricted_int_16_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<i16, Error>;
    async fn list_long_octet_string<P>(
        &self,
        ctx: impl ReadContext,
        builder: ArrayAttributeRead<OctetsArrayBuilder<P>, OctetsBuilder<P>>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn list_fabric_scoped<P>(
        &self,
        ctx: impl ReadContext,
        builder: ArrayAttributeRead<TestFabricScopedArrayBuilder<P>, TestFabricScopedBuilder<P>>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn timed_write_boolean(
        &self,
        ctx: impl ReadContext,
    ) -> Result<bool, Error>;
    async fn general_error_boolean(
        &self,
        ctx: impl ReadContext,
    ) -> Result<bool, Error>;
    async fn cluster_error_boolean(
        &self,
        ctx: impl ReadContext,
    ) -> Result<bool, Error>;
    async fn global_enum(
        &self,
        ctx: impl ReadContext,
    ) -> Result<TestGlobalEnum, Error>;
    async fn global_struct<P>(
        &self,
        ctx: impl ReadContext,
        builder: TestGlobalStructBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn nullable_boolean(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<bool, AsNullable>, Error>;
    async fn nullable_bitmap_8(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<Bitmap8MaskMap, AsNullable>, Error>;
    async fn nullable_bitmap_16(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<Bitmap16MaskMap, AsNullable>, Error>;
    async fn nullable_bitmap_32(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<Bitmap32MaskMap, AsNullable>, Error>;
    async fn nullable_bitmap_64(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<Bitmap64MaskMap, AsNullable>, Error>;
    async fn nullable_int_8_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u8, AsNullable>, Error>;
    async fn nullable_int_16_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u16, AsNullable>, Error>;
    async fn nullable_int_24_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u32, AsNullable>, Error>;
    async fn nullable_int_32_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u32, AsNullable>, Error>;
    async fn nullable_int_40_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u64, AsNullable>, Error>;
    async fn nullable_int_48_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u64, AsNullable>, Error>;
    async fn nullable_int_56_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u64, AsNullable>, Error>;
    async fn nullable_int_64_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u64, AsNullable>, Error>;
    async fn nullable_int_8_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<i8, AsNullable>, Error>;
    async fn nullable_int_16_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<i16, AsNullable>, Error>;
    async fn nullable_int_24_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<i32, AsNullable>, Error>;
    async fn nullable_int_32_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<i32, AsNullable>, Error>;
    async fn nullable_int_40_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<i64, AsNullable>, Error>;
    async fn nullable_int_48_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<i64, AsNullable>, Error>;
    async fn nullable_int_56_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<i64, AsNullable>, Error>;
    async fn nullable_int_64_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<i64, AsNullable>, Error>;
    async fn nullable_enum_8(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u8, AsNullable>, Error>;
    async fn nullable_enum_16(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u16, AsNullable>, Error>;
    async fn nullable_float_single(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<f32, AsNullable>, Error>;
    async fn nullable_float_double(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<f64, AsNullable>, Error>;
    async fn nullable_octet_string<P>(
        &self,
        ctx: impl ReadContext,
        builder: NullableBuilder<P, OctetsBuilder<P>>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn nullable_char_string<P>(
        &self,
        ctx: impl ReadContext,
        builder: NullableBuilder<P, Utf8StrBuilder<P>>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn nullable_enum_attr(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<SimpleEnum, AsNullable>, Error>;
    async fn nullable_struct<P>(
        &self,
        ctx: impl ReadContext,
        builder: NullableBuilder<P, SimpleStructBuilder<P>>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn nullable_range_restricted_int_8_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u8, AsNullable>, Error>;
    async fn nullable_range_restricted_int_8_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<i8, AsNullable>, Error>;
    async fn nullable_range_restricted_int_16_u(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<u16, AsNullable>, Error>;
    async fn nullable_range_restricted_int_16_s(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<i16, AsNullable>, Error>;
    async fn nullable_global_enum(
        &self,
        ctx: impl ReadContext,
    ) -> Result<Maybe<TestGlobalEnum, AsNullable>, Error>;
    async fn nullable_global_struct<P>(
        &self,
        ctx: impl ReadContext,
        builder: NullableBuilder<P, TestGlobalStructBuilder<P>>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn mei_int_8_u(&self, ctx: impl ReadContext) -> Result<u8, Error>;
    async fn set_boolean(
        &self,
        ctx: impl WriteContext,
        value: bool,
    ) -> Result<(), Error>;
    async fn set_bitmap_8(
        &self,
        ctx: impl WriteContext,
        value: Bitmap8MaskMap,
    ) -> Result<(), Error>;
    async fn set_bitmap_16(
        &self,
        ctx: impl WriteContext,
        value: Bitmap16MaskMap,
    ) -> Result<(), Error>;
    async fn set_bitmap_32(
        &self,
        ctx: impl WriteContext,
        value: Bitmap32MaskMap,
    ) -> Result<(), Error>;
    async fn set_bitmap_64(
        &self,
        ctx: impl WriteContext,
        value: Bitmap64MaskMap,
    ) -> Result<(), Error>;
    async fn set_int_8_u(
        &self,
        ctx: impl WriteContext,
        value: u8,
    ) -> Result<(), Error>;
    async fn set_int_16_u(
        &self,
        ctx: impl WriteContext,
        value: u16,
    ) -> Result<(), Error>;
    async fn set_int_24_u(
        &self,
        ctx: impl WriteContext,
        value: u32,
    ) -> Result<(), Error>;
    async fn set_int_32_u(
        &self,
        ctx: impl WriteContext,
        value: u32,
    ) -> Result<(), Error>;
    async fn set_int_40_u(
        &self,
        ctx: impl WriteContext,
        value: u64,
    ) -> Result<(), Error>;
    async fn set_int_48_u(
        &self,
        ctx: impl WriteContext,
        value: u64,
    ) -> Result<(), Error>;
    async fn set_int_56_u(
        &self,
        ctx: impl WriteContext,
        value: u64,
    ) -> Result<(), Error>;
    async fn set_int_64_u(
        &self,
        ctx: impl WriteContext,
        value: u64,
    ) -> Result<(), Error>;
    async fn set_int_8_s(
        &self,
        ctx: impl WriteContext,
        value: i8,
    ) -> Result<(), Error>;
    async fn set_int_16_s(
        &self,
        ctx: impl WriteContext,
        value: i16,
    ) -> Result<(), Error>;
    async fn set_int_24_s(
        &self,
        ctx: impl WriteContext,
        value: i32,
    ) -> Result<(), Error>;
    async fn set_int_32_s(
        &self,
        ctx: impl WriteContext,
        value: i32,
    ) -> Result<(), Error>;
    async fn set_int_40_s(
        &self,
        ctx: impl WriteContext,
        value: i64,
    ) -> Result<(), Error>;
    async fn set_int_48_s(
        &self,
        ctx: impl WriteContext,
        value: i64,
    ) -> Result<(), Error>;
    async fn set_int_56_s(
        &self,
        ctx: impl WriteContext,
        value: i64,
    ) -> Result<(), Error>;
    async fn set_int_64_s(
        &self,
        ctx: impl WriteContext,
        value: i64,
    ) -> Result<(), Error>;
    async fn set_enum_8(
        &self,
        ctx: impl WriteContext,
        value: u8,
    ) -> Result<(), Error>;
    async fn set_enum_16(
        &self,
        ctx: impl WriteContext,
        value: u16,
    ) -> Result<(), Error>;
    async fn set_float_single(
        &self,
        ctx: impl WriteContext,
        value: f32,
    ) -> Result<(), Error>;
    async fn set_float_double(
        &self,
        ctx: impl WriteContext,
        value: f64,
    ) -> Result<(), Error>;
    async fn set_octet_string(
        &self,
        ctx: impl WriteContext,
        value: Octets<'_>,
    ) -> Result<(), Error>;
    async fn set_list_int_8_u(
        &self,
        ctx: impl WriteContext,
        value: ArrayAttributeWrite<TLVContainer<'_, u8, ArrayContainer>, u8>,
    ) -> Result<(), Error>;
    async fn set_list_octet_string(
        &self,
        ctx: impl WriteContext,
        value: ArrayAttributeWrite<TLVContainer<'_, Octets<'_>, ArrayContainer>, Octets<'_>>,
    ) -> Result<(), Error>;
    async fn set_list_struct_octet_string(
        &self,
        ctx: impl WriteContext,
        value: ArrayAttributeWrite<TLVContainer<'_, TestListStructOctet<'_>, ArrayContainer>, TestListStructOctet<'_>>,
    ) -> Result<(), Error>;
    async fn set_long_octet_string(
        &self,
        ctx: impl WriteContext,
        value: Octets<'_>,
    ) -> Result<(), Error>;
    async fn set_char_string(
        &self,
        ctx: impl WriteContext,
        value: &str,
    ) -> Result<(), Error>;
    async fn set_long_char_string(
        &self,
        ctx: impl WriteContext,
        value: &str,
    ) -> Result<(), Error>;
    async fn set_epoch_us(
        &self,
        ctx: impl WriteContext,
        value: u64,
    ) -> Result<(), Error>;
    async fn set_epoch_s(
        &self,
        ctx: impl WriteContext,
        value: u32,
    ) -> Result<(), Error>;
    async fn set_vendor_id(
        &self,
        ctx: impl WriteContext,
        value: u16,
    ) -> Result<(), Error>;
    async fn set_list_nullables_and_optionals_struct(
        &self,
        ctx: impl WriteContext,
        value: ArrayAttributeWrite<TLVContainer<'_, NullablesAndOptionalsStruct<'_>, ArrayContainer>, NullablesAndOptionalsStruct<'_>>,
    ) -> Result<(), Error>;
    async fn set_enum_attr(
        &self,
        ctx: impl WriteContext,
        value: SimpleEnum,
    ) -> Result<(), Error>;
    async fn set_struct_attr(
        &self,
        ctx: impl WriteContext,
        value: SimpleStruct<'_>,
    ) -> Result<(), Error>;
    async fn set_range_restricted_int_8_u(
        &self,
        ctx: impl WriteContext,
        value: u8,
    ) -> Result<(), Error>;
    async fn set_range_restricted_int_8_s(
        &self,
        ctx: impl WriteContext,
        value: i8,
    ) -> Result<(), Error>;
    async fn set_range_restricted_int_16_u(
        &self,
        ctx: impl WriteContext,
        value: u16,
    ) -> Result<(), Error>;
    async fn set_range_restricted_int_16_s(
        &self,
        ctx: impl WriteContext,
        value: i16,
    ) -> Result<(), Error>;
    async fn set_list_long_octet_string(
        &self,
        ctx: impl WriteContext,
        value: ArrayAttributeWrite<TLVContainer<'_, Octets<'_>, ArrayContainer>, Octets<'_>>,
    ) -> Result<(), Error>;
    async fn set_list_fabric_scoped(
        &self,
        ctx: impl WriteContext,
        value: ArrayAttributeWrite<TLVContainer<'_, TestFabricScoped<'_>, ArrayContainer>, TestFabricScoped<'_>>,
    ) -> Result<(), Error>;
    async fn set_timed_write_boolean(
        &self,
        ctx: impl WriteContext,
        value: bool,
    ) -> Result<(), Error>;
    async fn set_general_error_boolean(
        &self,
        ctx: impl WriteContext,
        value: bool,
    ) -> Result<(), Error>;
    async fn set_cluster_error_boolean(
        &self,
        ctx: impl WriteContext,
        value: bool,
    ) -> Result<(), Error>;
    async fn set_global_enum(
        &self,
        ctx: impl WriteContext,
        value: TestGlobalEnum,
    ) -> Result<(), Error>;
    async fn set_global_struct(
        &self,
        ctx: impl WriteContext,
        value: TestGlobalStruct<'_>,
    ) -> Result<(), Error>;
    async fn set_nullable_boolean(
        &self,
        ctx: impl WriteContext,
        value: Maybe<bool, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_bitmap_8(
        &self,
        ctx: impl WriteContext,
        value: Maybe<Bitmap8MaskMap, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_bitmap_16(
        &self,
        ctx: impl WriteContext,
        value: Maybe<Bitmap16MaskMap, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_bitmap_32(
        &self,
        ctx: impl WriteContext,
        value: Maybe<Bitmap32MaskMap, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_bitmap_64(
        &self,
        ctx: impl WriteContext,
        value: Maybe<Bitmap64MaskMap, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_8_u(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u8, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_16_u(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u16, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_24_u(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u32, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_32_u(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u32, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_40_u(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u64, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_48_u(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u64, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_56_u(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u64, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_64_u(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u64, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_8_s(
        &self,
        ctx: impl WriteContext,
        value: Maybe<i8, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_16_s(
        &self,
        ctx: impl WriteContext,
        value: Maybe<i16, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_24_s(
        &self,
        ctx: impl WriteContext,
        value: Maybe<i32, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_32_s(
        &self,
        ctx: impl WriteContext,
        value: Maybe<i32, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_40_s(
        &self,
        ctx: impl WriteContext,
        value: Maybe<i64, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_48_s(
        &self,
        ctx: impl WriteContext,
        value: Maybe<i64, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_56_s(
        &self,
        ctx: impl WriteContext,
        value: Maybe<i64, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_int_64_s(
        &self,
        ctx: impl WriteContext,
        value: Maybe<i64, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_enum_8(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u8, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_enum_16(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u16, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_float_single(
        &self,
        ctx: impl WriteContext,
        value: Maybe<f32, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_float_double(
        &self,
        ctx: impl WriteContext,
        value: Maybe<f64, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_octet_string(
        &self,
        ctx: impl WriteContext,
        value: Maybe<Octets<'_>, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_char_string(
        &self,
        ctx: impl WriteContext,
        value: Maybe<&str, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_enum_attr(
        &self,
        ctx: impl WriteContext,
        value: Maybe<SimpleEnum, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_struct(
        &self,
        ctx: impl WriteContext,
        value: Maybe<SimpleStruct<'_>, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_range_restricted_int_8_u(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u8, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_range_restricted_int_8_s(
        &self,
        ctx: impl WriteContext,
        value: Maybe<i8, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_range_restricted_int_16_u(
        &self,
        ctx: impl WriteContext,
        value: Maybe<u16, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_range_restricted_int_16_s(
        &self,
        ctx: impl WriteContext,
        value: Maybe<i16, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_global_enum(
        &self,
        ctx: impl WriteContext,
        value: Maybe<TestGlobalEnum, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_nullable_global_struct(
        &self,
        ctx: impl WriteContext,
        value: Maybe<TestGlobalStruct<'_>, AsNullable>,
    ) -> Result<(), Error>;
    async fn set_mei_int_8_u(
        &self,
        ctx: impl WriteContext,
        value: u8,
    ) -> Result<(), Error>;
    async fn handle_test(&self, ctx: impl InvokeContext) -> Result<(), Error>;
    async fn handle_test_not_handled(
        &self,
        ctx: impl InvokeContext,
    ) -> Result<(), Error>;
    async fn handle_test_specific<P>(
        &self,
        ctx: impl InvokeContext,
        response: TestSpecificResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_unknown_command(
        &self,
        ctx: impl InvokeContext,
    ) -> Result<(), Error>;
    async fn handle_test_add_arguments<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestAddArgumentsRequest<'_>,
        response: TestAddArgumentsResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_simple_argument_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestSimpleArgumentRequestRequest<'_>,
        response: TestSimpleArgumentResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_struct_array_argument_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestStructArrayArgumentRequestRequest<'_>,
        response: TestStructArrayArgumentResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_struct_argument_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestStructArgumentRequestRequest<'_>,
        response: BooleanResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_nested_struct_argument_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestNestedStructArgumentRequestRequest<'_>,
        response: BooleanResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_list_struct_argument_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestListStructArgumentRequestRequest<'_>,
        response: BooleanResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_list_int_8_u_argument_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestListInt8UArgumentRequestRequest<'_>,
        response: BooleanResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_nested_struct_list_argument_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestNestedStructListArgumentRequestRequest<'_>,
        response: BooleanResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_list_nested_struct_list_argument_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestListNestedStructListArgumentRequestRequest<'_>,
        response: BooleanResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_list_int_8_u_reverse_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestListInt8UReverseRequestRequest<'_>,
        response: TestListInt8UReverseResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_enums_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestEnumsRequestRequest<'_>,
        response: TestEnumsResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_nullable_optional_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestNullableOptionalRequestRequest<'_>,
        response: TestNullableOptionalResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_complex_nullable_optional_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestComplexNullableOptionalRequestRequest<'_>,
        response: TestComplexNullableOptionalResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_simple_struct_echo_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: SimpleStructEchoRequestRequest<'_>,
        response: SimpleStructResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_timed_invoke_request(
        &self,
        ctx: impl InvokeContext,
    ) -> Result<(), Error>;
    async fn handle_test_simple_optional_argument_request(
        &self,
        ctx: impl InvokeContext,
        request: TestSimpleOptionalArgumentRequestRequest<'_>,
    ) -> Result<(), Error>;
    async fn handle_test_emit_test_event_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestEmitTestEventRequestRequest<'_>,
        response: TestEmitTestEventResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_emit_test_fabric_scoped_event_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestEmitTestFabricScopedEventRequestRequest<'_>,
        response: TestEmitTestFabricScopedEventResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_batch_helper_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestBatchHelperRequestRequest<'_>,
        response: TestBatchHelperResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_second_batch_helper_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestSecondBatchHelperRequestRequest<'_>,
        response: TestBatchHelperResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_string_echo_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: StringEchoRequestRequest<'_>,
        response: StringEchoResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_global_echo_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: GlobalEchoRequestRequest<'_>,
        response: GlobalEchoResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;
    async fn handle_test_check_command_flags(
        &self,
        ctx: impl InvokeContext,
    ) -> Result<(), Error>;
    async fn handle_test_different_vendor_mei_request<P>(
        &self,
        ctx: impl InvokeContext,
        request: TestDifferentVendorMeiRequestRequest<'_>,
        response: TestDifferentVendorMeiResponseBuilder<P>,
    ) -> Result<P, Error>
       where P: TLVBuilderParent;

    // Provided methods
    fn lifecycle(
        &self,
        _ctx: impl HandlerContext,
        _op: LifecycleOp,
    ) -> Result<(), Error> { ... }
    fn run(
        &self,
        _ctx: impl HandlerContext,
    ) -> impl Future<Output = Result<(), Error>> { ... }
    fn unsupported_attribute_requiring_admin_privilege(
        &self,
        ctx: impl ReadContext,
    ) -> impl Future<Output = Result<bool, Error>> { ... }
    fn unsupported(
        &self,
        ctx: impl ReadContext,
    ) -> impl Future<Output = Result<bool, Error>> { ... }
    fn read_failure_code(
        &self,
        ctx: impl ReadContext,
    ) -> impl Future<Output = Result<u8, Error>> { ... }
    fn failure_int_32_u(
        &self,
        ctx: impl ReadContext,
    ) -> impl Future<Output = Result<u32, Error>> { ... }
    fn set_unsupported_attribute_requiring_admin_privilege(
        &self,
        ctx: impl WriteContext,
        value: bool,
    ) -> impl Future<Output = Result<(), Error>> { ... }
    fn set_unsupported(
        &self,
        ctx: impl WriteContext,
        value: bool,
    ) -> impl Future<Output = Result<(), Error>> { ... }
    fn set_read_failure_code(
        &self,
        ctx: impl WriteContext,
        value: u8,
    ) -> impl Future<Output = Result<(), Error>> { ... }
    fn set_failure_int_32_u(
        &self,
        ctx: impl WriteContext,
        value: u32,
    ) -> impl Future<Output = Result<(), Error>> { ... }
    fn set_write_only_int_8_u(
        &self,
        ctx: impl WriteContext,
        value: u8,
    ) -> impl Future<Output = Result<(), Error>> { ... }
}

The handler trait for the cluster.

Required Associated Constants

const CLUSTER: Cluster<'static>

The cluster-metadata corresponding to this handler trait.

Required Methods

fn dataver(&self) -> u32

fn dataver_changed(&self)

async fn boolean(&self, ctx: impl ReadContext) -> Result<bool, Error>

async fn bitmap_8(&self, ctx: impl ReadContext) -> Result<Bitmap8MaskMap, Error>

async fn bitmap_16( &self, ctx: impl ReadContext, ) -> Result<Bitmap16MaskMap, Error>

async fn bitmap_32( &self, ctx: impl ReadContext, ) -> Result<Bitmap32MaskMap, Error>

async fn bitmap_64( &self, ctx: impl ReadContext, ) -> Result<Bitmap64MaskMap, Error>

async fn int_8_u(&self, ctx: impl ReadContext) -> Result<u8, Error>

async fn int_16_u(&self, ctx: impl ReadContext) -> Result<u16, Error>

async fn int_24_u(&self, ctx: impl ReadContext) -> Result<u32, Error>

async fn int_32_u(&self, ctx: impl ReadContext) -> Result<u32, Error>

async fn int_40_u(&self, ctx: impl ReadContext) -> Result<u64, Error>

async fn int_48_u(&self, ctx: impl ReadContext) -> Result<u64, Error>

async fn int_56_u(&self, ctx: impl ReadContext) -> Result<u64, Error>

async fn int_64_u(&self, ctx: impl ReadContext) -> Result<u64, Error>

async fn int_8_s(&self, ctx: impl ReadContext) -> Result<i8, Error>

async fn int_16_s(&self, ctx: impl ReadContext) -> Result<i16, Error>

async fn int_24_s(&self, ctx: impl ReadContext) -> Result<i32, Error>

async fn int_32_s(&self, ctx: impl ReadContext) -> Result<i32, Error>

async fn int_40_s(&self, ctx: impl ReadContext) -> Result<i64, Error>

async fn int_48_s(&self, ctx: impl ReadContext) -> Result<i64, Error>

async fn int_56_s(&self, ctx: impl ReadContext) -> Result<i64, Error>

async fn int_64_s(&self, ctx: impl ReadContext) -> Result<i64, Error>

async fn enum_8(&self, ctx: impl ReadContext) -> Result<u8, Error>

async fn enum_16(&self, ctx: impl ReadContext) -> Result<u16, Error>

async fn float_single(&self, ctx: impl ReadContext) -> Result<f32, Error>

async fn float_double(&self, ctx: impl ReadContext) -> Result<f64, Error>

async fn octet_string<P>( &self, ctx: impl ReadContext, builder: OctetsBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn list_int_8_u<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<ToTLVArrayBuilder<P, u8>, ToTLVBuilder<P, u8>>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn list_octet_string<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<OctetsArrayBuilder<P>, OctetsBuilder<P>>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn list_struct_octet_string<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<TestListStructOctetArrayBuilder<P>, TestListStructOctetBuilder<P>>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn long_octet_string<P>( &self, ctx: impl ReadContext, builder: OctetsBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn char_string<P>( &self, ctx: impl ReadContext, builder: Utf8StrBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn long_char_string<P>( &self, ctx: impl ReadContext, builder: Utf8StrBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn epoch_us(&self, ctx: impl ReadContext) -> Result<u64, Error>

async fn epoch_s(&self, ctx: impl ReadContext) -> Result<u32, Error>

async fn vendor_id(&self, ctx: impl ReadContext) -> Result<u16, Error>

async fn list_nullables_and_optionals_struct<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<NullablesAndOptionalsStructArrayBuilder<P>, NullablesAndOptionalsStructBuilder<P>>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn enum_attr(&self, ctx: impl ReadContext) -> Result<SimpleEnum, Error>

async fn struct_attr<P>( &self, ctx: impl ReadContext, builder: SimpleStructBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn range_restricted_int_8_u( &self, ctx: impl ReadContext, ) -> Result<u8, Error>

async fn range_restricted_int_8_s( &self, ctx: impl ReadContext, ) -> Result<i8, Error>

async fn range_restricted_int_16_u( &self, ctx: impl ReadContext, ) -> Result<u16, Error>

async fn range_restricted_int_16_s( &self, ctx: impl ReadContext, ) -> Result<i16, Error>

async fn list_long_octet_string<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<OctetsArrayBuilder<P>, OctetsBuilder<P>>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn list_fabric_scoped<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<TestFabricScopedArrayBuilder<P>, TestFabricScopedBuilder<P>>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn timed_write_boolean( &self, ctx: impl ReadContext, ) -> Result<bool, Error>

async fn general_error_boolean( &self, ctx: impl ReadContext, ) -> Result<bool, Error>

async fn cluster_error_boolean( &self, ctx: impl ReadContext, ) -> Result<bool, Error>

async fn global_enum( &self, ctx: impl ReadContext, ) -> Result<TestGlobalEnum, Error>

async fn global_struct<P>( &self, ctx: impl ReadContext, builder: TestGlobalStructBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn nullable_boolean( &self, ctx: impl ReadContext, ) -> Result<Maybe<bool, AsNullable>, Error>

async fn nullable_bitmap_8( &self, ctx: impl ReadContext, ) -> Result<Maybe<Bitmap8MaskMap, AsNullable>, Error>

async fn nullable_bitmap_16( &self, ctx: impl ReadContext, ) -> Result<Maybe<Bitmap16MaskMap, AsNullable>, Error>

async fn nullable_bitmap_32( &self, ctx: impl ReadContext, ) -> Result<Maybe<Bitmap32MaskMap, AsNullable>, Error>

async fn nullable_bitmap_64( &self, ctx: impl ReadContext, ) -> Result<Maybe<Bitmap64MaskMap, AsNullable>, Error>

async fn nullable_int_8_u( &self, ctx: impl ReadContext, ) -> Result<Maybe<u8, AsNullable>, Error>

async fn nullable_int_16_u( &self, ctx: impl ReadContext, ) -> Result<Maybe<u16, AsNullable>, Error>

async fn nullable_int_24_u( &self, ctx: impl ReadContext, ) -> Result<Maybe<u32, AsNullable>, Error>

async fn nullable_int_32_u( &self, ctx: impl ReadContext, ) -> Result<Maybe<u32, AsNullable>, Error>

async fn nullable_int_40_u( &self, ctx: impl ReadContext, ) -> Result<Maybe<u64, AsNullable>, Error>

async fn nullable_int_48_u( &self, ctx: impl ReadContext, ) -> Result<Maybe<u64, AsNullable>, Error>

async fn nullable_int_56_u( &self, ctx: impl ReadContext, ) -> Result<Maybe<u64, AsNullable>, Error>

async fn nullable_int_64_u( &self, ctx: impl ReadContext, ) -> Result<Maybe<u64, AsNullable>, Error>

async fn nullable_int_8_s( &self, ctx: impl ReadContext, ) -> Result<Maybe<i8, AsNullable>, Error>

async fn nullable_int_16_s( &self, ctx: impl ReadContext, ) -> Result<Maybe<i16, AsNullable>, Error>

async fn nullable_int_24_s( &self, ctx: impl ReadContext, ) -> Result<Maybe<i32, AsNullable>, Error>

async fn nullable_int_32_s( &self, ctx: impl ReadContext, ) -> Result<Maybe<i32, AsNullable>, Error>

async fn nullable_int_40_s( &self, ctx: impl ReadContext, ) -> Result<Maybe<i64, AsNullable>, Error>

async fn nullable_int_48_s( &self, ctx: impl ReadContext, ) -> Result<Maybe<i64, AsNullable>, Error>

async fn nullable_int_56_s( &self, ctx: impl ReadContext, ) -> Result<Maybe<i64, AsNullable>, Error>

async fn nullable_int_64_s( &self, ctx: impl ReadContext, ) -> Result<Maybe<i64, AsNullable>, Error>

async fn nullable_enum_8( &self, ctx: impl ReadContext, ) -> Result<Maybe<u8, AsNullable>, Error>

async fn nullable_enum_16( &self, ctx: impl ReadContext, ) -> Result<Maybe<u16, AsNullable>, Error>

async fn nullable_float_single( &self, ctx: impl ReadContext, ) -> Result<Maybe<f32, AsNullable>, Error>

async fn nullable_float_double( &self, ctx: impl ReadContext, ) -> Result<Maybe<f64, AsNullable>, Error>

async fn nullable_octet_string<P>( &self, ctx: impl ReadContext, builder: NullableBuilder<P, OctetsBuilder<P>>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn nullable_char_string<P>( &self, ctx: impl ReadContext, builder: NullableBuilder<P, Utf8StrBuilder<P>>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn nullable_enum_attr( &self, ctx: impl ReadContext, ) -> Result<Maybe<SimpleEnum, AsNullable>, Error>

async fn nullable_struct<P>( &self, ctx: impl ReadContext, builder: NullableBuilder<P, SimpleStructBuilder<P>>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn nullable_range_restricted_int_8_u( &self, ctx: impl ReadContext, ) -> Result<Maybe<u8, AsNullable>, Error>

async fn nullable_range_restricted_int_8_s( &self, ctx: impl ReadContext, ) -> Result<Maybe<i8, AsNullable>, Error>

async fn nullable_range_restricted_int_16_u( &self, ctx: impl ReadContext, ) -> Result<Maybe<u16, AsNullable>, Error>

async fn nullable_range_restricted_int_16_s( &self, ctx: impl ReadContext, ) -> Result<Maybe<i16, AsNullable>, Error>

async fn nullable_global_enum( &self, ctx: impl ReadContext, ) -> Result<Maybe<TestGlobalEnum, AsNullable>, Error>

async fn nullable_global_struct<P>( &self, ctx: impl ReadContext, builder: NullableBuilder<P, TestGlobalStructBuilder<P>>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn mei_int_8_u(&self, ctx: impl ReadContext) -> Result<u8, Error>

async fn set_boolean( &self, ctx: impl WriteContext, value: bool, ) -> Result<(), Error>

async fn set_bitmap_8( &self, ctx: impl WriteContext, value: Bitmap8MaskMap, ) -> Result<(), Error>

async fn set_bitmap_16( &self, ctx: impl WriteContext, value: Bitmap16MaskMap, ) -> Result<(), Error>

async fn set_bitmap_32( &self, ctx: impl WriteContext, value: Bitmap32MaskMap, ) -> Result<(), Error>

async fn set_bitmap_64( &self, ctx: impl WriteContext, value: Bitmap64MaskMap, ) -> Result<(), Error>

async fn set_int_8_u( &self, ctx: impl WriteContext, value: u8, ) -> Result<(), Error>

async fn set_int_16_u( &self, ctx: impl WriteContext, value: u16, ) -> Result<(), Error>

async fn set_int_24_u( &self, ctx: impl WriteContext, value: u32, ) -> Result<(), Error>

async fn set_int_32_u( &self, ctx: impl WriteContext, value: u32, ) -> Result<(), Error>

async fn set_int_40_u( &self, ctx: impl WriteContext, value: u64, ) -> Result<(), Error>

async fn set_int_48_u( &self, ctx: impl WriteContext, value: u64, ) -> Result<(), Error>

async fn set_int_56_u( &self, ctx: impl WriteContext, value: u64, ) -> Result<(), Error>

async fn set_int_64_u( &self, ctx: impl WriteContext, value: u64, ) -> Result<(), Error>

async fn set_int_8_s( &self, ctx: impl WriteContext, value: i8, ) -> Result<(), Error>

async fn set_int_16_s( &self, ctx: impl WriteContext, value: i16, ) -> Result<(), Error>

async fn set_int_24_s( &self, ctx: impl WriteContext, value: i32, ) -> Result<(), Error>

async fn set_int_32_s( &self, ctx: impl WriteContext, value: i32, ) -> Result<(), Error>

async fn set_int_40_s( &self, ctx: impl WriteContext, value: i64, ) -> Result<(), Error>

async fn set_int_48_s( &self, ctx: impl WriteContext, value: i64, ) -> Result<(), Error>

async fn set_int_56_s( &self, ctx: impl WriteContext, value: i64, ) -> Result<(), Error>

async fn set_int_64_s( &self, ctx: impl WriteContext, value: i64, ) -> Result<(), Error>

async fn set_enum_8( &self, ctx: impl WriteContext, value: u8, ) -> Result<(), Error>

async fn set_enum_16( &self, ctx: impl WriteContext, value: u16, ) -> Result<(), Error>

async fn set_float_single( &self, ctx: impl WriteContext, value: f32, ) -> Result<(), Error>

async fn set_float_double( &self, ctx: impl WriteContext, value: f64, ) -> Result<(), Error>

async fn set_octet_string( &self, ctx: impl WriteContext, value: Octets<'_>, ) -> Result<(), Error>

async fn set_list_int_8_u( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, u8, ArrayContainer>, u8>, ) -> Result<(), Error>

async fn set_list_octet_string( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, Octets<'_>, ArrayContainer>, Octets<'_>>, ) -> Result<(), Error>

async fn set_list_struct_octet_string( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, TestListStructOctet<'_>, ArrayContainer>, TestListStructOctet<'_>>, ) -> Result<(), Error>

async fn set_long_octet_string( &self, ctx: impl WriteContext, value: Octets<'_>, ) -> Result<(), Error>

async fn set_char_string( &self, ctx: impl WriteContext, value: &str, ) -> Result<(), Error>

async fn set_long_char_string( &self, ctx: impl WriteContext, value: &str, ) -> Result<(), Error>

async fn set_epoch_us( &self, ctx: impl WriteContext, value: u64, ) -> Result<(), Error>

async fn set_epoch_s( &self, ctx: impl WriteContext, value: u32, ) -> Result<(), Error>

async fn set_vendor_id( &self, ctx: impl WriteContext, value: u16, ) -> Result<(), Error>

async fn set_list_nullables_and_optionals_struct( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, NullablesAndOptionalsStruct<'_>, ArrayContainer>, NullablesAndOptionalsStruct<'_>>, ) -> Result<(), Error>

async fn set_enum_attr( &self, ctx: impl WriteContext, value: SimpleEnum, ) -> Result<(), Error>

async fn set_struct_attr( &self, ctx: impl WriteContext, value: SimpleStruct<'_>, ) -> Result<(), Error>

async fn set_range_restricted_int_8_u( &self, ctx: impl WriteContext, value: u8, ) -> Result<(), Error>

async fn set_range_restricted_int_8_s( &self, ctx: impl WriteContext, value: i8, ) -> Result<(), Error>

async fn set_range_restricted_int_16_u( &self, ctx: impl WriteContext, value: u16, ) -> Result<(), Error>

async fn set_range_restricted_int_16_s( &self, ctx: impl WriteContext, value: i16, ) -> Result<(), Error>

async fn set_list_long_octet_string( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, Octets<'_>, ArrayContainer>, Octets<'_>>, ) -> Result<(), Error>

async fn set_list_fabric_scoped( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, TestFabricScoped<'_>, ArrayContainer>, TestFabricScoped<'_>>, ) -> Result<(), Error>

async fn set_timed_write_boolean( &self, ctx: impl WriteContext, value: bool, ) -> Result<(), Error>

async fn set_general_error_boolean( &self, ctx: impl WriteContext, value: bool, ) -> Result<(), Error>

async fn set_cluster_error_boolean( &self, ctx: impl WriteContext, value: bool, ) -> Result<(), Error>

async fn set_global_enum( &self, ctx: impl WriteContext, value: TestGlobalEnum, ) -> Result<(), Error>

async fn set_global_struct( &self, ctx: impl WriteContext, value: TestGlobalStruct<'_>, ) -> Result<(), Error>

async fn set_nullable_boolean( &self, ctx: impl WriteContext, value: Maybe<bool, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_bitmap_8( &self, ctx: impl WriteContext, value: Maybe<Bitmap8MaskMap, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_bitmap_16( &self, ctx: impl WriteContext, value: Maybe<Bitmap16MaskMap, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_bitmap_32( &self, ctx: impl WriteContext, value: Maybe<Bitmap32MaskMap, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_bitmap_64( &self, ctx: impl WriteContext, value: Maybe<Bitmap64MaskMap, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_8_u( &self, ctx: impl WriteContext, value: Maybe<u8, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_16_u( &self, ctx: impl WriteContext, value: Maybe<u16, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_24_u( &self, ctx: impl WriteContext, value: Maybe<u32, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_32_u( &self, ctx: impl WriteContext, value: Maybe<u32, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_40_u( &self, ctx: impl WriteContext, value: Maybe<u64, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_48_u( &self, ctx: impl WriteContext, value: Maybe<u64, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_56_u( &self, ctx: impl WriteContext, value: Maybe<u64, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_64_u( &self, ctx: impl WriteContext, value: Maybe<u64, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_8_s( &self, ctx: impl WriteContext, value: Maybe<i8, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_16_s( &self, ctx: impl WriteContext, value: Maybe<i16, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_24_s( &self, ctx: impl WriteContext, value: Maybe<i32, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_32_s( &self, ctx: impl WriteContext, value: Maybe<i32, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_40_s( &self, ctx: impl WriteContext, value: Maybe<i64, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_48_s( &self, ctx: impl WriteContext, value: Maybe<i64, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_56_s( &self, ctx: impl WriteContext, value: Maybe<i64, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_int_64_s( &self, ctx: impl WriteContext, value: Maybe<i64, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_enum_8( &self, ctx: impl WriteContext, value: Maybe<u8, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_enum_16( &self, ctx: impl WriteContext, value: Maybe<u16, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_float_single( &self, ctx: impl WriteContext, value: Maybe<f32, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_float_double( &self, ctx: impl WriteContext, value: Maybe<f64, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_octet_string( &self, ctx: impl WriteContext, value: Maybe<Octets<'_>, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_char_string( &self, ctx: impl WriteContext, value: Maybe<&str, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_enum_attr( &self, ctx: impl WriteContext, value: Maybe<SimpleEnum, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_struct( &self, ctx: impl WriteContext, value: Maybe<SimpleStruct<'_>, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_range_restricted_int_8_u( &self, ctx: impl WriteContext, value: Maybe<u8, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_range_restricted_int_8_s( &self, ctx: impl WriteContext, value: Maybe<i8, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_range_restricted_int_16_u( &self, ctx: impl WriteContext, value: Maybe<u16, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_range_restricted_int_16_s( &self, ctx: impl WriteContext, value: Maybe<i16, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_global_enum( &self, ctx: impl WriteContext, value: Maybe<TestGlobalEnum, AsNullable>, ) -> Result<(), Error>

async fn set_nullable_global_struct( &self, ctx: impl WriteContext, value: Maybe<TestGlobalStruct<'_>, AsNullable>, ) -> Result<(), Error>

async fn set_mei_int_8_u( &self, ctx: impl WriteContext, value: u8, ) -> Result<(), Error>

async fn handle_test(&self, ctx: impl InvokeContext) -> Result<(), Error>

async fn handle_test_not_handled( &self, ctx: impl InvokeContext, ) -> Result<(), Error>

async fn handle_test_specific<P>( &self, ctx: impl InvokeContext, response: TestSpecificResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_unknown_command( &self, ctx: impl InvokeContext, ) -> Result<(), Error>

async fn handle_test_add_arguments<P>( &self, ctx: impl InvokeContext, request: TestAddArgumentsRequest<'_>, response: TestAddArgumentsResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_simple_argument_request<P>( &self, ctx: impl InvokeContext, request: TestSimpleArgumentRequestRequest<'_>, response: TestSimpleArgumentResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_struct_array_argument_request<P>( &self, ctx: impl InvokeContext, request: TestStructArrayArgumentRequestRequest<'_>, response: TestStructArrayArgumentResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_struct_argument_request<P>( &self, ctx: impl InvokeContext, request: TestStructArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_nested_struct_argument_request<P>( &self, ctx: impl InvokeContext, request: TestNestedStructArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_list_struct_argument_request<P>( &self, ctx: impl InvokeContext, request: TestListStructArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_list_int_8_u_argument_request<P>( &self, ctx: impl InvokeContext, request: TestListInt8UArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_nested_struct_list_argument_request<P>( &self, ctx: impl InvokeContext, request: TestNestedStructListArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_list_nested_struct_list_argument_request<P>( &self, ctx: impl InvokeContext, request: TestListNestedStructListArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_list_int_8_u_reverse_request<P>( &self, ctx: impl InvokeContext, request: TestListInt8UReverseRequestRequest<'_>, response: TestListInt8UReverseResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_enums_request<P>( &self, ctx: impl InvokeContext, request: TestEnumsRequestRequest<'_>, response: TestEnumsResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_nullable_optional_request<P>( &self, ctx: impl InvokeContext, request: TestNullableOptionalRequestRequest<'_>, response: TestNullableOptionalResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_complex_nullable_optional_request<P>( &self, ctx: impl InvokeContext, request: TestComplexNullableOptionalRequestRequest<'_>, response: TestComplexNullableOptionalResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_simple_struct_echo_request<P>( &self, ctx: impl InvokeContext, request: SimpleStructEchoRequestRequest<'_>, response: SimpleStructResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_timed_invoke_request( &self, ctx: impl InvokeContext, ) -> Result<(), Error>

async fn handle_test_simple_optional_argument_request( &self, ctx: impl InvokeContext, request: TestSimpleOptionalArgumentRequestRequest<'_>, ) -> Result<(), Error>

async fn handle_test_emit_test_event_request<P>( &self, ctx: impl InvokeContext, request: TestEmitTestEventRequestRequest<'_>, response: TestEmitTestEventResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_emit_test_fabric_scoped_event_request<P>( &self, ctx: impl InvokeContext, request: TestEmitTestFabricScopedEventRequestRequest<'_>, response: TestEmitTestFabricScopedEventResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_batch_helper_request<P>( &self, ctx: impl InvokeContext, request: TestBatchHelperRequestRequest<'_>, response: TestBatchHelperResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_second_batch_helper_request<P>( &self, ctx: impl InvokeContext, request: TestSecondBatchHelperRequestRequest<'_>, response: TestBatchHelperResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_string_echo_request<P>( &self, ctx: impl InvokeContext, request: StringEchoRequestRequest<'_>, response: StringEchoResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_global_echo_request<P>( &self, ctx: impl InvokeContext, request: GlobalEchoRequestRequest<'_>, response: GlobalEchoResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

async fn handle_test_check_command_flags( &self, ctx: impl InvokeContext, ) -> Result<(), Error>

async fn handle_test_different_vendor_mei_request<P>( &self, ctx: impl InvokeContext, request: TestDifferentVendorMeiRequestRequest<'_>, response: TestDifferentVendorMeiResponseBuilder<P>, ) -> Result<P, Error>

where P: TLVBuilderParent,

Provided Methods

fn lifecycle( &self, _ctx: impl HandlerContext, _op: LifecycleOp, ) -> Result<(), Error>

fn run( &self, _ctx: impl HandlerContext, ) -> impl Future<Output = Result<(), Error>>

fn unsupported_attribute_requiring_admin_privilege( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<bool, Error>>

fn unsupported( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<bool, Error>>

fn read_failure_code( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u8, Error>>

fn failure_int_32_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u32, Error>>

fn set_unsupported_attribute_requiring_admin_privilege( &self, ctx: impl WriteContext, value: bool, ) -> impl Future<Output = Result<(), Error>>

fn set_unsupported( &self, ctx: impl WriteContext, value: bool, ) -> impl Future<Output = Result<(), Error>>

fn set_read_failure_code( &self, ctx: impl WriteContext, value: u8, ) -> impl Future<Output = Result<(), Error>>

fn set_failure_int_32_u( &self, ctx: impl WriteContext, value: u32, ) -> impl Future<Output = Result<(), Error>>

fn set_write_only_int_8_u( &self, ctx: impl WriteContext, value: u8, ) -> impl Future<Output = Result<(), Error>>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T> ClusterAsyncHandler for &T

where T: ClusterAsyncHandler,

const CLUSTER: Cluster<'static> = T::CLUSTER

fn dataver(&self) -> u32

fn dataver_changed(&self)

fn lifecycle( &self, ctx: impl HandlerContext, op: LifecycleOp, ) -> Result<(), Error>

fn run( &self, ctx: impl HandlerContext, ) -> impl Future<Output = Result<(), Error>>

fn boolean( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<bool, Error>>

fn bitmap_8( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Bitmap8MaskMap, Error>>

fn bitmap_16( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Bitmap16MaskMap, Error>>

fn bitmap_32( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Bitmap32MaskMap, Error>>

fn bitmap_64( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Bitmap64MaskMap, Error>>

fn int_8_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u8, Error>>

fn int_16_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u16, Error>>

fn int_24_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u32, Error>>

fn int_32_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u32, Error>>

fn int_40_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u64, Error>>

fn int_48_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u64, Error>>

fn int_56_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u64, Error>>

fn int_64_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u64, Error>>

fn int_8_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<i8, Error>>

fn int_16_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<i16, Error>>

fn int_24_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<i32, Error>>

fn int_32_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<i32, Error>>

fn int_40_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<i64, Error>>

fn int_48_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<i64, Error>>

fn int_56_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<i64, Error>>

fn int_64_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<i64, Error>>

fn enum_8( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u8, Error>>

fn enum_16( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u16, Error>>

fn float_single( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<f32, Error>>

fn float_double( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<f64, Error>>

fn octet_string<P>( &self, ctx: impl ReadContext, builder: OctetsBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn list_int_8_u<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<ToTLVArrayBuilder<P, u8>, ToTLVBuilder<P, u8>>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn list_octet_string<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<OctetsArrayBuilder<P>, OctetsBuilder<P>>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn list_struct_octet_string<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<TestListStructOctetArrayBuilder<P>, TestListStructOctetBuilder<P>>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn long_octet_string<P>( &self, ctx: impl ReadContext, builder: OctetsBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn char_string<P>( &self, ctx: impl ReadContext, builder: Utf8StrBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn long_char_string<P>( &self, ctx: impl ReadContext, builder: Utf8StrBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn epoch_us( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u64, Error>>

fn epoch_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u32, Error>>

fn vendor_id( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u16, Error>>

fn list_nullables_and_optionals_struct<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<NullablesAndOptionalsStructArrayBuilder<P>, NullablesAndOptionalsStructBuilder<P>>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn enum_attr( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<SimpleEnum, Error>>

fn struct_attr<P>( &self, ctx: impl ReadContext, builder: SimpleStructBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn range_restricted_int_8_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u8, Error>>

fn range_restricted_int_8_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<i8, Error>>

fn range_restricted_int_16_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u16, Error>>

fn range_restricted_int_16_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<i16, Error>>

fn list_long_octet_string<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<OctetsArrayBuilder<P>, OctetsBuilder<P>>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn list_fabric_scoped<P>( &self, ctx: impl ReadContext, builder: ArrayAttributeRead<TestFabricScopedArrayBuilder<P>, TestFabricScopedBuilder<P>>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn timed_write_boolean( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<bool, Error>>

fn general_error_boolean( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<bool, Error>>

fn cluster_error_boolean( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<bool, Error>>

fn global_enum( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<TestGlobalEnum, Error>>

fn global_struct<P>( &self, ctx: impl ReadContext, builder: TestGlobalStructBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn unsupported_attribute_requiring_admin_privilege( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<bool, Error>>

fn unsupported( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<bool, Error>>

fn read_failure_code( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u8, Error>>

fn failure_int_32_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u32, Error>>

fn nullable_boolean( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<bool, AsNullable>, Error>>

fn nullable_bitmap_8( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<Bitmap8MaskMap, AsNullable>, Error>>

fn nullable_bitmap_16( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<Bitmap16MaskMap, AsNullable>, Error>>

fn nullable_bitmap_32( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<Bitmap32MaskMap, AsNullable>, Error>>

fn nullable_bitmap_64( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<Bitmap64MaskMap, AsNullable>, Error>>

fn nullable_int_8_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u8, AsNullable>, Error>>

fn nullable_int_16_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u16, AsNullable>, Error>>

fn nullable_int_24_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u32, AsNullable>, Error>>

fn nullable_int_32_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u32, AsNullable>, Error>>

fn nullable_int_40_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u64, AsNullable>, Error>>

fn nullable_int_48_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u64, AsNullable>, Error>>

fn nullable_int_56_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u64, AsNullable>, Error>>

fn nullable_int_64_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u64, AsNullable>, Error>>

fn nullable_int_8_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<i8, AsNullable>, Error>>

fn nullable_int_16_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<i16, AsNullable>, Error>>

fn nullable_int_24_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<i32, AsNullable>, Error>>

fn nullable_int_32_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<i32, AsNullable>, Error>>

fn nullable_int_40_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<i64, AsNullable>, Error>>

fn nullable_int_48_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<i64, AsNullable>, Error>>

fn nullable_int_56_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<i64, AsNullable>, Error>>

fn nullable_int_64_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<i64, AsNullable>, Error>>

fn nullable_enum_8( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u8, AsNullable>, Error>>

fn nullable_enum_16( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u16, AsNullable>, Error>>

fn nullable_float_single( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<f32, AsNullable>, Error>>

fn nullable_float_double( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<f64, AsNullable>, Error>>

fn nullable_octet_string<P>( &self, ctx: impl ReadContext, builder: NullableBuilder<P, OctetsBuilder<P>>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn nullable_char_string<P>( &self, ctx: impl ReadContext, builder: NullableBuilder<P, Utf8StrBuilder<P>>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn nullable_enum_attr( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<SimpleEnum, AsNullable>, Error>>

fn nullable_struct<P>( &self, ctx: impl ReadContext, builder: NullableBuilder<P, SimpleStructBuilder<P>>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn nullable_range_restricted_int_8_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u8, AsNullable>, Error>>

fn nullable_range_restricted_int_8_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<i8, AsNullable>, Error>>

fn nullable_range_restricted_int_16_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<u16, AsNullable>, Error>>

fn nullable_range_restricted_int_16_s( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<i16, AsNullable>, Error>>

fn nullable_global_enum( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<Maybe<TestGlobalEnum, AsNullable>, Error>>

fn nullable_global_struct<P>( &self, ctx: impl ReadContext, builder: NullableBuilder<P, TestGlobalStructBuilder<P>>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn mei_int_8_u( &self, ctx: impl ReadContext, ) -> impl Future<Output = Result<u8, Error>>

fn set_boolean( &self, ctx: impl WriteContext, value: bool, ) -> impl Future<Output = Result<(), Error>>

fn set_bitmap_8( &self, ctx: impl WriteContext, value: Bitmap8MaskMap, ) -> impl Future<Output = Result<(), Error>>

fn set_bitmap_16( &self, ctx: impl WriteContext, value: Bitmap16MaskMap, ) -> impl Future<Output = Result<(), Error>>

fn set_bitmap_32( &self, ctx: impl WriteContext, value: Bitmap32MaskMap, ) -> impl Future<Output = Result<(), Error>>

fn set_bitmap_64( &self, ctx: impl WriteContext, value: Bitmap64MaskMap, ) -> impl Future<Output = Result<(), Error>>

fn set_int_8_u( &self, ctx: impl WriteContext, value: u8, ) -> impl Future<Output = Result<(), Error>>

fn set_int_16_u( &self, ctx: impl WriteContext, value: u16, ) -> impl Future<Output = Result<(), Error>>

fn set_int_24_u( &self, ctx: impl WriteContext, value: u32, ) -> impl Future<Output = Result<(), Error>>

fn set_int_32_u( &self, ctx: impl WriteContext, value: u32, ) -> impl Future<Output = Result<(), Error>>

fn set_int_40_u( &self, ctx: impl WriteContext, value: u64, ) -> impl Future<Output = Result<(), Error>>

fn set_int_48_u( &self, ctx: impl WriteContext, value: u64, ) -> impl Future<Output = Result<(), Error>>

fn set_int_56_u( &self, ctx: impl WriteContext, value: u64, ) -> impl Future<Output = Result<(), Error>>

fn set_int_64_u( &self, ctx: impl WriteContext, value: u64, ) -> impl Future<Output = Result<(), Error>>

fn set_int_8_s( &self, ctx: impl WriteContext, value: i8, ) -> impl Future<Output = Result<(), Error>>

fn set_int_16_s( &self, ctx: impl WriteContext, value: i16, ) -> impl Future<Output = Result<(), Error>>

fn set_int_24_s( &self, ctx: impl WriteContext, value: i32, ) -> impl Future<Output = Result<(), Error>>

fn set_int_32_s( &self, ctx: impl WriteContext, value: i32, ) -> impl Future<Output = Result<(), Error>>

fn set_int_40_s( &self, ctx: impl WriteContext, value: i64, ) -> impl Future<Output = Result<(), Error>>

fn set_int_48_s( &self, ctx: impl WriteContext, value: i64, ) -> impl Future<Output = Result<(), Error>>

fn set_int_56_s( &self, ctx: impl WriteContext, value: i64, ) -> impl Future<Output = Result<(), Error>>

fn set_int_64_s( &self, ctx: impl WriteContext, value: i64, ) -> impl Future<Output = Result<(), Error>>

fn set_enum_8( &self, ctx: impl WriteContext, value: u8, ) -> impl Future<Output = Result<(), Error>>

fn set_enum_16( &self, ctx: impl WriteContext, value: u16, ) -> impl Future<Output = Result<(), Error>>

fn set_float_single( &self, ctx: impl WriteContext, value: f32, ) -> impl Future<Output = Result<(), Error>>

fn set_float_double( &self, ctx: impl WriteContext, value: f64, ) -> impl Future<Output = Result<(), Error>>

fn set_octet_string( &self, ctx: impl WriteContext, value: Octets<'_>, ) -> impl Future<Output = Result<(), Error>>

fn set_list_int_8_u( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, u8, ArrayContainer>, u8>, ) -> impl Future<Output = Result<(), Error>>

fn set_list_octet_string( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, Octets<'_>, ArrayContainer>, Octets<'_>>, ) -> impl Future<Output = Result<(), Error>>

fn set_list_struct_octet_string( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, TestListStructOctet<'_>, ArrayContainer>, TestListStructOctet<'_>>, ) -> impl Future<Output = Result<(), Error>>

fn set_long_octet_string( &self, ctx: impl WriteContext, value: Octets<'_>, ) -> impl Future<Output = Result<(), Error>>

fn set_char_string( &self, ctx: impl WriteContext, value: &str, ) -> impl Future<Output = Result<(), Error>>

fn set_long_char_string( &self, ctx: impl WriteContext, value: &str, ) -> impl Future<Output = Result<(), Error>>

fn set_epoch_us( &self, ctx: impl WriteContext, value: u64, ) -> impl Future<Output = Result<(), Error>>

fn set_epoch_s( &self, ctx: impl WriteContext, value: u32, ) -> impl Future<Output = Result<(), Error>>

fn set_vendor_id( &self, ctx: impl WriteContext, value: u16, ) -> impl Future<Output = Result<(), Error>>

fn set_list_nullables_and_optionals_struct( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, NullablesAndOptionalsStruct<'_>, ArrayContainer>, NullablesAndOptionalsStruct<'_>>, ) -> impl Future<Output = Result<(), Error>>

fn set_enum_attr( &self, ctx: impl WriteContext, value: SimpleEnum, ) -> impl Future<Output = Result<(), Error>>

fn set_struct_attr( &self, ctx: impl WriteContext, value: SimpleStruct<'_>, ) -> impl Future<Output = Result<(), Error>>

fn set_range_restricted_int_8_u( &self, ctx: impl WriteContext, value: u8, ) -> impl Future<Output = Result<(), Error>>

fn set_range_restricted_int_8_s( &self, ctx: impl WriteContext, value: i8, ) -> impl Future<Output = Result<(), Error>>

fn set_range_restricted_int_16_u( &self, ctx: impl WriteContext, value: u16, ) -> impl Future<Output = Result<(), Error>>

fn set_range_restricted_int_16_s( &self, ctx: impl WriteContext, value: i16, ) -> impl Future<Output = Result<(), Error>>

fn set_list_long_octet_string( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, Octets<'_>, ArrayContainer>, Octets<'_>>, ) -> impl Future<Output = Result<(), Error>>

fn set_list_fabric_scoped( &self, ctx: impl WriteContext, value: ArrayAttributeWrite<TLVContainer<'_, TestFabricScoped<'_>, ArrayContainer>, TestFabricScoped<'_>>, ) -> impl Future<Output = Result<(), Error>>

fn set_timed_write_boolean( &self, ctx: impl WriteContext, value: bool, ) -> impl Future<Output = Result<(), Error>>

fn set_general_error_boolean( &self, ctx: impl WriteContext, value: bool, ) -> impl Future<Output = Result<(), Error>>

fn set_cluster_error_boolean( &self, ctx: impl WriteContext, value: bool, ) -> impl Future<Output = Result<(), Error>>

fn set_global_enum( &self, ctx: impl WriteContext, value: TestGlobalEnum, ) -> impl Future<Output = Result<(), Error>>

fn set_global_struct( &self, ctx: impl WriteContext, value: TestGlobalStruct<'_>, ) -> impl Future<Output = Result<(), Error>>

fn set_unsupported_attribute_requiring_admin_privilege( &self, ctx: impl WriteContext, value: bool, ) -> impl Future<Output = Result<(), Error>>

fn set_unsupported( &self, ctx: impl WriteContext, value: bool, ) -> impl Future<Output = Result<(), Error>>

fn set_read_failure_code( &self, ctx: impl WriteContext, value: u8, ) -> impl Future<Output = Result<(), Error>>

fn set_failure_int_32_u( &self, ctx: impl WriteContext, value: u32, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_boolean( &self, ctx: impl WriteContext, value: Maybe<bool, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_bitmap_8( &self, ctx: impl WriteContext, value: Maybe<Bitmap8MaskMap, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_bitmap_16( &self, ctx: impl WriteContext, value: Maybe<Bitmap16MaskMap, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_bitmap_32( &self, ctx: impl WriteContext, value: Maybe<Bitmap32MaskMap, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_bitmap_64( &self, ctx: impl WriteContext, value: Maybe<Bitmap64MaskMap, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_8_u( &self, ctx: impl WriteContext, value: Maybe<u8, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_16_u( &self, ctx: impl WriteContext, value: Maybe<u16, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_24_u( &self, ctx: impl WriteContext, value: Maybe<u32, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_32_u( &self, ctx: impl WriteContext, value: Maybe<u32, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_40_u( &self, ctx: impl WriteContext, value: Maybe<u64, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_48_u( &self, ctx: impl WriteContext, value: Maybe<u64, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_56_u( &self, ctx: impl WriteContext, value: Maybe<u64, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_64_u( &self, ctx: impl WriteContext, value: Maybe<u64, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_8_s( &self, ctx: impl WriteContext, value: Maybe<i8, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_16_s( &self, ctx: impl WriteContext, value: Maybe<i16, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_24_s( &self, ctx: impl WriteContext, value: Maybe<i32, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_32_s( &self, ctx: impl WriteContext, value: Maybe<i32, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_40_s( &self, ctx: impl WriteContext, value: Maybe<i64, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_48_s( &self, ctx: impl WriteContext, value: Maybe<i64, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_56_s( &self, ctx: impl WriteContext, value: Maybe<i64, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_int_64_s( &self, ctx: impl WriteContext, value: Maybe<i64, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_enum_8( &self, ctx: impl WriteContext, value: Maybe<u8, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_enum_16( &self, ctx: impl WriteContext, value: Maybe<u16, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_float_single( &self, ctx: impl WriteContext, value: Maybe<f32, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_float_double( &self, ctx: impl WriteContext, value: Maybe<f64, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_octet_string( &self, ctx: impl WriteContext, value: Maybe<Octets<'_>, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_char_string( &self, ctx: impl WriteContext, value: Maybe<&str, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_enum_attr( &self, ctx: impl WriteContext, value: Maybe<SimpleEnum, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_struct( &self, ctx: impl WriteContext, value: Maybe<SimpleStruct<'_>, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_range_restricted_int_8_u( &self, ctx: impl WriteContext, value: Maybe<u8, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_range_restricted_int_8_s( &self, ctx: impl WriteContext, value: Maybe<i8, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_range_restricted_int_16_u( &self, ctx: impl WriteContext, value: Maybe<u16, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_range_restricted_int_16_s( &self, ctx: impl WriteContext, value: Maybe<i16, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_write_only_int_8_u( &self, ctx: impl WriteContext, value: u8, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_global_enum( &self, ctx: impl WriteContext, value: Maybe<TestGlobalEnum, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_nullable_global_struct( &self, ctx: impl WriteContext, value: Maybe<TestGlobalStruct<'_>, AsNullable>, ) -> impl Future<Output = Result<(), Error>>

fn set_mei_int_8_u( &self, ctx: impl WriteContext, value: u8, ) -> impl Future<Output = Result<(), Error>>

fn handle_test( &self, ctx: impl InvokeContext, ) -> impl Future<Output = Result<(), Error>>

fn handle_test_not_handled( &self, ctx: impl InvokeContext, ) -> impl Future<Output = Result<(), Error>>

fn handle_test_specific<P>( &self, ctx: impl InvokeContext, response: TestSpecificResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_unknown_command( &self, ctx: impl InvokeContext, ) -> impl Future<Output = Result<(), Error>>

fn handle_test_add_arguments<P>( &self, ctx: impl InvokeContext, request: TestAddArgumentsRequest<'_>, response: TestAddArgumentsResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_simple_argument_request<P>( &self, ctx: impl InvokeContext, request: TestSimpleArgumentRequestRequest<'_>, response: TestSimpleArgumentResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_struct_array_argument_request<P>( &self, ctx: impl InvokeContext, request: TestStructArrayArgumentRequestRequest<'_>, response: TestStructArrayArgumentResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_struct_argument_request<P>( &self, ctx: impl InvokeContext, request: TestStructArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_nested_struct_argument_request<P>( &self, ctx: impl InvokeContext, request: TestNestedStructArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_list_struct_argument_request<P>( &self, ctx: impl InvokeContext, request: TestListStructArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_list_int_8_u_argument_request<P>( &self, ctx: impl InvokeContext, request: TestListInt8UArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_nested_struct_list_argument_request<P>( &self, ctx: impl InvokeContext, request: TestNestedStructListArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_list_nested_struct_list_argument_request<P>( &self, ctx: impl InvokeContext, request: TestListNestedStructListArgumentRequestRequest<'_>, response: BooleanResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_list_int_8_u_reverse_request<P>( &self, ctx: impl InvokeContext, request: TestListInt8UReverseRequestRequest<'_>, response: TestListInt8UReverseResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_enums_request<P>( &self, ctx: impl InvokeContext, request: TestEnumsRequestRequest<'_>, response: TestEnumsResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_nullable_optional_request<P>( &self, ctx: impl InvokeContext, request: TestNullableOptionalRequestRequest<'_>, response: TestNullableOptionalResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_complex_nullable_optional_request<P>( &self, ctx: impl InvokeContext, request: TestComplexNullableOptionalRequestRequest<'_>, response: TestComplexNullableOptionalResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_simple_struct_echo_request<P>( &self, ctx: impl InvokeContext, request: SimpleStructEchoRequestRequest<'_>, response: SimpleStructResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_timed_invoke_request( &self, ctx: impl InvokeContext, ) -> impl Future<Output = Result<(), Error>>

fn handle_test_simple_optional_argument_request( &self, ctx: impl InvokeContext, request: TestSimpleOptionalArgumentRequestRequest<'_>, ) -> impl Future<Output = Result<(), Error>>

fn handle_test_emit_test_event_request<P>( &self, ctx: impl InvokeContext, request: TestEmitTestEventRequestRequest<'_>, response: TestEmitTestEventResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_emit_test_fabric_scoped_event_request<P>( &self, ctx: impl InvokeContext, request: TestEmitTestFabricScopedEventRequestRequest<'_>, response: TestEmitTestFabricScopedEventResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_batch_helper_request<P>( &self, ctx: impl InvokeContext, request: TestBatchHelperRequestRequest<'_>, response: TestBatchHelperResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_second_batch_helper_request<P>( &self, ctx: impl InvokeContext, request: TestSecondBatchHelperRequestRequest<'_>, response: TestBatchHelperResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_string_echo_request<P>( &self, ctx: impl InvokeContext, request: StringEchoRequestRequest<'_>, response: StringEchoResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_global_echo_request<P>( &self, ctx: impl InvokeContext, request: GlobalEchoRequestRequest<'_>, response: GlobalEchoResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

fn handle_test_check_command_flags( &self, ctx: impl InvokeContext, ) -> impl Future<Output = Result<(), Error>>

fn handle_test_different_vendor_mei_request<P>( &self, ctx: impl InvokeContext, request: TestDifferentVendorMeiRequestRequest<'_>, response: TestDifferentVendorMeiResponseBuilder<P>, ) -> impl Future<Output = Result<P, Error>>

where P: TLVBuilderParent,

Implementors