#![allow(unused_imports)]
use crate::dm::conformance::{Clause, Condition, Conform, Conformance};
use crate::dm::meta::{EventPriority, Reporting};
use crate::dm::spec::{Attribute, Cluster, Command, Event, Feature};
use crate::dm::{Access, AccessQualities, AttributeQualities, Privilege};
use crate::error::Result;
use crate::im::{AttributeId, ClusterId, CommandId, EventId};
use crate::tlv::{
ContainerKind, Element, FromTlv, Nullable, Tag, TlvList, TlvReader, TlvWriter, ToTlv, Value,
};
pub const ID: ClusterId = 0x0555;
pub const REVISION: u16 = 2;
pub const PICS: &str = "PAVST";
pub mod feature {
pub const PER_ZONE_SENSITIVITY: u32 = 1 << 0;
pub const METADATA: u32 = 1 << 1;
}
pub const FEATURES: &[Feature] = &[
Feature {
bit: 0,
code: "PERZONESENS",
name: "PerZoneSensitivity",
conform: Conform::OPTIONAL,
},
Feature {
bit: 1,
code: "METADATA",
name: "Metadata",
conform: Conform {
clauses: &[
Clause {
verdict: Conformance::Provisional,
when: Condition::Always,
},
Clause {
verdict: Conformance::Optional,
when: Condition::Always,
},
],
},
},
];
pub mod attribute {
use crate::im::AttributeId;
pub const SUPPORTED_FORMATS: AttributeId = 0x00;
pub const CURRENT_CONNECTIONS: AttributeId = 0x01;
}
pub mod command {
use crate::im::CommandId;
pub const ALLOCATE_PUSH_TRANSPORT: CommandId = 0x00;
pub const ALLOCATE_PUSH_TRANSPORT_RESPONSE: CommandId = 0x01;
pub const DEALLOCATE_PUSH_TRANSPORT: CommandId = 0x02;
pub const MODIFY_PUSH_TRANSPORT: CommandId = 0x03;
pub const SET_TRANSPORT_STATUS: CommandId = 0x04;
pub const MANUALLY_TRIGGER_TRANSPORT: CommandId = 0x05;
pub const FIND_TRANSPORT: CommandId = 0x06;
pub const FIND_TRANSPORT_RESPONSE: CommandId = 0x07;
}
pub mod event {
use crate::im::EventId;
pub const PUSH_TRANSPORT_BEGIN: EventId = 0x00;
pub const PUSH_TRANSPORT_END: EventId = 0x01;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum CMAFInterfaceEnum {
Interface1 = 0,
Interface2DASH = 1,
Interface2HLS = 2,
}
impl CMAFInterfaceEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Interface1),
1 => Some(Self::Interface2DASH),
2 => Some(Self::Interface2HLS),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for CMAFInterfaceEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for CMAFInterfaceEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum ContainerFormatEnum {
CMAF = 0,
}
impl ContainerFormatEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::CMAF),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for ContainerFormatEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for ContainerFormatEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum IngestMethodsEnum {
CMAFIngest = 0,
}
impl IngestMethodsEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::CMAFIngest),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for IngestMethodsEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for IngestMethodsEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum StatusCodeEnum {
InvalidTLSEndpoint = 2,
InvalidStream = 3,
InvalidURL = 4,
InvalidZone = 5,
InvalidCombination = 6,
InvalidTriggerType = 7,
InvalidTransportStatus = 8,
InvalidOptions = 9,
InvalidStreamUsage = 10,
InvalidTime = 11,
InvalidPreRollLength = 12,
DuplicateStreamValues = 13,
}
impl StatusCodeEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
2 => Some(Self::InvalidTLSEndpoint),
3 => Some(Self::InvalidStream),
4 => Some(Self::InvalidURL),
5 => Some(Self::InvalidZone),
6 => Some(Self::InvalidCombination),
7 => Some(Self::InvalidTriggerType),
8 => Some(Self::InvalidTransportStatus),
9 => Some(Self::InvalidOptions),
10 => Some(Self::InvalidStreamUsage),
11 => Some(Self::InvalidTime),
12 => Some(Self::InvalidPreRollLength),
13 => Some(Self::DuplicateStreamValues),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for StatusCodeEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for StatusCodeEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum TransportStatusEnum {
Active = 0,
Inactive = 1,
}
impl TransportStatusEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Active),
1 => Some(Self::Inactive),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for TransportStatusEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for TransportStatusEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum TransportTriggerTypeEnum {
Command = 0,
Motion = 1,
Continuous = 2,
}
impl TransportTriggerTypeEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Command),
1 => Some(Self::Motion),
2 => Some(Self::Continuous),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for TransportTriggerTypeEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for TransportTriggerTypeEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum TriggerActivationReasonEnum {
UserInitiated = 0,
Automation = 1,
Emergency = 2,
DoorbellPressed = 3,
}
impl TriggerActivationReasonEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::UserInitiated),
1 => Some(Self::Automation),
2 => Some(Self::Emergency),
3 => Some(Self::DoorbellPressed),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for TriggerActivationReasonEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for TriggerActivationReasonEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AudioStreamStruct<'a> {
pub audio_stream_name: &'a str,
pub audio_stream_id: u16,
}
impl<'a> ToTlv for AudioStreamStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.audio_stream_name.to_tlv(w, Tag::Context(0))?;
self.audio_stream_id.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for AudioStreamStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut audio_stream_name = None;
let mut audio_stream_id = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => audio_stream_name = Some(<&'a str>::from_tlv(reader, &field)?),
Some(1) => audio_stream_id = Some(<u16>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
audio_stream_name: audio_stream_name
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
audio_stream_id: audio_stream_id
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CMAFContainerOptionsStruct<'a> {
pub cmaf_interface: CMAFInterfaceEnum,
pub segment_duration: u16,
pub chunk_duration: u16,
pub session_group: Option<u8>,
pub track_name: Option<&'a str>,
pub metadata_enabled: Option<bool>,
}
impl<'a> ToTlv for CMAFContainerOptionsStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.cmaf_interface.to_tlv(w, Tag::Context(0))?;
self.segment_duration.to_tlv(w, Tag::Context(1))?;
self.chunk_duration.to_tlv(w, Tag::Context(2))?;
if let Some(value) = &self.session_group {
value.to_tlv(w, Tag::Context(3))?;
}
if let Some(value) = &self.track_name {
value.to_tlv(w, Tag::Context(4))?;
}
if let Some(value) = &self.metadata_enabled {
value.to_tlv(w, Tag::Context(7))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for CMAFContainerOptionsStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut cmaf_interface = None;
let mut segment_duration = None;
let mut chunk_duration = None;
let mut session_group = None;
let mut track_name = None;
let mut metadata_enabled = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => cmaf_interface = Some(<CMAFInterfaceEnum>::from_tlv(reader, &field)?),
Some(1) => segment_duration = Some(<u16>::from_tlv(reader, &field)?),
Some(2) => chunk_duration = Some(<u16>::from_tlv(reader, &field)?),
Some(3) => session_group = Some(<u8>::from_tlv(reader, &field)?),
Some(4) => track_name = Some(<&'a str>::from_tlv(reader, &field)?),
Some(7) => metadata_enabled = Some(<bool>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
cmaf_interface: cmaf_interface
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
segment_duration: segment_duration
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
chunk_duration: chunk_duration
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
session_group,
track_name,
metadata_enabled,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ContainerOptionsStruct<'a> {
pub container_type: ContainerFormatEnum,
pub cmaf_container_options: Option<CMAFContainerOptionsStruct<'a>>,
}
impl<'a> ToTlv for ContainerOptionsStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.container_type.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.cmaf_container_options {
value.to_tlv(w, Tag::Context(1))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for ContainerOptionsStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut container_type = None;
let mut cmaf_container_options = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => container_type = Some(<ContainerFormatEnum>::from_tlv(reader, &field)?),
Some(1) => {
cmaf_container_options =
Some(<CMAFContainerOptionsStruct<'a>>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
container_type: container_type
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
cmaf_container_options,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SupportedFormatStruct {
pub container_format: ContainerFormatEnum,
pub ingest_method: IngestMethodsEnum,
}
impl ToTlv for SupportedFormatStruct {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.container_format.to_tlv(w, Tag::Context(0))?;
self.ingest_method.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for SupportedFormatStruct {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut container_format = None;
let mut ingest_method = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
container_format = Some(<ContainerFormatEnum>::from_tlv(reader, &field)?)
}
Some(1) => ingest_method = Some(<IngestMethodsEnum>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
container_format: container_format
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
ingest_method: ingest_method.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TransportConfigurationStruct<'a> {
pub connection_id: u16,
pub transport_status: TransportStatusEnum,
pub transport_options: Option<TransportOptionsStruct<'a>>,
pub fabric_index: crate::msg::FabricIndex,
}
impl<'a> ToTlv for TransportConfigurationStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.connection_id.to_tlv(w, Tag::Context(0))?;
self.transport_status.to_tlv(w, Tag::Context(1))?;
if let Some(value) = &self.transport_options {
value.to_tlv(w, Tag::Context(2))?;
}
self.fabric_index.to_tlv(w, Tag::Context(254))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for TransportConfigurationStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut connection_id = None;
let mut transport_status = None;
let mut transport_options = None;
let mut fabric_index = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => connection_id = Some(<u16>::from_tlv(reader, &field)?),
Some(1) => {
transport_status = Some(<TransportStatusEnum>::from_tlv(reader, &field)?)
}
Some(2) => {
transport_options =
Some(<TransportOptionsStruct<'a>>::from_tlv(reader, &field)?)
}
Some(254) => {
fabric_index = Some(<crate::msg::FabricIndex>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
connection_id: connection_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
transport_status: transport_status
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
transport_options,
fabric_index: fabric_index.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TransportMotionTriggerTimeControlStruct {
pub initial_duration: u16,
pub augmentation_duration: u16,
pub max_duration: u32,
pub blind_duration: u16,
}
impl ToTlv for TransportMotionTriggerTimeControlStruct {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.initial_duration.to_tlv(w, Tag::Context(0))?;
self.augmentation_duration.to_tlv(w, Tag::Context(1))?;
self.max_duration.to_tlv(w, Tag::Context(2))?;
self.blind_duration.to_tlv(w, Tag::Context(3))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for TransportMotionTriggerTimeControlStruct {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut initial_duration = None;
let mut augmentation_duration = None;
let mut max_duration = None;
let mut blind_duration = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => initial_duration = Some(<u16>::from_tlv(reader, &field)?),
Some(1) => augmentation_duration = Some(<u16>::from_tlv(reader, &field)?),
Some(2) => max_duration = Some(<u32>::from_tlv(reader, &field)?),
Some(3) => blind_duration = Some(<u16>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
initial_duration: initial_duration
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
augmentation_duration: augmentation_duration
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
max_duration: max_duration.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
blind_duration: blind_duration
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TransportOptionsStruct<'a> {
pub stream_usage: crate::clusters::generated::globals::StreamUsageEnum,
pub video_stream_id: Option<Nullable<u16>>,
pub audio_stream_id: Option<Nullable<u16>>,
pub tls_endpoint_id: u16,
pub url: &'a str,
pub trigger_options: TransportTriggerOptionsStruct<'a>,
pub ingest_method: IngestMethodsEnum,
pub container_options: ContainerOptionsStruct<'a>,
pub expiry_time: Option<u32>,
pub video_streams: Option<TlvList<'a, VideoStreamStruct<'a>>>,
pub audio_streams: Option<TlvList<'a, AudioStreamStruct<'a>>>,
}
impl<'a> ToTlv for TransportOptionsStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.stream_usage.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.video_stream_id {
value.to_tlv(w, Tag::Context(1))?;
}
if let Some(value) = &self.audio_stream_id {
value.to_tlv(w, Tag::Context(2))?;
}
self.tls_endpoint_id.to_tlv(w, Tag::Context(3))?;
self.url.to_tlv(w, Tag::Context(4))?;
self.trigger_options.to_tlv(w, Tag::Context(5))?;
self.ingest_method.to_tlv(w, Tag::Context(6))?;
self.container_options.to_tlv(w, Tag::Context(7))?;
if let Some(value) = &self.expiry_time {
value.to_tlv(w, Tag::Context(8))?;
}
if let Some(value) = &self.video_streams {
value.to_tlv(w, Tag::Context(9))?;
}
if let Some(value) = &self.audio_streams {
value.to_tlv(w, Tag::Context(10))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for TransportOptionsStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut stream_usage = None;
let mut video_stream_id = None;
let mut audio_stream_id = None;
let mut tls_endpoint_id = None;
let mut url = None;
let mut trigger_options = None;
let mut ingest_method = None;
let mut container_options = None;
let mut expiry_time = None;
let mut video_streams = None;
let mut audio_streams = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
stream_usage = Some(
<crate::clusters::generated::globals::StreamUsageEnum>::from_tlv(
reader, &field,
)?,
)
}
Some(1) => video_stream_id = Some(<Nullable<u16>>::from_tlv(reader, &field)?),
Some(2) => audio_stream_id = Some(<Nullable<u16>>::from_tlv(reader, &field)?),
Some(3) => tls_endpoint_id = Some(<u16>::from_tlv(reader, &field)?),
Some(4) => url = Some(<&'a str>::from_tlv(reader, &field)?),
Some(5) => {
trigger_options = Some(<TransportTriggerOptionsStruct<'a>>::from_tlv(
reader, &field,
)?)
}
Some(6) => ingest_method = Some(<IngestMethodsEnum>::from_tlv(reader, &field)?),
Some(7) => {
container_options =
Some(<ContainerOptionsStruct<'a>>::from_tlv(reader, &field)?)
}
Some(8) => expiry_time = Some(<u32>::from_tlv(reader, &field)?),
Some(9) => {
video_streams = Some(<TlvList<'a, VideoStreamStruct<'a>>>::from_tlv(
reader, &field,
)?)
}
Some(10) => {
audio_streams = Some(<TlvList<'a, AudioStreamStruct<'a>>>::from_tlv(
reader, &field,
)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
stream_usage: stream_usage.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
video_stream_id,
audio_stream_id,
tls_endpoint_id: tls_endpoint_id
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
url: url.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
trigger_options: trigger_options
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
ingest_method: ingest_method.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
container_options: container_options
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
expiry_time,
video_streams,
audio_streams,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TransportTriggerOptionsStruct<'a> {
pub trigger_type: TransportTriggerTypeEnum,
pub motion_zones: Option<Nullable<TlvList<'a, TransportZoneOptionsStruct>>>,
pub motion_sensitivity: Option<Nullable<u8>>,
pub motion_time_control: Option<TransportMotionTriggerTimeControlStruct>,
pub max_pre_roll_len: Option<u16>,
}
impl<'a> ToTlv for TransportTriggerOptionsStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.trigger_type.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.motion_zones {
value.to_tlv(w, Tag::Context(1))?;
}
if let Some(value) = &self.motion_sensitivity {
value.to_tlv(w, Tag::Context(2))?;
}
if let Some(value) = &self.motion_time_control {
value.to_tlv(w, Tag::Context(3))?;
}
if let Some(value) = &self.max_pre_roll_len {
value.to_tlv(w, Tag::Context(4))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for TransportTriggerOptionsStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut trigger_type = None;
let mut motion_zones = None;
let mut motion_sensitivity = None;
let mut motion_time_control = None;
let mut max_pre_roll_len = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
trigger_type = Some(<TransportTriggerTypeEnum>::from_tlv(reader, &field)?)
}
Some(1) => {
motion_zones = Some(
<Nullable<TlvList<'a, TransportZoneOptionsStruct>>>::from_tlv(
reader, &field,
)?,
)
}
Some(2) => motion_sensitivity = Some(<Nullable<u8>>::from_tlv(reader, &field)?),
Some(3) => {
motion_time_control = Some(<TransportMotionTriggerTimeControlStruct>::from_tlv(
reader, &field,
)?)
}
Some(4) => max_pre_roll_len = Some(<u16>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
trigger_type: trigger_type.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
motion_zones,
motion_sensitivity,
motion_time_control,
max_pre_roll_len,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TransportZoneOptionsStruct {
pub zone: Nullable<u16>,
pub sensitivity: Option<u8>,
}
impl ToTlv for TransportZoneOptionsStruct {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.zone.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.sensitivity {
value.to_tlv(w, Tag::Context(1))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for TransportZoneOptionsStruct {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut zone = None;
let mut sensitivity = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => zone = Some(<Nullable<u16>>::from_tlv(reader, &field)?),
Some(1) => sensitivity = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
zone: zone.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
sensitivity,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct VideoStreamStruct<'a> {
pub video_stream_name: &'a str,
pub video_stream_id: u16,
}
impl<'a> ToTlv for VideoStreamStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.video_stream_name.to_tlv(w, Tag::Context(0))?;
self.video_stream_id.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for VideoStreamStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut video_stream_name = None;
let mut video_stream_id = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => video_stream_name = Some(<&'a str>::from_tlv(reader, &field)?),
Some(1) => video_stream_id = Some(<u16>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
video_stream_name: video_stream_name
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
video_stream_id: video_stream_id
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AllocatePushTransportFields<'a> {
pub transport_options: TransportOptionsStruct<'a>,
}
impl<'a> ToTlv for AllocatePushTransportFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.transport_options.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for AllocatePushTransportFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut transport_options = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
transport_options =
Some(<TransportOptionsStruct<'a>>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
transport_options: transport_options
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AllocatePushTransportResponseFields<'a> {
pub transport_configuration: TransportConfigurationStruct<'a>,
}
impl<'a> ToTlv for AllocatePushTransportResponseFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.transport_configuration.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for AllocatePushTransportResponseFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut transport_configuration = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
transport_configuration = Some(<TransportConfigurationStruct<'a>>::from_tlv(
reader, &field,
)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
transport_configuration: transport_configuration
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct DeallocatePushTransportFields {
pub connection_id: u16,
}
impl ToTlv for DeallocatePushTransportFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.connection_id.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for DeallocatePushTransportFields {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut connection_id = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => connection_id = Some(<u16>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
connection_id: connection_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ModifyPushTransportFields<'a> {
pub connection_id: u16,
pub transport_options: TransportOptionsStruct<'a>,
}
impl<'a> ToTlv for ModifyPushTransportFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.connection_id.to_tlv(w, Tag::Context(0))?;
self.transport_options.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for ModifyPushTransportFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut connection_id = None;
let mut transport_options = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => connection_id = Some(<u16>::from_tlv(reader, &field)?),
Some(1) => {
transport_options =
Some(<TransportOptionsStruct<'a>>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
connection_id: connection_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
transport_options: transport_options
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SetTransportStatusFields {
pub connection_id: Nullable<u16>,
pub transport_status: TransportStatusEnum,
}
impl ToTlv for SetTransportStatusFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.connection_id.to_tlv(w, Tag::Context(0))?;
self.transport_status.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for SetTransportStatusFields {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut connection_id = None;
let mut transport_status = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => connection_id = Some(<Nullable<u16>>::from_tlv(reader, &field)?),
Some(1) => {
transport_status = Some(<TransportStatusEnum>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
connection_id: connection_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
transport_status: transport_status
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ManuallyTriggerTransportFields<'a> {
pub connection_id: u16,
pub activation_reason: TriggerActivationReasonEnum,
pub time_control: Option<TransportMotionTriggerTimeControlStruct>,
pub user_defined: Option<&'a [u8]>,
}
impl<'a> ToTlv for ManuallyTriggerTransportFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.connection_id.to_tlv(w, Tag::Context(0))?;
self.activation_reason.to_tlv(w, Tag::Context(1))?;
if let Some(value) = &self.time_control {
value.to_tlv(w, Tag::Context(2))?;
}
if let Some(value) = &self.user_defined {
value.to_tlv(w, Tag::Context(3))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for ManuallyTriggerTransportFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut connection_id = None;
let mut activation_reason = None;
let mut time_control = None;
let mut user_defined = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => connection_id = Some(<u16>::from_tlv(reader, &field)?),
Some(1) => {
activation_reason =
Some(<TriggerActivationReasonEnum>::from_tlv(reader, &field)?)
}
Some(2) => {
time_control = Some(<TransportMotionTriggerTimeControlStruct>::from_tlv(
reader, &field,
)?)
}
Some(3) => user_defined = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
connection_id: connection_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
activation_reason: activation_reason
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
time_control,
user_defined,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct FindTransportFields {
pub connection_id: Nullable<u16>,
}
impl ToTlv for FindTransportFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.connection_id.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for FindTransportFields {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut connection_id = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => connection_id = Some(<Nullable<u16>>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
connection_id: connection_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct FindTransportResponseFields<'a> {
pub transport_configurations: TlvList<'a, TransportConfigurationStruct<'a>>,
}
impl<'a> ToTlv for FindTransportResponseFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.transport_configurations.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for FindTransportResponseFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut transport_configurations = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
transport_configurations = Some(
<TlvList<'a, TransportConfigurationStruct<'a>>>::from_tlv(reader, &field)?,
)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
transport_configurations: transport_configurations
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
pub const ATTRIBUTES: &[Attribute] = &[
Attribute {
id: 0x0000,
name: "SupportedFormats",
kind: "list[SupportedFormatStruct]",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0001,
name: "CurrentConnections",
kind: "list[TransportConfigurationStruct]",
access: Access::read_only(Privilege::View)
.with_qualities(AccessQualities::FABRIC_SENSITIVE),
qualities: AttributeQualities::NON_VOLATILE,
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
];
pub const COMMANDS: &[Command] = &[
Command {
id: 0x00,
name: "AllocatePushTransport",
to_server: true,
response: Some(0x01),
access: Access::invoke(Privilege::Manage)
.with_qualities(AccessQualities::FABRIC_SCOPED.union(AccessQualities::LARGE)),
conform: Conform::MANDATORY,
},
Command {
id: 0x01,
name: "AllocatePushTransportResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate).with_qualities(AccessQualities::LARGE),
conform: Conform::MANDATORY,
},
Command {
id: 0x02,
name: "DeallocatePushTransport",
to_server: true,
response: None,
access: Access::invoke(Privilege::Manage).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x03,
name: "ModifyPushTransport",
to_server: true,
response: None,
access: Access::invoke(Privilege::Manage).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x04,
name: "SetTransportStatus",
to_server: true,
response: None,
access: Access::invoke(Privilege::Manage).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x05,
name: "ManuallyTriggerTransport",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x06,
name: "FindTransport",
to_server: true,
response: Some(0x07),
access: Access::invoke(Privilege::Operate)
.with_qualities(AccessQualities::FABRIC_SCOPED.union(AccessQualities::LARGE)),
conform: Conform::MANDATORY,
},
Command {
id: 0x07,
name: "FindTransportResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate).with_qualities(AccessQualities::LARGE),
conform: Conform::MANDATORY,
},
];
pub const EVENTS: &[Event] = &[
Event {
id: 0x00,
name: "PushTransportBegin",
priority: EventPriority::Info,
access: Access::read_only(Privilege::View),
conform: Conform::MANDATORY,
},
Event {
id: 0x01,
name: "PushTransportEnd",
priority: EventPriority::Info,
access: Access::read_only(Privilege::View),
conform: Conform::MANDATORY,
},
];
pub const CLUSTER: Cluster = Cluster {
id: ID,
name: "Push AV Stream Transport",
revision: REVISION,
pics: "PAVST",
derived_from: None,
features: FEATURES,
attributes: ATTRIBUTES,
commands: COMMANDS,
events: EVENTS,
};