#[allow(
    non_camel_case_types,
    non_snake_case,
    non_upper_case_globals,
    unused,
    clippy::too_many_arguments
)]
pub mod denm_pdu_descriptions {
    extern crate alloc;
    use core::borrow::Borrow;

    use rasn::prelude::*;

    use super::super::cdd_1_3_1_1::its_container::{
        ActionID,
        CauseCode,
        ClosedLanes,
        DangerousGoodsExtended,
        DeltaReferencePosition,
        EnergyStorageType,
        EventHistory,
        Heading,
        HeightLonCarr,
        InformationQuality,
        ItineraryPath,
        ItsPduHeader,
        LanePosition,
        LightBarSirenInUse,
        NumberOfOccupants,
        PosCentMass,
        PosFrontAx,
        PosLonCarr,
        PositionOfOccupants,
        PositionOfPillars,
        PositioningSolutionType,
        ReferencePosition,
        RelevanceDistance,
        RelevanceTrafficDirection,
        RequestResponseIndication,
        RestrictedTypes,
        RoadType,
        Speed,
        SpeedLimit,
        StationType,
        StationarySince,
        Temperature,
        TimestampIts,
        Traces,
        TrafficRule,
        TransmissionInterval,
        TurningRadius,
        ValidityDuration,
        VehicleIdentification,
        VehicleMass,
        WheelBaseVehicle,
    };
    #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
    #[rasn(automatic_tags)]
    #[non_exhaustive]
    pub struct AlacarteContainer {
        #[rasn(identifier = "lanePosition")]
        pub lane_position: Option<LanePosition>,
        #[rasn(identifier = "impactReduction")]
        pub impact_reduction: Option<ImpactReductionContainer>,
        #[rasn(identifier = "externalTemperature")]
        pub external_temperature: Option<Temperature>,
        #[rasn(identifier = "roadWorks")]
        pub road_works: Option<RoadWorksContainerExtended>,
        #[rasn(identifier = "positioningSolution")]
        pub positioning_solution: Option<PositioningSolutionType>,
        #[rasn(identifier = "stationaryVehicle")]
        pub stationary_vehicle: Option<StationaryVehicleContainer>,
    }
    impl AlacarteContainer {
        pub fn new(
            lane_position: Option<LanePosition>,
            impact_reduction: Option<ImpactReductionContainer>,
            external_temperature: Option<Temperature>,
            road_works: Option<RoadWorksContainerExtended>,
            positioning_solution: Option<PositioningSolutionType>,
            stationary_vehicle: Option<StationaryVehicleContainer>,
        ) -> Self {
            Self {
                lane_position,
                impact_reduction,
                external_temperature,
                road_works,
                positioning_solution,
                stationary_vehicle,
            }
        }
    }
    #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
    #[rasn(automatic_tags)]
    pub struct DENM {
        pub header: ItsPduHeader,
        pub denm: DecentralizedEnvironmentalNotificationMessage,
    }
    impl DENM {
        pub fn new(
            header: ItsPduHeader,
            denm: DecentralizedEnvironmentalNotificationMessage,
        ) -> Self {
            Self { header, denm }
        }
    }
    #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
    #[rasn(automatic_tags)]
    pub struct DecentralizedEnvironmentalNotificationMessage {
        pub management: ManagementContainer,
        pub situation: Option<SituationContainer>,
        pub location: Option<LocationContainer>,
        pub alacarte: Option<AlacarteContainer>,
    }
    impl DecentralizedEnvironmentalNotificationMessage {
        pub fn new(
            management: ManagementContainer,
            situation: Option<SituationContainer>,
            location: Option<LocationContainer>,
            alacarte: Option<AlacarteContainer>,
        ) -> Self {
            Self {
                management,
                situation,
                location,
                alacarte,
            }
        }
    }
    #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
    #[rasn(automatic_tags)]
    pub struct ImpactReductionContainer {
        #[rasn(identifier = "heightLonCarrLeft")]
        pub height_lon_carr_left: HeightLonCarr,
        #[rasn(identifier = "heightLonCarrRight")]
        pub height_lon_carr_right: HeightLonCarr,
        #[rasn(identifier = "posLonCarrLeft")]
        pub pos_lon_carr_left: PosLonCarr,
        #[rasn(identifier = "posLonCarrRight")]
        pub pos_lon_carr_right: PosLonCarr,
        #[rasn(identifier = "positionOfPillars")]
        pub position_of_pillars: PositionOfPillars,
        #[rasn(identifier = "posCentMass")]
        pub pos_cent_mass: PosCentMass,
        #[rasn(identifier = "wheelBaseVehicle")]
        pub wheel_base_vehicle: WheelBaseVehicle,
        #[rasn(identifier = "turningRadius")]
        pub turning_radius: TurningRadius,
        #[rasn(identifier = "posFrontAx")]
        pub pos_front_ax: PosFrontAx,
        #[rasn(identifier = "positionOfOccupants")]
        pub position_of_occupants: PositionOfOccupants,
        #[rasn(identifier = "vehicleMass")]
        pub vehicle_mass: VehicleMass,
        #[rasn(identifier = "requestResponseIndication")]
        pub request_response_indication: RequestResponseIndication,
    }
    impl ImpactReductionContainer {
        pub fn new(
            height_lon_carr_left: HeightLonCarr,
            height_lon_carr_right: HeightLonCarr,
            pos_lon_carr_left: PosLonCarr,
            pos_lon_carr_right: PosLonCarr,
            position_of_pillars: PositionOfPillars,
            pos_cent_mass: PosCentMass,
            wheel_base_vehicle: WheelBaseVehicle,
            turning_radius: TurningRadius,
            pos_front_ax: PosFrontAx,
            position_of_occupants: PositionOfOccupants,
            vehicle_mass: VehicleMass,
            request_response_indication: RequestResponseIndication,
        ) -> Self {
            Self {
                height_lon_carr_left,
                height_lon_carr_right,
                pos_lon_carr_left,
                pos_lon_carr_right,
                position_of_pillars,
                pos_cent_mass,
                wheel_base_vehicle,
                turning_radius,
                pos_front_ax,
                position_of_occupants,
                vehicle_mass,
                request_response_indication,
            }
        }
    }
    #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
    #[rasn(automatic_tags)]
    #[non_exhaustive]
    pub struct LocationContainer {
        #[rasn(identifier = "eventSpeed")]
        pub event_speed: Option<Speed>,
        #[rasn(identifier = "eventPositionHeading")]
        pub event_position_heading: Option<Heading>,
        pub traces: Traces,
        #[rasn(identifier = "roadType")]
        pub road_type: Option<RoadType>,
    }
    impl LocationContainer {
        pub fn new(
            event_speed: Option<Speed>,
            event_position_heading: Option<Heading>,
            traces: Traces,
            road_type: Option<RoadType>,
        ) -> Self {
            Self {
                event_speed,
                event_position_heading,
                traces,
                road_type,
            }
        }
    }
    #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
    #[rasn(automatic_tags)]
    #[non_exhaustive]
    pub struct ManagementContainer {
        #[rasn(identifier = "actionID")]
        pub action_id: ActionID,
        #[rasn(identifier = "detectionTime")]
        pub detection_time: TimestampIts,
        #[rasn(identifier = "referenceTime")]
        pub reference_time: TimestampIts,
        pub termination: Option<Termination>,
        #[rasn(identifier = "eventPosition")]
        pub event_position: ReferencePosition,
        #[rasn(identifier = "relevanceDistance")]
        pub relevance_distance: Option<RelevanceDistance>,
        #[rasn(identifier = "relevanceTrafficDirection")]
        pub relevance_traffic_direction: Option<RelevanceTrafficDirection>,
        #[rasn(
            default = "management_container_validity_duration_default",
            identifier = "validityDuration"
        )]
        pub validity_duration: ValidityDuration,
        #[rasn(identifier = "transmissionInterval")]
        pub transmission_interval: Option<TransmissionInterval>,
        #[rasn(identifier = "stationType")]
        pub station_type: StationType,
    }
    impl ManagementContainer {
        pub fn new(
            action_id: ActionID,
            detection_time: TimestampIts,
            reference_time: TimestampIts,
            termination: Option<Termination>,
            event_position: ReferencePosition,
            relevance_distance: Option<RelevanceDistance>,
            relevance_traffic_direction: Option<RelevanceTrafficDirection>,
            validity_duration: ValidityDuration,
            transmission_interval: Option<TransmissionInterval>,
            station_type: StationType,
        ) -> Self {
            Self {
                action_id,
                detection_time,
                reference_time,
                termination,
                event_position,
                relevance_distance,
                relevance_traffic_direction,
                validity_duration,
                transmission_interval,
                station_type,
            }
        }
    }
    fn management_container_validity_duration_default() -> ValidityDuration {
        DEFAULT_VALIDITY.clone()
    }
    #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
    #[rasn(delegate, size("1..=8", extensible))]
    pub struct ReferenceDenms(pub SequenceOf<ActionID>);
    #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
    #[rasn(automatic_tags)]
    pub struct RoadWorksContainerExtended {
        #[rasn(identifier = "lightBarSirenInUse")]
        pub light_bar_siren_in_use: Option<LightBarSirenInUse>,
        #[rasn(identifier = "closedLanes")]
        pub closed_lanes: Option<ClosedLanes>,
        pub restriction: Option<RestrictedTypes>,
        #[rasn(identifier = "speedLimit")]
        pub speed_limit: Option<SpeedLimit>,
        #[rasn(identifier = "incidentIndication")]
        pub incident_indication: Option<CauseCode>,
        #[rasn(identifier = "recommendedPath")]
        pub recommended_path: Option<ItineraryPath>,
        #[rasn(identifier = "startingPointSpeedLimit")]
        pub starting_point_speed_limit: Option<DeltaReferencePosition>,
        #[rasn(identifier = "trafficFlowRule")]
        pub traffic_flow_rule: Option<TrafficRule>,
        #[rasn(identifier = "referenceDenms")]
        pub reference_denms: Option<ReferenceDenms>,
    }
    impl RoadWorksContainerExtended {
        pub fn new(
            light_bar_siren_in_use: Option<LightBarSirenInUse>,
            closed_lanes: Option<ClosedLanes>,
            restriction: Option<RestrictedTypes>,
            speed_limit: Option<SpeedLimit>,
            incident_indication: Option<CauseCode>,
            recommended_path: Option<ItineraryPath>,
            starting_point_speed_limit: Option<DeltaReferencePosition>,
            traffic_flow_rule: Option<TrafficRule>,
            reference_denms: Option<ReferenceDenms>,
        ) -> Self {
            Self {
                light_bar_siren_in_use,
                closed_lanes,
                restriction,
                speed_limit,
                incident_indication,
                recommended_path,
                starting_point_speed_limit,
                traffic_flow_rule,
                reference_denms,
            }
        }
    }
    #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
    #[rasn(automatic_tags)]
    #[non_exhaustive]
    pub struct SituationContainer {
        #[rasn(identifier = "informationQuality")]
        pub information_quality: InformationQuality,
        #[rasn(identifier = "eventType")]
        pub event_type: CauseCode,
        #[rasn(identifier = "linkedCause")]
        pub linked_cause: Option<CauseCode>,
        #[rasn(identifier = "eventHistory")]
        pub event_history: Option<EventHistory>,
    }
    impl SituationContainer {
        pub fn new(
            information_quality: InformationQuality,
            event_type: CauseCode,
            linked_cause: Option<CauseCode>,
            event_history: Option<EventHistory>,
        ) -> Self {
            Self {
                information_quality,
                event_type,
                linked_cause,
                event_history,
            }
        }
    }
    #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash)]
    #[rasn(automatic_tags)]
    pub struct StationaryVehicleContainer {
        #[rasn(identifier = "stationarySince")]
        pub stationary_since: Option<StationarySince>,
        #[rasn(identifier = "stationaryCause")]
        pub stationary_cause: Option<CauseCode>,
        #[rasn(identifier = "carryingDangerousGoods")]
        pub carrying_dangerous_goods: Option<DangerousGoodsExtended>,
        #[rasn(identifier = "numberOfOccupants")]
        pub number_of_occupants: Option<NumberOfOccupants>,
        #[rasn(identifier = "vehicleIdentification")]
        pub vehicle_identification: Option<VehicleIdentification>,
        #[rasn(identifier = "energyStorageType")]
        pub energy_storage_type: Option<EnergyStorageType>,
    }
    impl StationaryVehicleContainer {
        pub fn new(
            stationary_since: Option<StationarySince>,
            stationary_cause: Option<CauseCode>,
            carrying_dangerous_goods: Option<DangerousGoodsExtended>,
            number_of_occupants: Option<NumberOfOccupants>,
            vehicle_identification: Option<VehicleIdentification>,
            energy_storage_type: Option<EnergyStorageType>,
        ) -> Self {
            Self {
                stationary_since,
                stationary_cause,
                carrying_dangerous_goods,
                number_of_occupants,
                vehicle_identification,
                energy_storage_type,
            }
        }
    }
    #[derive(AsnType, Debug, Clone, Decode, Encode, PartialEq, Eq, Hash, Copy)]
    #[rasn(enumerated)]
    pub enum Termination {
        isCancellation = 0,
        isNegation = 1,
    }
    pub static DEFAULT_VALIDITY: ValidityDuration = ValidityDuration(600);
}
