step_io/generated/

author.rs

// @generated by codegen. DO NOT EDIT.
// Schema-faithful model + generic 2-pass read + topo write.

//! The strict authoring layer — [`Ap242Author`], one validated
//! constructor per AP242 entity.

use super::model::*;

/// An authoring-time rejection: the input cannot be part of a strict AP242
/// model. These fire while an adapter is being developed; a correct adapter
/// never triggers them.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AuthorError {
    /// The referenced entity kind is not legal in AP242.
    NotAp242 { entity: &'static str },
    /// The referenced id does not point at an existing entity.
    DanglingRef { entity: &'static str },
    /// The part set of a complex instance violates a schema rule.
    InvalidComplex { reason: &'static str },
    /// An aggregate attribute's element count is outside the schema's
    /// cardinality bounds (e.g. `SET [1:?]` given an empty set).
    Cardinality {
        entity: &'static str,
        attribute: &'static str,
        got: usize,
        min: usize,
        max: Option<usize>,
    },
}

impl std::fmt::Display for AuthorError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            AuthorError::NotAp242 { entity } => {
                write!(f, "{entity} is not legal in AP242 output")
            }
            AuthorError::DanglingRef { entity } => {
                write!(f, "dangling reference to {entity}")
            }
            AuthorError::InvalidComplex { reason } => {
                write!(f, "invalid complex instance: {reason}")
            }
            AuthorError::Cardinality {
                entity,
                attribute,
                got,
                min,
                max,
            } => match max {
                Some(max) => write!(
                    f,
                    "{entity}.{attribute}: {got} elements outside [{min}:{max}]"
                ),
                None => write!(f, "{entity}.{attribute}: {got} elements, minimum {min}"),
            },
        }
    }
}

impl std::error::Error for AuthorError {}

/// Strict AP242 authoring handle. Owns the model privately: entities enter
/// only through the generated constructors, so everything inside is AP242 by
/// construction. [`Ap242Author::finish`] emits the Part 21 text.
#[derive(Default)]
pub struct Ap242Author {
    model: StepModel,
}

impl Ap242Author {
    pub fn new() -> Self {
        Self::default()
    }

    /// Emit the model as AP242 (edition 2 IS) Part 21 text. The header's
    /// `FILE_SCHEMA` is stamped AP242 — the authoring layer's schema.
    pub fn finish(mut self) -> String {
        self.model.header.schema = super::schema::ap242e2_schema_id();
        crate::emit::write(&self.model)
    }

    /// [`Ap242Author::finish`] with explicit Part 21 HEADER fields. The
    /// header's `schema` is overwritten with AP242 regardless of input.
    pub fn finish_with_header(mut self, header: &crate::header::FileHeader) -> String {
        self.model.header = header.clone();
        self.finish()
    }

    /// `ACTION` — strict AP242 constructor.
    pub fn add_action(
        &mut self,
        name: String,
        description: Option<String>,
        chosen_method: ActionMethodRef,
    ) -> Result<ActionId, AuthorError> {
        check_action_method_ref(&self.model, &chosen_method)?;
        Ok(ActionId(self.model.action_arena.push(Action {
            name,
            description,
            chosen_method,
        })))
    }

    /// `ACTION_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_action_assignment(
        &mut self,
        assigned_action: ActionRef,
    ) -> Result<ActionAssignmentId, AuthorError> {
        check_action_ref(&self.model, &assigned_action)?;
        Ok(ActionAssignmentId(
            self.model
                .action_assignment_arena
                .push(ActionAssignment { assigned_action }),
        ))
    }

    /// `ACTION_DIRECTIVE` — strict AP242 constructor.
    pub fn add_action_directive(
        &mut self,
        name: String,
        description: Option<String>,
        analysis: String,
        comment: String,
        requests: Vec<VersionedActionRequestRef>,
    ) -> Result<ActionDirectiveId, AuthorError> {
        {
            let x = &requests;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "ACTION_DIRECTIVE",
                    attribute: "requests",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &requests {
            check_versioned_action_request_ref(&self.model, e0)?;
        }
        Ok(ActionDirectiveId(self.model.action_directive_arena.push(
            ActionDirective {
                name,
                description,
                analysis,
                comment,
                requests,
            },
        )))
    }

    /// `ACTION_METHOD` — strict AP242 constructor.
    pub fn add_action_method(
        &mut self,
        name: String,
        description: Option<String>,
        consequence: String,
        purpose: String,
    ) -> Result<ActionMethodId, AuthorError> {
        Ok(ActionMethodId(self.model.action_method_arena.push(
            ActionMethod {
                name,
                description,
                consequence,
                purpose,
            },
        )))
    }

    /// `ACTION_METHOD_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_action_method_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        relating_method: ActionMethodRef,
        related_method: ActionMethodRef,
    ) -> Result<ActionMethodRelationshipId, AuthorError> {
        check_action_method_ref(&self.model, &relating_method)?;
        check_action_method_ref(&self.model, &related_method)?;
        Ok(ActionMethodRelationshipId(
            self.model
                .action_method_relationship_arena
                .push(ActionMethodRelationship {
                    name,
                    description,
                    relating_method,
                    related_method,
                }),
        ))
    }

    /// `ACTION_PROPERTY` — strict AP242 constructor.
    pub fn add_action_property(
        &mut self,
        name: String,
        description: String,
        definition: CharacterizedActionDefinitionRef,
    ) -> Result<ActionPropertyId, AuthorError> {
        check_characterized_action_definition_ref(&self.model, &definition)?;
        Ok(ActionPropertyId(self.model.action_property_arena.push(
            ActionProperty {
                name,
                description,
                definition,
            },
        )))
    }

    /// `ACTION_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_action_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        relating_action: ActionRef,
        related_action: ActionRef,
    ) -> Result<ActionRelationshipId, AuthorError> {
        check_action_ref(&self.model, &relating_action)?;
        check_action_ref(&self.model, &related_action)?;
        Ok(ActionRelationshipId(
            self.model
                .action_relationship_arena
                .push(ActionRelationship {
                    name,
                    description,
                    relating_action,
                    related_action,
                }),
        ))
    }

    /// `ACTION_REQUEST_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_action_request_assignment(
        &mut self,
        assigned_action_request: VersionedActionRequestRef,
    ) -> Result<ActionRequestAssignmentId, AuthorError> {
        check_versioned_action_request_ref(&self.model, &assigned_action_request)?;
        Ok(ActionRequestAssignmentId(
            self.model
                .action_request_assignment_arena
                .push(ActionRequestAssignment {
                    assigned_action_request,
                }),
        ))
    }

    /// `ACTION_REQUEST_SOLUTION` — strict AP242 constructor.
    pub fn add_action_request_solution(
        &mut self,
        method: ActionMethodRef,
        request: VersionedActionRequestRef,
    ) -> Result<ActionRequestSolutionId, AuthorError> {
        check_action_method_ref(&self.model, &method)?;
        check_versioned_action_request_ref(&self.model, &request)?;
        Ok(ActionRequestSolutionId(
            self.model
                .action_request_solution_arena
                .push(ActionRequestSolution { method, request }),
        ))
    }

    /// `ACTION_RESOURCE` — strict AP242 constructor.
    pub fn add_action_resource(
        &mut self,
        name: String,
        description: Option<String>,
        usage: Vec<SupportedItemRef>,
        kind: ActionResourceTypeRef,
    ) -> Result<ActionResourceId, AuthorError> {
        {
            let x = &usage;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "ACTION_RESOURCE",
                    attribute: "usage",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &usage {
            check_supported_item_ref(&self.model, e0)?;
        }
        check_action_resource_type_ref(&self.model, &kind)?;
        Ok(ActionResourceId(self.model.action_resource_arena.push(
            ActionResource {
                name,
                description,
                usage,
                kind,
            },
        )))
    }

    /// `ACTION_RESOURCE_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_action_resource_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        relating_resource: ActionResourceRef,
        related_resource: ActionResourceRef,
    ) -> Result<ActionResourceRelationshipId, AuthorError> {
        check_action_resource_ref(&self.model, &relating_resource)?;
        check_action_resource_ref(&self.model, &related_resource)?;
        Ok(ActionResourceRelationshipId(
            self.model
                .action_resource_relationship_arena
                .push(ActionResourceRelationship {
                    name,
                    description,
                    relating_resource,
                    related_resource,
                }),
        ))
    }

    /// `ACTION_RESOURCE_REQUIREMENT` — strict AP242 constructor.
    pub fn add_action_resource_requirement(
        &mut self,
        name: String,
        description: String,
        kind: ResourceRequirementTypeRef,
        operations: Vec<CharacterizedActionDefinitionRef>,
    ) -> Result<ActionResourceRequirementId, AuthorError> {
        check_resource_requirement_type_ref(&self.model, &kind)?;
        {
            let x = &operations;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "ACTION_RESOURCE_REQUIREMENT",
                    attribute: "operations",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &operations {
            check_characterized_action_definition_ref(&self.model, e0)?;
        }
        Ok(ActionResourceRequirementId(
            self.model
                .action_resource_requirement_arena
                .push(ActionResourceRequirement {
                    name,
                    description,
                    kind,
                    operations,
                }),
        ))
    }

    /// `ACTION_RESOURCE_TYPE` — strict AP242 constructor.
    pub fn add_action_resource_type(
        &mut self,
        name: String,
    ) -> Result<ActionResourceTypeId, AuthorError> {
        Ok(ActionResourceTypeId(
            self.model
                .action_resource_type_arena
                .push(ActionResourceType { name }),
        ))
    }

    /// `ADDRESS` — strict AP242 constructor.
    pub fn add_address(
        &mut self,
        internal_location: Option<String>,
        street_number: Option<String>,
        street: Option<String>,
        postal_box: Option<String>,
        town: Option<String>,
        region: Option<String>,
        postal_code: Option<String>,
        country: Option<String>,
        facsimile_number: Option<String>,
        telephone_number: Option<String>,
        electronic_mail_address: Option<String>,
        telex_number: Option<String>,
    ) -> Result<AddressId, AuthorError> {
        Ok(AddressId(self.model.address_arena.push(Address {
            internal_location,
            street_number,
            street,
            postal_box,
            town,
            region,
            postal_code,
            country,
            facsimile_number,
            telephone_number,
            electronic_mail_address,
            telex_number,
        })))
    }

    /// `ADVANCED_BREP_SHAPE_REPRESENTATION` — strict AP242 constructor.
    pub fn add_advanced_brep_shape_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<AdvancedBrepShapeRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(AdvancedBrepShapeRepresentationId(
            self.model.advanced_brep_shape_representation_arena.push(
                AdvancedBrepShapeRepresentation {
                    name,
                    items,
                    context_of_items,
                },
            ),
        ))
    }

    /// `ADVANCED_FACE` — strict AP242 constructor.
    pub fn add_advanced_face(
        &mut self,
        name: String,
        bounds: Vec<FaceBoundRef>,
        face_geometry: SurfaceRef,
        same_sense: bool,
    ) -> Result<AdvancedFaceId, AuthorError> {
        {
            let x = &bounds;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "ADVANCED_FACE",
                    attribute: "bounds",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &bounds {
            check_face_bound_ref(&self.model, e0)?;
        }
        check_surface_ref(&self.model, &face_geometry)?;
        Ok(AdvancedFaceId(self.model.advanced_face_arena.push(
            AdvancedFace {
                name,
                bounds,
                face_geometry,
                same_sense,
            },
        )))
    }

    /// `ALL_AROUND_SHAPE_ASPECT` — strict AP242 constructor.
    pub fn add_all_around_shape_aspect(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
    ) -> Result<AllAroundShapeAspectId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(AllAroundShapeAspectId(
            self.model
                .all_around_shape_aspect_arena
                .push(AllAroundShapeAspect {
                    name,
                    description,
                    of_shape,
                    product_definitional,
                }),
        ))
    }

    /// `ANGULAR_LOCATION` — strict AP242 constructor.
    pub fn add_angular_location(
        &mut self,
        name: String,
        description: Option<String>,
        relating_shape_aspect: ShapeAspectRef,
        related_shape_aspect: ShapeAspectRef,
        angle_selection: AngleRelator,
    ) -> Result<AngularLocationId, AuthorError> {
        check_shape_aspect_ref(&self.model, &relating_shape_aspect)?;
        check_shape_aspect_ref(&self.model, &related_shape_aspect)?;
        Ok(AngularLocationId(self.model.angular_location_arena.push(
            AngularLocation {
                name,
                description,
                relating_shape_aspect,
                related_shape_aspect,
                angle_selection,
            },
        )))
    }

    /// `ANGULAR_SIZE` — strict AP242 constructor.
    pub fn add_angular_size(
        &mut self,
        applies_to: ShapeAspectRef,
        name: String,
        angle_selection: AngleRelator,
    ) -> Result<AngularSizeId, AuthorError> {
        check_shape_aspect_ref(&self.model, &applies_to)?;
        Ok(AngularSizeId(self.model.angular_size_arena.push(
            AngularSize {
                applies_to,
                name,
                angle_selection,
            },
        )))
    }

    /// `ANGULARITY_TOLERANCE` — strict AP242 constructor.
    pub fn add_angularity_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        datum_system: Vec<DatumSystemOrReferenceRef>,
    ) -> Result<AngularityToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        {
            let x = &datum_system;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "ANGULARITY_TOLERANCE",
                    attribute: "datum_system",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &datum_system {
            check_datum_system_or_reference_ref(&self.model, e0)?;
        }
        Ok(AngularityToleranceId(
            self.model
                .angularity_tolerance_arena
                .push(AngularityTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    datum_system,
                }),
        ))
    }

    /// `ANNOTATION_CURVE_OCCURRENCE` — strict AP242 constructor.
    pub fn add_annotation_curve_occurrence(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: CurveOrCurveSetRef,
    ) -> Result<AnnotationCurveOccurrenceId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_curve_or_curve_set_ref(&self.model, &item)?;
        Ok(AnnotationCurveOccurrenceId(
            self.model
                .annotation_curve_occurrence_arena
                .push(AnnotationCurveOccurrence { name, styles, item }),
        ))
    }

    /// `ANNOTATION_FILL_AREA_OCCURRENCE` — strict AP242 constructor.
    pub fn add_annotation_fill_area_occurrence(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: StyledItemTargetRef,
        fill_style_target: PointRef,
    ) -> Result<AnnotationFillAreaOccurrenceId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_styled_item_target_ref(&self.model, &item)?;
        check_point_ref(&self.model, &fill_style_target)?;
        Ok(AnnotationFillAreaOccurrenceId(
            self.model
                .annotation_fill_area_occurrence_arena
                .push(AnnotationFillAreaOccurrence {
                    name,
                    styles,
                    item,
                    fill_style_target,
                }),
        ))
    }

    /// `ANNOTATION_OCCURRENCE` — strict AP242 constructor.
    pub fn add_annotation_occurrence(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: StyledItemTargetRef,
    ) -> Result<AnnotationOccurrenceId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_styled_item_target_ref(&self.model, &item)?;
        Ok(AnnotationOccurrenceId(
            self.model
                .annotation_occurrence_arena
                .push(AnnotationOccurrence { name, styles, item }),
        ))
    }

    /// `ANNOTATION_OCCURRENCE_ASSOCIATIVITY` — strict AP242 constructor.
    pub fn add_annotation_occurrence_associativity(
        &mut self,
        name: String,
        description: String,
        relating_annotation_occurrence: AnnotationOccurrenceRef,
        related_annotation_occurrence: AnnotationOccurrenceRef,
    ) -> Result<AnnotationOccurrenceAssociativityId, AuthorError> {
        check_annotation_occurrence_ref(&self.model, &relating_annotation_occurrence)?;
        check_annotation_occurrence_ref(&self.model, &related_annotation_occurrence)?;
        Ok(AnnotationOccurrenceAssociativityId(
            self.model.annotation_occurrence_associativity_arena.push(
                AnnotationOccurrenceAssociativity {
                    name,
                    description,
                    relating_annotation_occurrence,
                    related_annotation_occurrence,
                },
            ),
        ))
    }

    /// `ANNOTATION_OCCURRENCE_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_annotation_occurrence_relationship(
        &mut self,
        name: String,
        description: String,
        relating_annotation_occurrence: AnnotationOccurrenceRef,
        related_annotation_occurrence: AnnotationOccurrenceRef,
    ) -> Result<AnnotationOccurrenceRelationshipId, AuthorError> {
        check_annotation_occurrence_ref(&self.model, &relating_annotation_occurrence)?;
        check_annotation_occurrence_ref(&self.model, &related_annotation_occurrence)?;
        Ok(AnnotationOccurrenceRelationshipId(
            self.model.annotation_occurrence_relationship_arena.push(
                AnnotationOccurrenceRelationship {
                    name,
                    description,
                    relating_annotation_occurrence,
                    related_annotation_occurrence,
                },
            ),
        ))
    }

    /// `ANNOTATION_PLACEHOLDER_OCCURRENCE` — strict AP242 constructor.
    pub fn add_annotation_placeholder_occurrence(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: StyledItemTargetRef,
        role: AnnotationPlaceholderOccurrenceRole,
        line_spacing: f64,
    ) -> Result<AnnotationPlaceholderOccurrenceId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_styled_item_target_ref(&self.model, &item)?;
        Ok(AnnotationPlaceholderOccurrenceId(
            self.model.annotation_placeholder_occurrence_arena.push(
                AnnotationPlaceholderOccurrence {
                    name,
                    styles,
                    item,
                    role,
                    line_spacing,
                },
            ),
        ))
    }

    /// `ANNOTATION_PLANE` — strict AP242 constructor.
    pub fn add_annotation_plane(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: PlaneOrPlanarBoxRef,
        elements: Option<Vec<AnnotationPlaneElementRef>>,
    ) -> Result<AnnotationPlaneId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_plane_or_planar_box_ref(&self.model, &item)?;
        if let Some(x) = &elements {
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "ANNOTATION_PLANE",
                    attribute: "elements",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        if let Some(x) = &elements {
            for e0 in x {
                check_annotation_plane_element_ref(&self.model, e0)?;
            }
        }
        Ok(AnnotationPlaneId(self.model.annotation_plane_arena.push(
            AnnotationPlane {
                name,
                styles,
                item,
                elements,
            },
        )))
    }

    /// `ANNOTATION_SYMBOL` — strict AP242 constructor.
    pub fn add_annotation_symbol(
        &mut self,
        name: String,
        mapping_source: RepresentationMapRef,
        mapping_target: RepresentationItemRef,
    ) -> Result<AnnotationSymbolId, AuthorError> {
        check_representation_map_ref(&self.model, &mapping_source)?;
        check_representation_item_ref(&self.model, &mapping_target)?;
        Ok(AnnotationSymbolId(self.model.annotation_symbol_arena.push(
            AnnotationSymbol {
                name,
                mapping_source,
                mapping_target,
            },
        )))
    }

    /// `ANNOTATION_SYMBOL_OCCURRENCE` — strict AP242 constructor.
    pub fn add_annotation_symbol_occurrence(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: AnnotationSymbolOccurrenceItemRef,
    ) -> Result<AnnotationSymbolOccurrenceId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_annotation_symbol_occurrence_item_ref(&self.model, &item)?;
        Ok(AnnotationSymbolOccurrenceId(
            self.model
                .annotation_symbol_occurrence_arena
                .push(AnnotationSymbolOccurrence { name, styles, item }),
        ))
    }

    /// `ANNOTATION_TEXT` — strict AP242 constructor.
    pub fn add_annotation_text(
        &mut self,
        name: String,
        mapping_source: RepresentationMapRef,
        mapping_target: Axis2PlacementRef,
    ) -> Result<AnnotationTextId, AuthorError> {
        check_representation_map_ref(&self.model, &mapping_source)?;
        check_axis2_placement_ref(&self.model, &mapping_target)?;
        Ok(AnnotationTextId(self.model.annotation_text_arena.push(
            AnnotationText {
                name,
                mapping_source,
                mapping_target,
            },
        )))
    }

    /// `ANNOTATION_TEXT_CHARACTER` — strict AP242 constructor.
    pub fn add_annotation_text_character(
        &mut self,
        name: String,
        mapping_source: RepresentationMapRef,
        mapping_target: Axis2PlacementRef,
        alignment: String,
    ) -> Result<AnnotationTextCharacterId, AuthorError> {
        check_representation_map_ref(&self.model, &mapping_source)?;
        check_axis2_placement_ref(&self.model, &mapping_target)?;
        Ok(AnnotationTextCharacterId(
            self.model
                .annotation_text_character_arena
                .push(AnnotationTextCharacter {
                    name,
                    mapping_source,
                    mapping_target,
                    alignment,
                }),
        ))
    }

    /// `ANNOTATION_TEXT_OCCURRENCE` — strict AP242 constructor.
    pub fn add_annotation_text_occurrence(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: AnnotationTextOccurrenceItemRef,
    ) -> Result<AnnotationTextOccurrenceId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_annotation_text_occurrence_item_ref(&self.model, &item)?;
        Ok(AnnotationTextOccurrenceId(
            self.model
                .annotation_text_occurrence_arena
                .push(AnnotationTextOccurrence { name, styles, item }),
        ))
    }

    /// `APPLICATION_CONTEXT` — strict AP242 constructor.
    pub fn add_application_context(
        &mut self,
        application: String,
    ) -> Result<ApplicationContextId, AuthorError> {
        Ok(ApplicationContextId(
            self.model
                .application_context_arena
                .push(ApplicationContext { application }),
        ))
    }

    /// `APPLICATION_CONTEXT_ELEMENT` — strict AP242 constructor.
    pub fn add_application_context_element(
        &mut self,
        name: String,
        frame_of_reference: ApplicationContextRef,
    ) -> Result<ApplicationContextElementId, AuthorError> {
        check_application_context_ref(&self.model, &frame_of_reference)?;
        Ok(ApplicationContextElementId(
            self.model
                .application_context_element_arena
                .push(ApplicationContextElement {
                    name,
                    frame_of_reference,
                }),
        ))
    }

    /// `APPLICATION_PROTOCOL_DEFINITION` — strict AP242 constructor.
    pub fn add_application_protocol_definition(
        &mut self,
        status: String,
        application_interpreted_model_schema_name: String,
        application_protocol_year: i64,
        application: ApplicationContextRef,
    ) -> Result<ApplicationProtocolDefinitionId, AuthorError> {
        check_application_context_ref(&self.model, &application)?;
        Ok(ApplicationProtocolDefinitionId(
            self.model
                .application_protocol_definition_arena
                .push(ApplicationProtocolDefinition {
                    status,
                    application_interpreted_model_schema_name,
                    application_protocol_year,
                    application,
                }),
        ))
    }

    /// `APPLIED_APPROVAL_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_applied_approval_assignment(
        &mut self,
        assigned_approval: ApprovalRef,
        items: Vec<ApprovalItemRef>,
    ) -> Result<AppliedApprovalAssignmentId, AuthorError> {
        check_approval_ref(&self.model, &assigned_approval)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "APPLIED_APPROVAL_ASSIGNMENT",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_approval_item_ref(&self.model, e0)?;
        }
        Ok(AppliedApprovalAssignmentId(
            self.model
                .applied_approval_assignment_arena
                .push(AppliedApprovalAssignment {
                    assigned_approval,
                    items,
                }),
        ))
    }

    /// `APPLIED_DATE_AND_TIME_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_applied_date_and_time_assignment(
        &mut self,
        assigned_date_and_time: DateAndTimeRef,
        role: DateTimeRoleRef,
        items: Vec<DateAndTimeItemRef>,
    ) -> Result<AppliedDateAndTimeAssignmentId, AuthorError> {
        check_date_and_time_ref(&self.model, &assigned_date_and_time)?;
        check_date_time_role_ref(&self.model, &role)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "APPLIED_DATE_AND_TIME_ASSIGNMENT",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_date_and_time_item_ref(&self.model, e0)?;
        }
        Ok(AppliedDateAndTimeAssignmentId(
            self.model
                .applied_date_and_time_assignment_arena
                .push(AppliedDateAndTimeAssignment {
                    assigned_date_and_time,
                    role,
                    items,
                }),
        ))
    }

    /// `APPLIED_DOCUMENT_REFERENCE` — strict AP242 constructor.
    pub fn add_applied_document_reference(
        &mut self,
        assigned_document: DocumentRef,
        source: String,
        items: Vec<DocumentReferenceItemRef>,
    ) -> Result<AppliedDocumentReferenceId, AuthorError> {
        check_document_ref(&self.model, &assigned_document)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "APPLIED_DOCUMENT_REFERENCE",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_document_reference_item_ref(&self.model, e0)?;
        }
        Ok(AppliedDocumentReferenceId(
            self.model
                .applied_document_reference_arena
                .push(AppliedDocumentReference {
                    assigned_document,
                    source,
                    items,
                }),
        ))
    }

    /// `APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_applied_external_identification_assignment(
        &mut self,
        assigned_id: String,
        role: IdentificationRoleRef,
        source: ExternalSourceRef,
        items: Vec<ExternalIdentificationItemRef>,
    ) -> Result<AppliedExternalIdentificationAssignmentId, AuthorError> {
        check_identification_role_ref(&self.model, &role)?;
        check_external_source_ref(&self.model, &source)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_external_identification_item_ref(&self.model, e0)?;
        }
        Ok(AppliedExternalIdentificationAssignmentId(
            self.model
                .applied_external_identification_assignment_arena
                .push(AppliedExternalIdentificationAssignment {
                    assigned_id,
                    role,
                    source,
                    items,
                }),
        ))
    }

    /// `APPLIED_GROUP_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_applied_group_assignment(
        &mut self,
        assigned_group: GroupRef,
        items: Vec<GroupableItemRef>,
    ) -> Result<AppliedGroupAssignmentId, AuthorError> {
        check_group_ref(&self.model, &assigned_group)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "APPLIED_GROUP_ASSIGNMENT",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_groupable_item_ref(&self.model, e0)?;
        }
        Ok(AppliedGroupAssignmentId(
            self.model
                .applied_group_assignment_arena
                .push(AppliedGroupAssignment {
                    assigned_group,
                    items,
                }),
        ))
    }

    /// `APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_applied_person_and_organization_assignment(
        &mut self,
        assigned_person_and_organization: PersonAndOrganizationRef,
        role: PersonAndOrganizationRoleRef,
        items: Vec<PersonAndOrganizationItemRef>,
    ) -> Result<AppliedPersonAndOrganizationAssignmentId, AuthorError> {
        check_person_and_organization_ref(&self.model, &assigned_person_and_organization)?;
        check_person_and_organization_role_ref(&self.model, &role)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_person_and_organization_item_ref(&self.model, e0)?;
        }
        Ok(AppliedPersonAndOrganizationAssignmentId(
            self.model
                .applied_person_and_organization_assignment_arena
                .push(AppliedPersonAndOrganizationAssignment {
                    assigned_person_and_organization,
                    role,
                    items,
                }),
        ))
    }

    /// `APPLIED_PRESENTED_ITEM` — strict AP242 constructor.
    pub fn add_applied_presented_item(
        &mut self,
        items: Vec<PresentedItemSelectRef>,
    ) -> Result<AppliedPresentedItemId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "APPLIED_PRESENTED_ITEM",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_presented_item_select_ref(&self.model, e0)?;
        }
        Ok(AppliedPresentedItemId(
            self.model
                .applied_presented_item_arena
                .push(AppliedPresentedItem { items }),
        ))
    }

    /// `APPLIED_SECURITY_CLASSIFICATION_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_applied_security_classification_assignment(
        &mut self,
        assigned_security_classification: SecurityClassificationRef,
        items: Vec<SecurityClassificationItemRef>,
    ) -> Result<AppliedSecurityClassificationAssignmentId, AuthorError> {
        check_security_classification_ref(&self.model, &assigned_security_classification)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "APPLIED_SECURITY_CLASSIFICATION_ASSIGNMENT",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_security_classification_item_ref(&self.model, e0)?;
        }
        Ok(AppliedSecurityClassificationAssignmentId(
            self.model
                .applied_security_classification_assignment_arena
                .push(AppliedSecurityClassificationAssignment {
                    assigned_security_classification,
                    items,
                }),
        ))
    }

    /// `APPROVAL` — strict AP242 constructor.
    pub fn add_approval(
        &mut self,
        status: ApprovalStatusRef,
        level: String,
    ) -> Result<ApprovalId, AuthorError> {
        check_approval_status_ref(&self.model, &status)?;
        Ok(ApprovalId(
            self.model.approval_arena.push(Approval { status, level }),
        ))
    }

    /// `APPROVAL_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_approval_assignment(
        &mut self,
        assigned_approval: ApprovalRef,
    ) -> Result<ApprovalAssignmentId, AuthorError> {
        check_approval_ref(&self.model, &assigned_approval)?;
        Ok(ApprovalAssignmentId(
            self.model
                .approval_assignment_arena
                .push(ApprovalAssignment { assigned_approval }),
        ))
    }

    /// `APPROVAL_DATE_TIME` — strict AP242 constructor.
    pub fn add_approval_date_time(
        &mut self,
        date_time: DateTimeSelectRef,
        dated_approval: ApprovalRef,
    ) -> Result<ApprovalDateTimeId, AuthorError> {
        check_date_time_select_ref(&self.model, &date_time)?;
        check_approval_ref(&self.model, &dated_approval)?;
        Ok(ApprovalDateTimeId(
            self.model.approval_date_time_arena.push(ApprovalDateTime {
                date_time,
                dated_approval,
            }),
        ))
    }

    /// `APPROVAL_PERSON_ORGANIZATION` — strict AP242 constructor.
    pub fn add_approval_person_organization(
        &mut self,
        person_organization: PersonOrganizationSelectRef,
        authorized_approval: ApprovalRef,
        role: ApprovalRoleRef,
    ) -> Result<ApprovalPersonOrganizationId, AuthorError> {
        check_person_organization_select_ref(&self.model, &person_organization)?;
        check_approval_ref(&self.model, &authorized_approval)?;
        check_approval_role_ref(&self.model, &role)?;
        Ok(ApprovalPersonOrganizationId(
            self.model
                .approval_person_organization_arena
                .push(ApprovalPersonOrganization {
                    person_organization,
                    authorized_approval,
                    role,
                }),
        ))
    }

    /// `APPROVAL_ROLE` — strict AP242 constructor.
    pub fn add_approval_role(&mut self, role: String) -> Result<ApprovalRoleId, AuthorError> {
        Ok(ApprovalRoleId(
            self.model.approval_role_arena.push(ApprovalRole { role }),
        ))
    }

    /// `APPROVAL_STATUS` — strict AP242 constructor.
    pub fn add_approval_status(&mut self, name: String) -> Result<ApprovalStatusId, AuthorError> {
        Ok(ApprovalStatusId(
            self.model
                .approval_status_arena
                .push(ApprovalStatus { name }),
        ))
    }

    /// `AREA_IN_SET` — strict AP242 constructor.
    pub fn add_area_in_set(
        &mut self,
        area: PresentationAreaRef,
        in_set: PresentationSetRef,
    ) -> Result<AreaInSetId, AuthorError> {
        check_presentation_area_ref(&self.model, &area)?;
        check_presentation_set_ref(&self.model, &in_set)?;
        Ok(AreaInSetId(
            self.model
                .area_in_set_arena
                .push(AreaInSet { area, in_set }),
        ))
    }

    /// `AREA_UNIT` — strict AP242 constructor.
    pub fn add_area_unit(
        &mut self,
        elements: Vec<DerivedUnitElementRef>,
    ) -> Result<AreaUnitId, AuthorError> {
        {
            let x = &elements;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "AREA_UNIT",
                    attribute: "elements",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &elements {
            check_derived_unit_element_ref(&self.model, e0)?;
        }
        Ok(AreaUnitId(
            self.model.area_unit_arena.push(AreaUnit { elements }),
        ))
    }

    /// `ASCRIBABLE_STATE` — strict AP242 constructor.
    pub fn add_ascribable_state(
        &mut self,
        name: String,
        description: Option<String>,
        pertaining_state_type: StateTypeRef,
        ascribed_state_observed: StateObservedRef,
    ) -> Result<AscribableStateId, AuthorError> {
        check_state_type_ref(&self.model, &pertaining_state_type)?;
        check_state_observed_ref(&self.model, &ascribed_state_observed)?;
        Ok(AscribableStateId(self.model.ascribable_state_arena.push(
            AscribableState {
                name,
                description,
                pertaining_state_type,
                ascribed_state_observed,
            },
        )))
    }

    /// `ASCRIBABLE_STATE_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_ascribable_state_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        relating_ascribable_state: AscribableStateRef,
        related_ascribable_state: AscribableStateRef,
    ) -> Result<AscribableStateRelationshipId, AuthorError> {
        check_ascribable_state_ref(&self.model, &relating_ascribable_state)?;
        check_ascribable_state_ref(&self.model, &related_ascribable_state)?;
        Ok(AscribableStateRelationshipId(
            self.model
                .ascribable_state_relationship_arena
                .push(AscribableStateRelationship {
                    name,
                    description,
                    relating_ascribable_state,
                    related_ascribable_state,
                }),
        ))
    }

    /// `ASSEMBLY_COMPONENT_USAGE` — strict AP242 constructor.
    pub fn add_assembly_component_usage(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
        relating_product_definition: ProductDefinitionOrReferenceRef,
        related_product_definition: ProductDefinitionOrReferenceRef,
        reference_designator: Option<String>,
    ) -> Result<AssemblyComponentUsageId, AuthorError> {
        check_product_definition_or_reference_ref(&self.model, &relating_product_definition)?;
        check_product_definition_or_reference_ref(&self.model, &related_product_definition)?;
        Ok(AssemblyComponentUsageId(
            self.model
                .assembly_component_usage_arena
                .push(AssemblyComponentUsage {
                    id,
                    name,
                    description,
                    relating_product_definition,
                    related_product_definition,
                    reference_designator,
                }),
        ))
    }

    /// `AXIS1_PLACEMENT` — strict AP242 constructor.
    pub fn add_axis1_placement(
        &mut self,
        name: String,
        location: CartesianPointRef,
        axis: Option<DirectionRef>,
    ) -> Result<Axis1PlacementId, AuthorError> {
        check_cartesian_point_ref(&self.model, &location)?;
        if let Some(x) = &axis {
            check_direction_ref(&self.model, x)?;
        }
        Ok(Axis1PlacementId(self.model.axis1_placement_arena.push(
            Axis1Placement {
                name,
                location,
                axis,
            },
        )))
    }

    /// `AXIS2_PLACEMENT_2D` — strict AP242 constructor.
    pub fn add_axis2_placement2d(
        &mut self,
        name: String,
        location: CartesianPointRef,
        ref_direction: Option<DirectionRef>,
    ) -> Result<Axis2Placement2dId, AuthorError> {
        check_cartesian_point_ref(&self.model, &location)?;
        if let Some(x) = &ref_direction {
            check_direction_ref(&self.model, x)?;
        }
        Ok(Axis2Placement2dId(self.model.axis2_placement2d_arena.push(
            Axis2Placement2d {
                name,
                location,
                ref_direction,
            },
        )))
    }

    /// `AXIS2_PLACEMENT_3D` — strict AP242 constructor.
    pub fn add_axis2_placement3d(
        &mut self,
        name: String,
        location: CartesianPointRef,
        axis: Option<DirectionRef>,
        ref_direction: Option<DirectionRef>,
    ) -> Result<Axis2Placement3dId, AuthorError> {
        check_cartesian_point_ref(&self.model, &location)?;
        if let Some(x) = &axis {
            check_direction_ref(&self.model, x)?;
        }
        if let Some(x) = &ref_direction {
            check_direction_ref(&self.model, x)?;
        }
        Ok(Axis2Placement3dId(self.model.axis2_placement3d_arena.push(
            Axis2Placement3d {
                name,
                location,
                axis,
                ref_direction,
            },
        )))
    }

    /// `B_SPLINE_CURVE` — strict AP242 constructor.
    pub fn add_b_spline_curve(
        &mut self,
        name: String,
        degree: i64,
        control_points_list: Vec<CartesianPointRef>,
        curve_form: BSplineCurveForm,
        closed_curve: Logical,
        self_intersect: Logical,
    ) -> Result<BSplineCurveId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "B_SPLINE_CURVE",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            check_cartesian_point_ref(&self.model, e0)?;
        }
        Ok(BSplineCurveId(self.model.b_spline_curve_arena.push(
            BSplineCurve {
                name,
                degree,
                control_points_list,
                curve_form,
                closed_curve,
                self_intersect,
            },
        )))
    }

    /// `B_SPLINE_CURVE_WITH_KNOTS` — strict AP242 constructor.
    pub fn add_b_spline_curve_with_knots(
        &mut self,
        name: String,
        degree: i64,
        control_points_list: Vec<CartesianPointRef>,
        curve_form: BSplineCurveForm,
        closed_curve: Logical,
        self_intersect: Logical,
        knot_multiplicities: Vec<i64>,
        knots: Vec<f64>,
        knot_spec: KnotType,
    ) -> Result<BSplineCurveWithKnotsId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            check_cartesian_point_ref(&self.model, e0)?;
        }
        {
            let x = &knot_multiplicities;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                    attribute: "knot_multiplicities",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        {
            let x = &knots;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                    attribute: "knots",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        Ok(BSplineCurveWithKnotsId(
            self.model
                .b_spline_curve_with_knots_arena
                .push(BSplineCurveWithKnots {
                    name,
                    degree,
                    control_points_list,
                    curve_form,
                    closed_curve,
                    self_intersect,
                    knot_multiplicities,
                    knots,
                    knot_spec,
                }),
        ))
    }

    /// `B_SPLINE_SURFACE` — strict AP242 constructor.
    pub fn add_b_spline_surface(
        &mut self,
        name: String,
        u_degree: i64,
        v_degree: i64,
        control_points_list: Vec<Vec<CartesianPointRef>>,
        surface_form: BSplineSurfaceForm,
        u_closed: Logical,
        v_closed: Logical,
        self_intersect: Logical,
    ) -> Result<BSplineSurfaceId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "B_SPLINE_SURFACE",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            for e1 in e0 {
                check_cartesian_point_ref(&self.model, e1)?;
            }
        }
        Ok(BSplineSurfaceId(self.model.b_spline_surface_arena.push(
            BSplineSurface {
                name,
                u_degree,
                v_degree,
                control_points_list,
                surface_form,
                u_closed,
                v_closed,
                self_intersect,
            },
        )))
    }

    /// `B_SPLINE_SURFACE_WITH_KNOTS` — strict AP242 constructor.
    pub fn add_b_spline_surface_with_knots(
        &mut self,
        name: String,
        u_degree: i64,
        v_degree: i64,
        control_points_list: Vec<Vec<CartesianPointRef>>,
        surface_form: BSplineSurfaceForm,
        u_closed: Logical,
        v_closed: Logical,
        self_intersect: Logical,
        u_multiplicities: Vec<i64>,
        v_multiplicities: Vec<i64>,
        u_knots: Vec<f64>,
        v_knots: Vec<f64>,
        knot_spec: KnotType,
    ) -> Result<BSplineSurfaceWithKnotsId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            for e1 in e0 {
                check_cartesian_point_ref(&self.model, e1)?;
            }
        }
        {
            let x = &u_multiplicities;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                    attribute: "u_multiplicities",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        {
            let x = &v_multiplicities;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                    attribute: "v_multiplicities",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        {
            let x = &u_knots;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                    attribute: "u_knots",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        {
            let x = &v_knots;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                    attribute: "v_knots",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        Ok(BSplineSurfaceWithKnotsId(
            self.model
                .b_spline_surface_with_knots_arena
                .push(BSplineSurfaceWithKnots {
                    name,
                    u_degree,
                    v_degree,
                    control_points_list,
                    surface_form,
                    u_closed,
                    v_closed,
                    self_intersect,
                    u_multiplicities,
                    v_multiplicities,
                    u_knots,
                    v_knots,
                    knot_spec,
                }),
        ))
    }

    /// `BEZIER_CURVE` — strict AP242 constructor.
    pub fn add_bezier_curve(
        &mut self,
        name: String,
        degree: i64,
        control_points_list: Vec<CartesianPointRef>,
        curve_form: BSplineCurveForm,
        closed_curve: Logical,
        self_intersect: Logical,
    ) -> Result<BezierCurveId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "BEZIER_CURVE",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            check_cartesian_point_ref(&self.model, e0)?;
        }
        Ok(BezierCurveId(self.model.bezier_curve_arena.push(
            BezierCurve {
                name,
                degree,
                control_points_list,
                curve_form,
                closed_curve,
                self_intersect,
            },
        )))
    }

    /// `BEZIER_SURFACE` — strict AP242 constructor.
    pub fn add_bezier_surface(
        &mut self,
        name: String,
        u_degree: i64,
        v_degree: i64,
        control_points_list: Vec<Vec<CartesianPointRef>>,
        surface_form: BSplineSurfaceForm,
        u_closed: Logical,
        v_closed: Logical,
        self_intersect: Logical,
    ) -> Result<BezierSurfaceId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "BEZIER_SURFACE",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            for e1 in e0 {
                check_cartesian_point_ref(&self.model, e1)?;
            }
        }
        Ok(BezierSurfaceId(self.model.bezier_surface_arena.push(
            BezierSurface {
                name,
                u_degree,
                v_degree,
                control_points_list,
                surface_form,
                u_closed,
                v_closed,
                self_intersect,
            },
        )))
    }

    /// `BOUNDED_CURVE` — strict AP242 constructor.
    pub fn add_bounded_curve(&mut self, name: String) -> Result<BoundedCurveId, AuthorError> {
        Ok(BoundedCurveId(
            self.model.bounded_curve_arena.push(BoundedCurve { name }),
        ))
    }

    /// `BOUNDED_PCURVE` — strict AP242 constructor.
    pub fn add_bounded_pcurve(
        &mut self,
        name: String,
        basis_surface: SurfaceRef,
        reference_to_curve: DefinitionalRepresentationRef,
    ) -> Result<BoundedPcurveId, AuthorError> {
        check_surface_ref(&self.model, &basis_surface)?;
        check_definitional_representation_ref(&self.model, &reference_to_curve)?;
        Ok(BoundedPcurveId(self.model.bounded_pcurve_arena.push(
            BoundedPcurve {
                name,
                basis_surface,
                reference_to_curve,
            },
        )))
    }

    /// `BOUNDED_SURFACE` — strict AP242 constructor.
    pub fn add_bounded_surface(&mut self, name: String) -> Result<BoundedSurfaceId, AuthorError> {
        Ok(BoundedSurfaceId(
            self.model
                .bounded_surface_arena
                .push(BoundedSurface { name }),
        ))
    }

    /// `BOUNDED_SURFACE_CURVE` — strict AP242 constructor.
    pub fn add_bounded_surface_curve(
        &mut self,
        name: String,
        curve_3d: CurveRef,
        associated_geometry: Vec<PcurveOrSurfaceRef>,
        master_representation: PreferredSurfaceCurveRepresentation,
    ) -> Result<BoundedSurfaceCurveId, AuthorError> {
        check_curve_ref(&self.model, &curve_3d)?;
        {
            let x = &associated_geometry;
            if x.len() < 1 || x.len() > 2 {
                return Err(AuthorError::Cardinality {
                    entity: "BOUNDED_SURFACE_CURVE",
                    attribute: "associated_geometry",
                    got: x.len(),
                    min: 1,
                    max: Some(2),
                });
            }
        }
        for e0 in &associated_geometry {
            check_pcurve_or_surface_ref(&self.model, e0)?;
        }
        Ok(BoundedSurfaceCurveId(
            self.model
                .bounded_surface_curve_arena
                .push(BoundedSurfaceCurve {
                    name,
                    curve_3d,
                    associated_geometry,
                    master_representation,
                }),
        ))
    }

    /// `BREP_WITH_VOIDS` — strict AP242 constructor.
    pub fn add_brep_with_voids(
        &mut self,
        name: String,
        outer: ClosedShellRef,
        voids: Vec<OrientedClosedShellRef>,
    ) -> Result<BrepWithVoidsId, AuthorError> {
        check_closed_shell_ref(&self.model, &outer)?;
        {
            let x = &voids;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "BREP_WITH_VOIDS",
                    attribute: "voids",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &voids {
            check_oriented_closed_shell_ref(&self.model, e0)?;
        }
        Ok(BrepWithVoidsId(
            self.model
                .brep_with_voids_arena
                .push(BrepWithVoids { name, outer, voids }),
        ))
    }

    /// `CALENDAR_DATE` — strict AP242 constructor.
    pub fn add_calendar_date(
        &mut self,
        year_component: i64,
        day_component: i64,
        month_component: i64,
    ) -> Result<CalendarDateId, AuthorError> {
        Ok(CalendarDateId(self.model.calendar_date_arena.push(
            CalendarDate {
                year_component,
                day_component,
                month_component,
            },
        )))
    }

    /// `CAMERA_IMAGE` — strict AP242 constructor.
    pub fn add_camera_image(
        &mut self,
        name: String,
        mapping_source: RepresentationMapRef,
        mapping_target: RepresentationItemRef,
    ) -> Result<CameraImageId, AuthorError> {
        check_representation_map_ref(&self.model, &mapping_source)?;
        check_representation_item_ref(&self.model, &mapping_target)?;
        Ok(CameraImageId(self.model.camera_image_arena.push(
            CameraImage {
                name,
                mapping_source,
                mapping_target,
            },
        )))
    }

    /// `CAMERA_IMAGE_3D_WITH_SCALE` — strict AP242 constructor.
    pub fn add_camera_image3d_with_scale(
        &mut self,
        name: String,
        mapping_source: RepresentationMapRef,
        mapping_target: RepresentationItemRef,
    ) -> Result<CameraImage3dWithScaleId, AuthorError> {
        check_representation_map_ref(&self.model, &mapping_source)?;
        check_representation_item_ref(&self.model, &mapping_target)?;
        Ok(CameraImage3dWithScaleId(
            self.model
                .camera_image3d_with_scale_arena
                .push(CameraImage3dWithScale {
                    name,
                    mapping_source,
                    mapping_target,
                }),
        ))
    }

    /// `CAMERA_MODEL` — strict AP242 constructor.
    pub fn add_camera_model(&mut self, name: String) -> Result<CameraModelId, AuthorError> {
        Ok(CameraModelId(
            self.model.camera_model_arena.push(CameraModel { name }),
        ))
    }

    /// `CAMERA_MODEL_D3` — strict AP242 constructor.
    pub fn add_camera_model_d3(
        &mut self,
        name: String,
        view_reference_system: Axis2Placement3dRef,
        perspective_of_volume: ViewVolumeRef,
    ) -> Result<CameraModelD3Id, AuthorError> {
        check_axis2_placement3d_ref(&self.model, &view_reference_system)?;
        check_view_volume_ref(&self.model, &perspective_of_volume)?;
        Ok(CameraModelD3Id(self.model.camera_model_d3_arena.push(
            CameraModelD3 {
                name,
                view_reference_system,
                perspective_of_volume,
            },
        )))
    }

    /// `CAMERA_MODEL_D3_MULTI_CLIPPING` — strict AP242 constructor.
    pub fn add_camera_model_d3_multi_clipping(
        &mut self,
        name: String,
        view_reference_system: Axis2Placement3dRef,
        perspective_of_volume: ViewVolumeRef,
        shape_clipping: Vec<CameraModelD3MultiClippingIntersectionSelectRef>,
    ) -> Result<CameraModelD3MultiClippingId, AuthorError> {
        check_axis2_placement3d_ref(&self.model, &view_reference_system)?;
        check_view_volume_ref(&self.model, &perspective_of_volume)?;
        {
            let x = &shape_clipping;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                    attribute: "shape_clipping",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &shape_clipping {
            check_camera_model_d3_multi_clipping_intersection_select_ref(&self.model, e0)?;
        }
        Ok(CameraModelD3MultiClippingId(
            self.model
                .camera_model_d3_multi_clipping_arena
                .push(CameraModelD3MultiClipping {
                    name,
                    view_reference_system,
                    perspective_of_volume,
                    shape_clipping,
                }),
        ))
    }

    /// `CAMERA_MODEL_D3_WITH_HLHSR` — strict AP242 constructor.
    pub fn add_camera_model_d3_with_hlhsr(
        &mut self,
        name: String,
        view_reference_system: Axis2Placement3dRef,
        perspective_of_volume: ViewVolumeRef,
        hidden_line_surface_removal: bool,
    ) -> Result<CameraModelD3WithHlhsrId, AuthorError> {
        check_axis2_placement3d_ref(&self.model, &view_reference_system)?;
        check_view_volume_ref(&self.model, &perspective_of_volume)?;
        Ok(CameraModelD3WithHlhsrId(
            self.model
                .camera_model_d3_with_hlhsr_arena
                .push(CameraModelD3WithHlhsr {
                    name,
                    view_reference_system,
                    perspective_of_volume,
                    hidden_line_surface_removal,
                }),
        ))
    }

    /// `CAMERA_USAGE` — strict AP242 constructor.
    pub fn add_camera_usage(
        &mut self,
        mapping_origin: RepresentationItemRef,
        mapped_representation: RepresentationRef,
    ) -> Result<CameraUsageId, AuthorError> {
        check_representation_item_ref(&self.model, &mapping_origin)?;
        check_representation_ref(&self.model, &mapped_representation)?;
        Ok(CameraUsageId(self.model.camera_usage_arena.push(
            CameraUsage {
                mapping_origin,
                mapped_representation,
            },
        )))
    }

    /// `CARTESIAN_POINT` — strict AP242 constructor.
    pub fn add_cartesian_point(
        &mut self,
        name: String,
        coordinates: Vec<f64>,
    ) -> Result<CartesianPointId, AuthorError> {
        {
            let x = &coordinates;
            if x.len() < 1 || x.len() > 3 {
                return Err(AuthorError::Cardinality {
                    entity: "CARTESIAN_POINT",
                    attribute: "coordinates",
                    got: x.len(),
                    min: 1,
                    max: Some(3),
                });
            }
        }
        Ok(CartesianPointId(
            self.model
                .cartesian_point_arena
                .push(CartesianPoint { name, coordinates }),
        ))
    }

    /// `CC_DESIGN_APPROVAL` — strict AP242 constructor.
    pub fn add_cc_design_approval(
        &mut self,
        assigned_approval: ApprovalRef,
        items: Vec<ApprovedItemRef>,
    ) -> Result<CcDesignApprovalId, AuthorError> {
        check_approval_ref(&self.model, &assigned_approval)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CC_DESIGN_APPROVAL",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_approved_item_ref(&self.model, e0)?;
        }
        Ok(CcDesignApprovalId(
            self.model.cc_design_approval_arena.push(CcDesignApproval {
                assigned_approval,
                items,
            }),
        ))
    }

    /// `CC_DESIGN_DATE_AND_TIME_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_cc_design_date_and_time_assignment(
        &mut self,
        assigned_date_and_time: DateAndTimeRef,
        role: DateTimeRoleRef,
        items: Vec<DateTimeItemRef>,
    ) -> Result<CcDesignDateAndTimeAssignmentId, AuthorError> {
        check_date_and_time_ref(&self.model, &assigned_date_and_time)?;
        check_date_time_role_ref(&self.model, &role)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_date_time_item_ref(&self.model, e0)?;
        }
        Ok(CcDesignDateAndTimeAssignmentId(
            self.model.cc_design_date_and_time_assignment_arena.push(
                CcDesignDateAndTimeAssignment {
                    assigned_date_and_time,
                    role,
                    items,
                },
            ),
        ))
    }

    /// `CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_cc_design_person_and_organization_assignment(
        &mut self,
        assigned_person_and_organization: PersonAndOrganizationRef,
        role: PersonAndOrganizationRoleRef,
        items: Vec<CcPersonOrganizationItemRef>,
    ) -> Result<CcDesignPersonAndOrganizationAssignmentId, AuthorError> {
        check_person_and_organization_ref(&self.model, &assigned_person_and_organization)?;
        check_person_and_organization_role_ref(&self.model, &role)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_cc_person_organization_item_ref(&self.model, e0)?;
        }
        Ok(CcDesignPersonAndOrganizationAssignmentId(
            self.model
                .cc_design_person_and_organization_assignment_arena
                .push(CcDesignPersonAndOrganizationAssignment {
                    assigned_person_and_organization,
                    role,
                    items,
                }),
        ))
    }

    /// `CC_DESIGN_SECURITY_CLASSIFICATION` — strict AP242 constructor.
    pub fn add_cc_design_security_classification(
        &mut self,
        assigned_security_classification: SecurityClassificationRef,
        items: Vec<CcClassifiedItemRef>,
    ) -> Result<CcDesignSecurityClassificationId, AuthorError> {
        check_security_classification_ref(&self.model, &assigned_security_classification)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CC_DESIGN_SECURITY_CLASSIFICATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_cc_classified_item_ref(&self.model, e0)?;
        }
        Ok(CcDesignSecurityClassificationId(
            self.model.cc_design_security_classification_arena.push(
                CcDesignSecurityClassification {
                    assigned_security_classification,
                    items,
                },
            ),
        ))
    }

    /// `CENTRE_OF_SYMMETRY` — strict AP242 constructor.
    pub fn add_centre_of_symmetry(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
    ) -> Result<CentreOfSymmetryId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(CentreOfSymmetryId(
            self.model.centre_of_symmetry_arena.push(CentreOfSymmetry {
                name,
                description,
                of_shape,
                product_definitional,
            }),
        ))
    }

    /// `CERTIFICATION` — strict AP242 constructor.
    pub fn add_certification(
        &mut self,
        name: String,
        purpose: String,
        kind: CertificationTypeRef,
    ) -> Result<CertificationId, AuthorError> {
        check_certification_type_ref(&self.model, &kind)?;
        Ok(CertificationId(self.model.certification_arena.push(
            Certification {
                name,
                purpose,
                kind,
            },
        )))
    }

    /// `CERTIFICATION_TYPE` — strict AP242 constructor.
    pub fn add_certification_type(
        &mut self,
        description: String,
    ) -> Result<CertificationTypeId, AuthorError> {
        Ok(CertificationTypeId(
            self.model
                .certification_type_arena
                .push(CertificationType { description }),
        ))
    }

    /// `CHANGE` — strict AP242 constructor.
    pub fn add_change(
        &mut self,
        assigned_action: ActionRef,
        items: Vec<WorkItemRef>,
    ) -> Result<ChangeId, AuthorError> {
        check_action_ref(&self.model, &assigned_action)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CHANGE",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_work_item_ref(&self.model, e0)?;
        }
        Ok(ChangeId(self.model.change_arena.push(Change {
            assigned_action,
            items,
        })))
    }

    /// `CHANGE_REQUEST` — strict AP242 constructor.
    pub fn add_change_request(
        &mut self,
        assigned_action_request: VersionedActionRequestRef,
        items: Vec<ChangeRequestItemRef>,
    ) -> Result<ChangeRequestId, AuthorError> {
        check_versioned_action_request_ref(&self.model, &assigned_action_request)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CHANGE_REQUEST",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_change_request_item_ref(&self.model, e0)?;
        }
        Ok(ChangeRequestId(self.model.change_request_arena.push(
            ChangeRequest {
                assigned_action_request,
                items,
            },
        )))
    }

    /// `CHARACTER_GLYPH_STYLE_OUTLINE` — strict AP242 constructor.
    pub fn add_character_glyph_style_outline(
        &mut self,
        outline_style: CurveStyleRef,
    ) -> Result<CharacterGlyphStyleOutlineId, AuthorError> {
        check_curve_style_ref(&self.model, &outline_style)?;
        Ok(CharacterGlyphStyleOutlineId(
            self.model
                .character_glyph_style_outline_arena
                .push(CharacterGlyphStyleOutline { outline_style }),
        ))
    }

    /// `CHARACTER_GLYPH_STYLE_STROKE` — strict AP242 constructor.
    pub fn add_character_glyph_style_stroke(
        &mut self,
        stroke_style: CurveStyleRef,
    ) -> Result<CharacterGlyphStyleStrokeId, AuthorError> {
        check_curve_style_ref(&self.model, &stroke_style)?;
        Ok(CharacterGlyphStyleStrokeId(
            self.model
                .character_glyph_style_stroke_arena
                .push(CharacterGlyphStyleStroke { stroke_style }),
        ))
    }

    /// `CHARACTERIZED_ITEM_WITHIN_REPRESENTATION` — strict AP242 constructor.
    pub fn add_characterized_item_within_representation(
        &mut self,
        name: String,
        description: Option<String>,
        item: RepresentationItemRef,
        rep: RepresentationRef,
    ) -> Result<CharacterizedItemWithinRepresentationId, AuthorError> {
        check_representation_item_ref(&self.model, &item)?;
        check_representation_ref(&self.model, &rep)?;
        Ok(CharacterizedItemWithinRepresentationId(
            self.model
                .characterized_item_within_representation_arena
                .push(CharacterizedItemWithinRepresentation {
                    name,
                    description,
                    item,
                    rep,
                }),
        ))
    }

    /// `CHARACTERIZED_OBJECT` — strict AP242 constructor.
    pub fn add_characterized_object(
        &mut self,
        name: Option<String>,
        description: Option<String>,
    ) -> Result<CharacterizedObjectId, AuthorError> {
        Ok(CharacterizedObjectId(
            self.model
                .characterized_object_arena
                .push(CharacterizedObject { name, description }),
        ))
    }

    /// `CHARACTERIZED_REPRESENTATION` — strict AP242 constructor.
    pub fn add_characterized_representation(
        &mut self,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<CharacterizedRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CHARACTERIZED_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(CharacterizedRepresentationId(
            self.model
                .characterized_representation_arena
                .push(CharacterizedRepresentation {
                    items,
                    context_of_items,
                }),
        ))
    }

    /// `CIRCLE` — strict AP242 constructor.
    pub fn add_circle(
        &mut self,
        name: String,
        position: Axis2PlacementRef,
        radius: f64,
    ) -> Result<CircleId, AuthorError> {
        check_axis2_placement_ref(&self.model, &position)?;
        Ok(CircleId(self.model.circle_arena.push(Circle {
            name,
            position,
            radius,
        })))
    }

    /// `CIRCULAR_RUNOUT_TOLERANCE` — strict AP242 constructor.
    pub fn add_circular_runout_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        datum_system: Vec<DatumSystemOrReferenceRef>,
    ) -> Result<CircularRunoutToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        {
            let x = &datum_system;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CIRCULAR_RUNOUT_TOLERANCE",
                    attribute: "datum_system",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &datum_system {
            check_datum_system_or_reference_ref(&self.model, e0)?;
        }
        Ok(CircularRunoutToleranceId(
            self.model
                .circular_runout_tolerance_arena
                .push(CircularRunoutTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    datum_system,
                }),
        ))
    }

    /// `CLOSED_SHELL` — strict AP242 constructor.
    pub fn add_closed_shell(
        &mut self,
        name: String,
        cfs_faces: Vec<FaceRef>,
    ) -> Result<ClosedShellId, AuthorError> {
        {
            let x = &cfs_faces;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CLOSED_SHELL",
                    attribute: "cfs_faces",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &cfs_faces {
            check_face_ref(&self.model, e0)?;
        }
        Ok(ClosedShellId(
            self.model
                .closed_shell_arena
                .push(ClosedShell { name, cfs_faces }),
        ))
    }

    /// `COAXIALITY_TOLERANCE` — strict AP242 constructor.
    pub fn add_coaxiality_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        datum_system: Vec<DatumSystemOrReferenceRef>,
    ) -> Result<CoaxialityToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        {
            let x = &datum_system;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "COAXIALITY_TOLERANCE",
                    attribute: "datum_system",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &datum_system {
            check_datum_system_or_reference_ref(&self.model, e0)?;
        }
        Ok(CoaxialityToleranceId(
            self.model
                .coaxiality_tolerance_arena
                .push(CoaxialityTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    datum_system,
                }),
        ))
    }

    /// `COLOUR` — strict AP242 constructor.
    pub fn add_colour(&mut self) -> Result<ColourId, AuthorError> {
        Ok(ColourId(self.model.colour_arena.push(Colour {})))
    }

    /// `COLOUR_RGB` — strict AP242 constructor.
    pub fn add_colour_rgb(
        &mut self,
        name: String,
        red: f64,
        green: f64,
        blue: f64,
    ) -> Result<ColourRgbId, AuthorError> {
        Ok(ColourRgbId(self.model.colour_rgb_arena.push(ColourRgb {
            name,
            red,
            green,
            blue,
        })))
    }

    /// `COLOUR_SPECIFICATION` — strict AP242 constructor.
    pub fn add_colour_specification(
        &mut self,
        name: String,
    ) -> Result<ColourSpecificationId, AuthorError> {
        Ok(ColourSpecificationId(
            self.model
                .colour_specification_arena
                .push(ColourSpecification { name }),
        ))
    }

    /// `COMMON_DATUM` — strict AP242 constructor.
    pub fn add_common_datum(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
        identification: String,
    ) -> Result<CommonDatumId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(CommonDatumId(self.model.common_datum_arena.push(
            CommonDatum {
                name,
                description,
                of_shape,
                product_definitional,
                identification,
            },
        )))
    }

    /// `COMPLEX_TRIANGULATED_FACE` — strict AP242 constructor.
    pub fn add_complex_triangulated_face(
        &mut self,
        name: String,
        coordinates: CoordinatesListRef,
        pnmax: i64,
        normals: Vec<Vec<f64>>,
        geometric_link: Option<FaceOrSurfaceRef>,
        pnindex: Vec<i64>,
        triangle_strips: Vec<Vec<i64>>,
        triangle_fans: Vec<Vec<i64>>,
    ) -> Result<ComplexTriangulatedFaceId, AuthorError> {
        check_coordinates_list_ref(&self.model, &coordinates)?;
        if let Some(x) = &geometric_link {
            check_face_or_surface_ref(&self.model, x)?;
        }
        Ok(ComplexTriangulatedFaceId(
            self.model
                .complex_triangulated_face_arena
                .push(ComplexTriangulatedFace {
                    name,
                    coordinates,
                    pnmax,
                    normals,
                    geometric_link,
                    pnindex,
                    triangle_strips,
                    triangle_fans,
                }),
        ))
    }

    /// `COMPLEX_TRIANGULATED_SURFACE_SET` — strict AP242 constructor.
    pub fn add_complex_triangulated_surface_set(
        &mut self,
        name: String,
        coordinates: CoordinatesListRef,
        pnmax: i64,
        normals: Vec<Vec<f64>>,
        pnindex: Vec<i64>,
        triangle_strips: Vec<Vec<i64>>,
        triangle_fans: Vec<Vec<i64>>,
    ) -> Result<ComplexTriangulatedSurfaceSetId, AuthorError> {
        check_coordinates_list_ref(&self.model, &coordinates)?;
        Ok(ComplexTriangulatedSurfaceSetId(
            self.model
                .complex_triangulated_surface_set_arena
                .push(ComplexTriangulatedSurfaceSet {
                    name,
                    coordinates,
                    pnmax,
                    normals,
                    pnindex,
                    triangle_strips,
                    triangle_fans,
                }),
        ))
    }

    /// `COMPOSITE_CURVE` — strict AP242 constructor.
    pub fn add_composite_curve(
        &mut self,
        name: String,
        segments: Vec<CompositeCurveSegmentRef>,
        self_intersect: Logical,
    ) -> Result<CompositeCurveId, AuthorError> {
        {
            let x = &segments;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "COMPOSITE_CURVE",
                    attribute: "segments",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &segments {
            check_composite_curve_segment_ref(&self.model, e0)?;
        }
        Ok(CompositeCurveId(self.model.composite_curve_arena.push(
            CompositeCurve {
                name,
                segments,
                self_intersect,
            },
        )))
    }

    /// `COMPOSITE_CURVE_SEGMENT` — strict AP242 constructor.
    pub fn add_composite_curve_segment(
        &mut self,
        transition: TransitionCode,
        same_sense: bool,
        parent_curve: CurveRef,
    ) -> Result<CompositeCurveSegmentId, AuthorError> {
        check_curve_ref(&self.model, &parent_curve)?;
        Ok(CompositeCurveSegmentId(
            self.model
                .composite_curve_segment_arena
                .push(CompositeCurveSegment {
                    transition,
                    same_sense,
                    parent_curve,
                }),
        ))
    }

    /// `COMPOSITE_GROUP_SHAPE_ASPECT` — strict AP242 constructor.
    pub fn add_composite_group_shape_aspect(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
    ) -> Result<CompositeGroupShapeAspectId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(CompositeGroupShapeAspectId(
            self.model
                .composite_group_shape_aspect_arena
                .push(CompositeGroupShapeAspect {
                    name,
                    description,
                    of_shape,
                    product_definitional,
                }),
        ))
    }

    /// `COMPOSITE_SHAPE_ASPECT` — strict AP242 constructor.
    pub fn add_composite_shape_aspect(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
    ) -> Result<CompositeShapeAspectId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(CompositeShapeAspectId(
            self.model
                .composite_shape_aspect_arena
                .push(CompositeShapeAspect {
                    name,
                    description,
                    of_shape,
                    product_definitional,
                }),
        ))
    }

    /// `COMPOSITE_TEXT` — strict AP242 constructor.
    pub fn add_composite_text(
        &mut self,
        name: String,
        collected_text: Vec<TextOrCharacterRef>,
    ) -> Result<CompositeTextId, AuthorError> {
        {
            let x = &collected_text;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "COMPOSITE_TEXT",
                    attribute: "collected_text",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &collected_text {
            check_text_or_character_ref(&self.model, e0)?;
        }
        Ok(CompositeTextId(self.model.composite_text_arena.push(
            CompositeText {
                name,
                collected_text,
            },
        )))
    }

    /// `COMPOUND_REPRESENTATION_ITEM` — strict AP242 constructor.
    pub fn add_compound_representation_item(
        &mut self,
        name: String,
        item_element: CompoundItemDefinitionRef,
    ) -> Result<CompoundRepresentationItemId, AuthorError> {
        check_compound_item_definition_ref(&self.model, &item_element)?;
        Ok(CompoundRepresentationItemId(
            self.model
                .compound_representation_item_arena
                .push(CompoundRepresentationItem { name, item_element }),
        ))
    }

    /// `CONCENTRICITY_TOLERANCE` — strict AP242 constructor.
    pub fn add_concentricity_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        datum_system: Vec<DatumSystemOrReferenceRef>,
    ) -> Result<ConcentricityToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        {
            let x = &datum_system;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CONCENTRICITY_TOLERANCE",
                    attribute: "datum_system",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &datum_system {
            check_datum_system_or_reference_ref(&self.model, e0)?;
        }
        Ok(ConcentricityToleranceId(
            self.model
                .concentricity_tolerance_arena
                .push(ConcentricityTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    datum_system,
                }),
        ))
    }

    /// `CONFIGURATION_DESIGN` — strict AP242 constructor.
    pub fn add_configuration_design(
        &mut self,
        configuration: ConfigurationItemRef,
        design: ConfigurationDesignItemRef,
    ) -> Result<ConfigurationDesignId, AuthorError> {
        check_configuration_item_ref(&self.model, &configuration)?;
        check_configuration_design_item_ref(&self.model, &design)?;
        Ok(ConfigurationDesignId(
            self.model
                .configuration_design_arena
                .push(ConfigurationDesign {
                    configuration,
                    design,
                }),
        ))
    }

    /// `CONFIGURATION_EFFECTIVITY` — strict AP242 constructor.
    pub fn add_configuration_effectivity(
        &mut self,
        id: String,
        usage: ProductDefinitionRelationshipRef,
        configuration: ConfigurationDesignRef,
    ) -> Result<ConfigurationEffectivityId, AuthorError> {
        check_product_definition_relationship_ref(&self.model, &usage)?;
        check_configuration_design_ref(&self.model, &configuration)?;
        Ok(ConfigurationEffectivityId(
            self.model
                .configuration_effectivity_arena
                .push(ConfigurationEffectivity {
                    id,
                    usage,
                    configuration,
                }),
        ))
    }

    /// `CONFIGURATION_ITEM` — strict AP242 constructor.
    pub fn add_configuration_item(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
        item_concept: ProductConceptRef,
        purpose: Option<String>,
    ) -> Result<ConfigurationItemId, AuthorError> {
        check_product_concept_ref(&self.model, &item_concept)?;
        Ok(ConfigurationItemId(
            self.model.configuration_item_arena.push(ConfigurationItem {
                id,
                name,
                description,
                item_concept,
                purpose,
            }),
        ))
    }

    /// `CONIC` — strict AP242 constructor.
    pub fn add_conic(
        &mut self,
        name: String,
        position: Axis2PlacementRef,
    ) -> Result<ConicId, AuthorError> {
        check_axis2_placement_ref(&self.model, &position)?;
        Ok(ConicId(
            self.model.conic_arena.push(Conic { name, position }),
        ))
    }

    /// `CONICAL_SURFACE` — strict AP242 constructor.
    pub fn add_conical_surface(
        &mut self,
        name: String,
        position: Axis2Placement3dRef,
        radius: f64,
        semi_angle: f64,
    ) -> Result<ConicalSurfaceId, AuthorError> {
        check_axis2_placement3d_ref(&self.model, &position)?;
        Ok(ConicalSurfaceId(self.model.conical_surface_arena.push(
            ConicalSurface {
                name,
                position,
                radius,
                semi_angle,
            },
        )))
    }

    /// `CONNECTED_FACE_SET` — strict AP242 constructor.
    pub fn add_connected_face_set(
        &mut self,
        name: String,
        cfs_faces: Option<Vec<FaceRef>>,
    ) -> Result<ConnectedFaceSetId, AuthorError> {
        if let Some(x) = &cfs_faces {
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CONNECTED_FACE_SET",
                    attribute: "cfs_faces",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        if let Some(x) = &cfs_faces {
            for e0 in x {
                check_face_ref(&self.model, e0)?;
            }
        }
        Ok(ConnectedFaceSetId(
            self.model
                .connected_face_set_arena
                .push(ConnectedFaceSet { name, cfs_faces }),
        ))
    }

    /// `CONSTRUCTIVE_GEOMETRY_REPRESENTATION` — strict AP242 constructor.
    pub fn add_constructive_geometry_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<ConstructiveGeometryRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(ConstructiveGeometryRepresentationId(
            self.model.constructive_geometry_representation_arena.push(
                ConstructiveGeometryRepresentation {
                    name,
                    items,
                    context_of_items,
                },
            ),
        ))
    }

    /// `CONSTRUCTIVE_GEOMETRY_REPRESENTATION_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_constructive_geometry_representation_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        rep_1: ConstructiveGeometryRepresentationOrShapeRepresentationRef,
        rep_2: RepresentationOrRepresentationReferenceRef,
    ) -> Result<ConstructiveGeometryRepresentationRelationshipId, AuthorError> {
        check_constructive_geometry_representation_or_shape_representation_ref(
            &self.model,
            &rep_1,
        )?;
        check_representation_or_representation_reference_ref(&self.model, &rep_2)?;
        Ok(ConstructiveGeometryRepresentationRelationshipId(
            self.model
                .constructive_geometry_representation_relationship_arena
                .push(ConstructiveGeometryRepresentationRelationship {
                    name,
                    description,
                    rep_1,
                    rep_2,
                }),
        ))
    }

    /// `CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM` — strict AP242 constructor.
    pub fn add_context_dependent_over_riding_styled_item(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: StyledItemTargetRef,
        over_ridden_style: StyledItemRef,
        style_context: Vec<StyleContextSelectRef>,
    ) -> Result<ContextDependentOverRidingStyledItemId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_styled_item_target_ref(&self.model, &item)?;
        check_styled_item_ref(&self.model, &over_ridden_style)?;
        {
            let x = &style_context;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                    attribute: "style_context",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &style_context {
            check_style_context_select_ref(&self.model, e0)?;
        }
        Ok(ContextDependentOverRidingStyledItemId(
            self.model
                .context_dependent_over_riding_styled_item_arena
                .push(ContextDependentOverRidingStyledItem {
                    name,
                    styles,
                    item,
                    over_ridden_style,
                    style_context,
                }),
        ))
    }

    /// `CONTEXT_DEPENDENT_SHAPE_REPRESENTATION` — strict AP242 constructor.
    pub fn add_context_dependent_shape_representation(
        &mut self,
        representation_relation: ShapeRepresentationRelationshipRef,
        represented_product_relation: ProductDefinitionShapeRef,
    ) -> Result<ContextDependentShapeRepresentationId, AuthorError> {
        check_shape_representation_relationship_ref(&self.model, &representation_relation)?;
        check_product_definition_shape_ref(&self.model, &represented_product_relation)?;
        Ok(ContextDependentShapeRepresentationId(
            self.model
                .context_dependent_shape_representation_arena
                .push(ContextDependentShapeRepresentation {
                    representation_relation,
                    represented_product_relation,
                }),
        ))
    }

    /// `CONTEXT_DEPENDENT_UNIT` — strict AP242 constructor.
    pub fn add_context_dependent_unit(
        &mut self,
        dimensions: DimensionalExponentsRef,
        name: String,
    ) -> Result<ContextDependentUnitId, AuthorError> {
        check_dimensional_exponents_ref(&self.model, &dimensions)?;
        Ok(ContextDependentUnitId(
            self.model
                .context_dependent_unit_arena
                .push(ContextDependentUnit { dimensions, name }),
        ))
    }

    /// `CONTINUOUS_SHAPE_ASPECT` — strict AP242 constructor.
    pub fn add_continuous_shape_aspect(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
    ) -> Result<ContinuousShapeAspectId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(ContinuousShapeAspectId(
            self.model
                .continuous_shape_aspect_arena
                .push(ContinuousShapeAspect {
                    name,
                    description,
                    of_shape,
                    product_definitional,
                }),
        ))
    }

    /// `CONTRACT` — strict AP242 constructor.
    pub fn add_contract(
        &mut self,
        name: String,
        purpose: String,
        kind: ContractTypeRef,
    ) -> Result<ContractId, AuthorError> {
        check_contract_type_ref(&self.model, &kind)?;
        Ok(ContractId(self.model.contract_arena.push(Contract {
            name,
            purpose,
            kind,
        })))
    }

    /// `CONTRACT_TYPE` — strict AP242 constructor.
    pub fn add_contract_type(
        &mut self,
        description: String,
    ) -> Result<ContractTypeId, AuthorError> {
        Ok(ContractTypeId(
            self.model
                .contract_type_arena
                .push(ContractType { description }),
        ))
    }

    /// `CONVERSION_BASED_UNIT` — strict AP242 constructor.
    pub fn add_conversion_based_unit(
        &mut self,
        dimensions: DimensionalExponentsRef,
        name: String,
        conversion_factor: MeasureWithUnitRef,
    ) -> Result<ConversionBasedUnitId, AuthorError> {
        check_dimensional_exponents_ref(&self.model, &dimensions)?;
        check_measure_with_unit_ref(&self.model, &conversion_factor)?;
        Ok(ConversionBasedUnitId(
            self.model
                .conversion_based_unit_arena
                .push(ConversionBasedUnit {
                    dimensions,
                    name,
                    conversion_factor,
                }),
        ))
    }

    /// `COORDINATED_UNIVERSAL_TIME_OFFSET` — strict AP242 constructor.
    pub fn add_coordinated_universal_time_offset(
        &mut self,
        hour_offset: i64,
        minute_offset: Option<i64>,
        sense: AheadOrBehind,
    ) -> Result<CoordinatedUniversalTimeOffsetId, AuthorError> {
        Ok(CoordinatedUniversalTimeOffsetId(
            self.model.coordinated_universal_time_offset_arena.push(
                CoordinatedUniversalTimeOffset {
                    hour_offset,
                    minute_offset,
                    sense,
                },
            ),
        ))
    }

    /// `COORDINATES_LIST` — strict AP242 constructor.
    pub fn add_coordinates_list(
        &mut self,
        name: String,
        npoints: i64,
        position_coords: Vec<Vec<f64>>,
    ) -> Result<CoordinatesListId, AuthorError> {
        {
            let x = &position_coords;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "COORDINATES_LIST",
                    attribute: "position_coords",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        Ok(CoordinatesListId(self.model.coordinates_list_arena.push(
            CoordinatesList {
                name,
                npoints,
                position_coords,
            },
        )))
    }

    /// `CURVE` — strict AP242 constructor.
    pub fn add_curve(&mut self, name: String) -> Result<CurveId, AuthorError> {
        Ok(CurveId(self.model.curve_arena.push(Curve { name })))
    }

    /// `CURVE_STYLE` — strict AP242 constructor.
    pub fn add_curve_style(
        &mut self,
        name: String,
        curve_font: Option<CurveFontOrScaledCurveFontSelectRef>,
        curve_width: Option<SizeSelectRef>,
        curve_colour: Option<ColourRef>,
    ) -> Result<CurveStyleId, AuthorError> {
        if let Some(x) = &curve_font {
            check_curve_font_or_scaled_curve_font_select_ref(&self.model, x)?;
        }
        if let Some(x) = &curve_width {
            check_size_select_ref(&self.model, x)?;
        }
        if let Some(x) = &curve_colour {
            check_colour_ref(&self.model, x)?;
        }
        Ok(CurveStyleId(self.model.curve_style_arena.push(
            CurveStyle {
                name,
                curve_font,
                curve_width,
                curve_colour,
            },
        )))
    }

    /// `CURVE_STYLE_FONT` — strict AP242 constructor.
    pub fn add_curve_style_font(
        &mut self,
        name: String,
        pattern_list: Vec<CurveStyleFontPatternRef>,
    ) -> Result<CurveStyleFontId, AuthorError> {
        {
            let x = &pattern_list;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "CURVE_STYLE_FONT",
                    attribute: "pattern_list",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &pattern_list {
            check_curve_style_font_pattern_ref(&self.model, e0)?;
        }
        Ok(CurveStyleFontId(
            self.model
                .curve_style_font_arena
                .push(CurveStyleFont { name, pattern_list }),
        ))
    }

    /// `CURVE_STYLE_FONT_AND_SCALING` — strict AP242 constructor.
    pub fn add_curve_style_font_and_scaling(
        &mut self,
        name: String,
        curve_font: CurveStyleFontSelectRef,
        curve_font_scaling: f64,
    ) -> Result<CurveStyleFontAndScalingId, AuthorError> {
        check_curve_style_font_select_ref(&self.model, &curve_font)?;
        Ok(CurveStyleFontAndScalingId(
            self.model
                .curve_style_font_and_scaling_arena
                .push(CurveStyleFontAndScaling {
                    name,
                    curve_font,
                    curve_font_scaling,
                }),
        ))
    }

    /// `CURVE_STYLE_FONT_PATTERN` — strict AP242 constructor.
    pub fn add_curve_style_font_pattern(
        &mut self,
        visible_segment_length: f64,
        invisible_segment_length: f64,
    ) -> Result<CurveStyleFontPatternId, AuthorError> {
        Ok(CurveStyleFontPatternId(
            self.model
                .curve_style_font_pattern_arena
                .push(CurveStyleFontPattern {
                    visible_segment_length,
                    invisible_segment_length,
                }),
        ))
    }

    /// `CURVE_STYLE_RENDERING` — strict AP242 constructor.
    pub fn add_curve_style_rendering(
        &mut self,
        rendering_method: ShadingCurveMethod,
        rendering_properties: SurfaceRenderingPropertiesRef,
    ) -> Result<CurveStyleRenderingId, AuthorError> {
        check_surface_rendering_properties_ref(&self.model, &rendering_properties)?;
        Ok(CurveStyleRenderingId(
            self.model
                .curve_style_rendering_arena
                .push(CurveStyleRendering {
                    rendering_method,
                    rendering_properties,
                }),
        ))
    }

    /// `CYLINDRICAL_SURFACE` — strict AP242 constructor.
    pub fn add_cylindrical_surface(
        &mut self,
        name: String,
        position: Axis2Placement3dRef,
        radius: f64,
    ) -> Result<CylindricalSurfaceId, AuthorError> {
        check_axis2_placement3d_ref(&self.model, &position)?;
        Ok(CylindricalSurfaceId(
            self.model
                .cylindrical_surface_arena
                .push(CylindricalSurface {
                    name,
                    position,
                    radius,
                }),
        ))
    }

    /// `CYLINDRICITY_TOLERANCE` — strict AP242 constructor.
    pub fn add_cylindricity_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
    ) -> Result<CylindricityToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        Ok(CylindricityToleranceId(
            self.model
                .cylindricity_tolerance_arena
                .push(CylindricityTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                }),
        ))
    }

    /// `DATE` — strict AP242 constructor.
    pub fn add_date(&mut self, year_component: i64) -> Result<DateId, AuthorError> {
        Ok(DateId(self.model.date_arena.push(Date { year_component })))
    }

    /// `DATE_AND_TIME` — strict AP242 constructor.
    pub fn add_date_and_time(
        &mut self,
        date_component: DateRef,
        time_component: LocalTimeRef,
    ) -> Result<DateAndTimeId, AuthorError> {
        check_date_ref(&self.model, &date_component)?;
        check_local_time_ref(&self.model, &time_component)?;
        Ok(DateAndTimeId(self.model.date_and_time_arena.push(
            DateAndTime {
                date_component,
                time_component,
            },
        )))
    }

    /// `DATE_AND_TIME_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_date_and_time_assignment(
        &mut self,
        assigned_date_and_time: DateAndTimeRef,
        role: DateTimeRoleRef,
    ) -> Result<DateAndTimeAssignmentId, AuthorError> {
        check_date_and_time_ref(&self.model, &assigned_date_and_time)?;
        check_date_time_role_ref(&self.model, &role)?;
        Ok(DateAndTimeAssignmentId(
            self.model
                .date_and_time_assignment_arena
                .push(DateAndTimeAssignment {
                    assigned_date_and_time,
                    role,
                }),
        ))
    }

    /// `DATE_ROLE` — strict AP242 constructor.
    pub fn add_date_role(&mut self, name: String) -> Result<DateRoleId, AuthorError> {
        Ok(DateRoleId(
            self.model.date_role_arena.push(DateRole { name }),
        ))
    }

    /// `DATE_TIME_ROLE` — strict AP242 constructor.
    pub fn add_date_time_role(&mut self, name: String) -> Result<DateTimeRoleId, AuthorError> {
        Ok(DateTimeRoleId(
            self.model.date_time_role_arena.push(DateTimeRole { name }),
        ))
    }

    /// `DATUM` — strict AP242 constructor.
    pub fn add_datum(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
        identification: String,
    ) -> Result<DatumId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(DatumId(self.model.datum_arena.push(Datum {
            name,
            description,
            of_shape,
            product_definitional,
            identification,
        })))
    }

    /// `DATUM_FEATURE` — strict AP242 constructor.
    pub fn add_datum_feature(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
    ) -> Result<DatumFeatureId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(DatumFeatureId(self.model.datum_feature_arena.push(
            DatumFeature {
                name,
                description,
                of_shape,
                product_definitional,
            },
        )))
    }

    /// `DATUM_REFERENCE` — strict AP242 constructor.
    pub fn add_datum_reference(
        &mut self,
        precedence: i64,
        referenced_datum: DatumRef,
    ) -> Result<DatumReferenceId, AuthorError> {
        check_datum_ref(&self.model, &referenced_datum)?;
        Ok(DatumReferenceId(self.model.datum_reference_arena.push(
            DatumReference {
                precedence,
                referenced_datum,
            },
        )))
    }

    /// `DATUM_REFERENCE_COMPARTMENT` — strict AP242 constructor.
    pub fn add_datum_reference_compartment(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
        base: DatumOrCommonDatumRef,
        modifiers: Option<Vec<DatumReferenceModifierRef>>,
    ) -> Result<DatumReferenceCompartmentId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        check_datum_or_common_datum_ref(&self.model, &base)?;
        if let Some(x) = &modifiers {
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                    attribute: "modifiers",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        if let Some(x) = &modifiers {
            for e0 in x {
                check_datum_reference_modifier_ref(&self.model, e0)?;
            }
        }
        Ok(DatumReferenceCompartmentId(
            self.model
                .datum_reference_compartment_arena
                .push(DatumReferenceCompartment {
                    name,
                    description,
                    of_shape,
                    product_definitional,
                    base,
                    modifiers,
                }),
        ))
    }

    /// `DATUM_REFERENCE_ELEMENT` — strict AP242 constructor.
    pub fn add_datum_reference_element(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
        base: DatumOrCommonDatumRef,
        modifiers: Option<Vec<DatumReferenceModifierRef>>,
    ) -> Result<DatumReferenceElementId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        check_datum_or_common_datum_ref(&self.model, &base)?;
        if let Some(x) = &modifiers {
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "DATUM_REFERENCE_ELEMENT",
                    attribute: "modifiers",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        if let Some(x) = &modifiers {
            for e0 in x {
                check_datum_reference_modifier_ref(&self.model, e0)?;
            }
        }
        Ok(DatumReferenceElementId(
            self.model
                .datum_reference_element_arena
                .push(DatumReferenceElement {
                    name,
                    description,
                    of_shape,
                    product_definitional,
                    base,
                    modifiers,
                }),
        ))
    }

    /// `DATUM_REFERENCE_MODIFIER_WITH_VALUE` — strict AP242 constructor.
    pub fn add_datum_reference_modifier_with_value(
        &mut self,
        modifier_type: DatumReferenceModifierType,
        modifier_value: LengthMeasureWithUnitRef,
    ) -> Result<DatumReferenceModifierWithValueId, AuthorError> {
        check_length_measure_with_unit_ref(&self.model, &modifier_value)?;
        Ok(DatumReferenceModifierWithValueId(
            self.model.datum_reference_modifier_with_value_arena.push(
                DatumReferenceModifierWithValue {
                    modifier_type,
                    modifier_value,
                },
            ),
        ))
    }

    /// `DATUM_SYSTEM` — strict AP242 constructor.
    pub fn add_datum_system(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
        constituents: Vec<DatumReferenceCompartmentRef>,
    ) -> Result<DatumSystemId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        {
            let x = &constituents;
            if x.len() < 1 || x.len() > 3 {
                return Err(AuthorError::Cardinality {
                    entity: "DATUM_SYSTEM",
                    attribute: "constituents",
                    got: x.len(),
                    min: 1,
                    max: Some(3),
                });
            }
        }
        for e0 in &constituents {
            check_datum_reference_compartment_ref(&self.model, e0)?;
        }
        Ok(DatumSystemId(self.model.datum_system_arena.push(
            DatumSystem {
                name,
                description,
                of_shape,
                product_definitional,
                constituents,
            },
        )))
    }

    /// `DATUM_TARGET` — strict AP242 constructor.
    pub fn add_datum_target(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
        target_id: String,
    ) -> Result<DatumTargetId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(DatumTargetId(self.model.datum_target_arena.push(
            DatumTarget {
                name,
                description,
                of_shape,
                product_definitional,
                target_id,
            },
        )))
    }

    /// `DEFAULT_MODEL_GEOMETRIC_VIEW` — strict AP242 constructor.
    pub fn add_default_model_geometric_view(
        &mut self,
        name: String,
        description: Option<String>,
        item: RepresentationItemRef,
        rep: RepresentationRef,
        name_1: String,
        description_1: Option<String>,
        of_shape: ProductDefinitionShapeRef,
    ) -> Result<DefaultModelGeometricViewId, AuthorError> {
        check_representation_item_ref(&self.model, &item)?;
        check_representation_ref(&self.model, &rep)?;
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(DefaultModelGeometricViewId(
            self.model
                .default_model_geometric_view_arena
                .push(DefaultModelGeometricView {
                    name,
                    description,
                    item,
                    rep,
                    name_1,
                    description_1,
                    of_shape,
                }),
        ))
    }

    /// `DEFINED_CHARACTER_GLYPH` — strict AP242 constructor.
    pub fn add_defined_character_glyph(
        &mut self,
        name: String,
        definition: DefinedGlyphSelectRef,
        placement: Axis2PlacementRef,
    ) -> Result<DefinedCharacterGlyphId, AuthorError> {
        check_defined_glyph_select_ref(&self.model, &definition)?;
        check_axis2_placement_ref(&self.model, &placement)?;
        Ok(DefinedCharacterGlyphId(
            self.model
                .defined_character_glyph_arena
                .push(DefinedCharacterGlyph {
                    name,
                    definition,
                    placement,
                }),
        ))
    }

    /// `DEFINED_SYMBOL` — strict AP242 constructor.
    pub fn add_defined_symbol(
        &mut self,
        name: String,
        definition: DefinedSymbolSelectRef,
        target: SymbolTargetRef,
    ) -> Result<DefinedSymbolId, AuthorError> {
        check_defined_symbol_select_ref(&self.model, &definition)?;
        check_symbol_target_ref(&self.model, &target)?;
        Ok(DefinedSymbolId(self.model.defined_symbol_arena.push(
            DefinedSymbol {
                name,
                definition,
                target,
            },
        )))
    }

    /// `DEFINITIONAL_REPRESENTATION` — strict AP242 constructor.
    pub fn add_definitional_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<DefinitionalRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "DEFINITIONAL_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(DefinitionalRepresentationId(
            self.model
                .definitional_representation_arena
                .push(DefinitionalRepresentation {
                    name,
                    items,
                    context_of_items,
                }),
        ))
    }

    /// `DEFINITIONAL_REPRESENTATION_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_definitional_representation_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        rep_1: RepresentationOrRepresentationReferenceRef,
        rep_2: RepresentationOrRepresentationReferenceRef,
    ) -> Result<DefinitionalRepresentationRelationshipId, AuthorError> {
        check_representation_or_representation_reference_ref(&self.model, &rep_1)?;
        check_representation_or_representation_reference_ref(&self.model, &rep_2)?;
        Ok(DefinitionalRepresentationRelationshipId(
            self.model
                .definitional_representation_relationship_arena
                .push(DefinitionalRepresentationRelationship {
                    name,
                    description,
                    rep_1,
                    rep_2,
                }),
        ))
    }

    /// `DEFINITIONAL_REPRESENTATION_RELATIONSHIP_WITH_SAME_CONTEXT` — strict AP242 constructor.
    pub fn add_definitional_representation_relationship_with_same_context(
        &mut self,
        name: String,
        description: Option<String>,
        rep_1: RepresentationOrRepresentationReferenceRef,
        rep_2: RepresentationOrRepresentationReferenceRef,
    ) -> Result<DefinitionalRepresentationRelationshipWithSameContextId, AuthorError> {
        check_representation_or_representation_reference_ref(&self.model, &rep_1)?;
        check_representation_or_representation_reference_ref(&self.model, &rep_2)?;
        Ok(DefinitionalRepresentationRelationshipWithSameContextId(
            self.model
                .definitional_representation_relationship_with_same_context_arena
                .push(DefinitionalRepresentationRelationshipWithSameContext {
                    name,
                    description,
                    rep_1,
                    rep_2,
                }),
        ))
    }

    /// `DEGENERATE_TOROIDAL_SURFACE` — strict AP242 constructor.
    pub fn add_degenerate_toroidal_surface(
        &mut self,
        name: String,
        position: Axis2Placement3dRef,
        major_radius: f64,
        minor_radius: f64,
        select_outer: bool,
    ) -> Result<DegenerateToroidalSurfaceId, AuthorError> {
        check_axis2_placement3d_ref(&self.model, &position)?;
        Ok(DegenerateToroidalSurfaceId(
            self.model
                .degenerate_toroidal_surface_arena
                .push(DegenerateToroidalSurface {
                    name,
                    position,
                    major_radius,
                    minor_radius,
                    select_outer,
                }),
        ))
    }

    /// `DERIVED_SHAPE_ASPECT` — strict AP242 constructor.
    pub fn add_derived_shape_aspect(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
    ) -> Result<DerivedShapeAspectId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(DerivedShapeAspectId(
            self.model
                .derived_shape_aspect_arena
                .push(DerivedShapeAspect {
                    name,
                    description,
                    of_shape,
                    product_definitional,
                }),
        ))
    }

    /// `DERIVED_UNIT` — strict AP242 constructor.
    pub fn add_derived_unit(
        &mut self,
        elements: Vec<DerivedUnitElementRef>,
    ) -> Result<DerivedUnitId, AuthorError> {
        {
            let x = &elements;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "DERIVED_UNIT",
                    attribute: "elements",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &elements {
            check_derived_unit_element_ref(&self.model, e0)?;
        }
        Ok(DerivedUnitId(
            self.model.derived_unit_arena.push(DerivedUnit { elements }),
        ))
    }

    /// `DERIVED_UNIT_ELEMENT` — strict AP242 constructor.
    pub fn add_derived_unit_element(
        &mut self,
        unit: NamedUnitRef,
        exponent: f64,
    ) -> Result<DerivedUnitElementId, AuthorError> {
        check_named_unit_ref(&self.model, &unit)?;
        Ok(DerivedUnitElementId(
            self.model
                .derived_unit_element_arena
                .push(DerivedUnitElement { unit, exponent }),
        ))
    }

    /// `DESCRIPTION_ATTRIBUTE` — strict AP242 constructor.
    pub fn add_description_attribute(
        &mut self,
        attribute_value: String,
        described_item: DescriptionAttributeSelectRef,
    ) -> Result<DescriptionAttributeId, AuthorError> {
        check_description_attribute_select_ref(&self.model, &described_item)?;
        Ok(DescriptionAttributeId(
            self.model
                .description_attribute_arena
                .push(DescriptionAttribute {
                    attribute_value,
                    described_item,
                }),
        ))
    }

    /// `DESCRIPTIVE_REPRESENTATION_ITEM` — strict AP242 constructor.
    pub fn add_descriptive_representation_item(
        &mut self,
        name: String,
        description: String,
    ) -> Result<DescriptiveRepresentationItemId, AuthorError> {
        Ok(DescriptiveRepresentationItemId(
            self.model
                .descriptive_representation_item_arena
                .push(DescriptiveRepresentationItem { name, description }),
        ))
    }

    /// `DESIGN_CONTEXT` — strict AP242 constructor.
    pub fn add_design_context(
        &mut self,
        name: String,
        frame_of_reference: ApplicationContextRef,
        life_cycle_stage: String,
    ) -> Result<DesignContextId, AuthorError> {
        check_application_context_ref(&self.model, &frame_of_reference)?;
        Ok(DesignContextId(self.model.design_context_arena.push(
            DesignContext {
                name,
                frame_of_reference,
                life_cycle_stage,
            },
        )))
    }

    /// `DIMENSIONAL_CHARACTERISTIC_REPRESENTATION` — strict AP242 constructor.
    pub fn add_dimensional_characteristic_representation(
        &mut self,
        dimension: DimensionalCharacteristicRef,
        representation: ShapeDimensionRepresentationRef,
    ) -> Result<DimensionalCharacteristicRepresentationId, AuthorError> {
        check_dimensional_characteristic_ref(&self.model, &dimension)?;
        check_shape_dimension_representation_ref(&self.model, &representation)?;
        Ok(DimensionalCharacteristicRepresentationId(
            self.model
                .dimensional_characteristic_representation_arena
                .push(DimensionalCharacteristicRepresentation {
                    dimension,
                    representation,
                }),
        ))
    }

    /// `DIMENSIONAL_EXPONENTS` — strict AP242 constructor.
    pub fn add_dimensional_exponents(
        &mut self,
        length_exponent: f64,
        mass_exponent: f64,
        time_exponent: f64,
        electric_current_exponent: f64,
        thermodynamic_temperature_exponent: f64,
        amount_of_substance_exponent: f64,
        luminous_intensity_exponent: f64,
    ) -> Result<DimensionalExponentsId, AuthorError> {
        Ok(DimensionalExponentsId(
            self.model
                .dimensional_exponents_arena
                .push(DimensionalExponents {
                    length_exponent,
                    mass_exponent,
                    time_exponent,
                    electric_current_exponent,
                    thermodynamic_temperature_exponent,
                    amount_of_substance_exponent,
                    luminous_intensity_exponent,
                }),
        ))
    }

    /// `DIMENSIONAL_LOCATION` — strict AP242 constructor.
    pub fn add_dimensional_location(
        &mut self,
        name: String,
        description: Option<String>,
        relating_shape_aspect: ShapeAspectRef,
        related_shape_aspect: ShapeAspectRef,
    ) -> Result<DimensionalLocationId, AuthorError> {
        check_shape_aspect_ref(&self.model, &relating_shape_aspect)?;
        check_shape_aspect_ref(&self.model, &related_shape_aspect)?;
        Ok(DimensionalLocationId(
            self.model
                .dimensional_location_arena
                .push(DimensionalLocation {
                    name,
                    description,
                    relating_shape_aspect,
                    related_shape_aspect,
                }),
        ))
    }

    /// `DIMENSIONAL_LOCATION_WITH_PATH` — strict AP242 constructor.
    pub fn add_dimensional_location_with_path(
        &mut self,
        name: String,
        description: Option<String>,
        relating_shape_aspect: ShapeAspectRef,
        related_shape_aspect: ShapeAspectRef,
        path: ShapeAspectRef,
    ) -> Result<DimensionalLocationWithPathId, AuthorError> {
        check_shape_aspect_ref(&self.model, &relating_shape_aspect)?;
        check_shape_aspect_ref(&self.model, &related_shape_aspect)?;
        check_shape_aspect_ref(&self.model, &path)?;
        Ok(DimensionalLocationWithPathId(
            self.model
                .dimensional_location_with_path_arena
                .push(DimensionalLocationWithPath {
                    name,
                    description,
                    relating_shape_aspect,
                    related_shape_aspect,
                    path,
                }),
        ))
    }

    /// `DIMENSIONAL_SIZE` — strict AP242 constructor.
    pub fn add_dimensional_size(
        &mut self,
        applies_to: ShapeAspectRef,
        name: String,
    ) -> Result<DimensionalSizeId, AuthorError> {
        check_shape_aspect_ref(&self.model, &applies_to)?;
        Ok(DimensionalSizeId(
            self.model
                .dimensional_size_arena
                .push(DimensionalSize { applies_to, name }),
        ))
    }

    /// `DIMENSIONAL_SIZE_WITH_DATUM_FEATURE` — strict AP242 constructor.
    pub fn add_dimensional_size_with_datum_feature(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
        applies_to: ShapeAspectRef,
        name_1: String,
    ) -> Result<DimensionalSizeWithDatumFeatureId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        check_shape_aspect_ref(&self.model, &applies_to)?;
        Ok(DimensionalSizeWithDatumFeatureId(
            self.model.dimensional_size_with_datum_feature_arena.push(
                DimensionalSizeWithDatumFeature {
                    name,
                    description,
                    of_shape,
                    product_definitional,
                    applies_to,
                    name_1,
                },
            ),
        ))
    }

    /// `DIMENSIONAL_SIZE_WITH_PATH` — strict AP242 constructor.
    pub fn add_dimensional_size_with_path(
        &mut self,
        applies_to: ShapeAspectRef,
        name: String,
        path: ShapeAspectRef,
    ) -> Result<DimensionalSizeWithPathId, AuthorError> {
        check_shape_aspect_ref(&self.model, &applies_to)?;
        check_shape_aspect_ref(&self.model, &path)?;
        Ok(DimensionalSizeWithPathId(
            self.model
                .dimensional_size_with_path_arena
                .push(DimensionalSizeWithPath {
                    applies_to,
                    name,
                    path,
                }),
        ))
    }

    /// `DIRECTED_DIMENSIONAL_LOCATION` — strict AP242 constructor.
    pub fn add_directed_dimensional_location(
        &mut self,
        name: String,
        description: Option<String>,
        relating_shape_aspect: ShapeAspectRef,
        related_shape_aspect: ShapeAspectRef,
    ) -> Result<DirectedDimensionalLocationId, AuthorError> {
        check_shape_aspect_ref(&self.model, &relating_shape_aspect)?;
        check_shape_aspect_ref(&self.model, &related_shape_aspect)?;
        Ok(DirectedDimensionalLocationId(
            self.model
                .directed_dimensional_location_arena
                .push(DirectedDimensionalLocation {
                    name,
                    description,
                    relating_shape_aspect,
                    related_shape_aspect,
                }),
        ))
    }

    /// `DIRECTION` — strict AP242 constructor.
    pub fn add_direction(
        &mut self,
        name: String,
        direction_ratios: Vec<f64>,
    ) -> Result<DirectionId, AuthorError> {
        {
            let x = &direction_ratios;
            if x.len() < 2 || x.len() > 3 {
                return Err(AuthorError::Cardinality {
                    entity: "DIRECTION",
                    attribute: "direction_ratios",
                    got: x.len(),
                    min: 2,
                    max: Some(3),
                });
            }
        }
        Ok(DirectionId(self.model.direction_arena.push(Direction {
            name,
            direction_ratios,
        })))
    }

    /// `DOCUMENT` — strict AP242 constructor.
    pub fn add_document(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
        kind: DocumentTypeRef,
    ) -> Result<DocumentId, AuthorError> {
        check_document_type_ref(&self.model, &kind)?;
        Ok(DocumentId(self.model.document_arena.push(Document {
            id,
            name,
            description,
            kind,
        })))
    }

    /// `DOCUMENT_FILE` — strict AP242 constructor.
    pub fn add_document_file(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
        kind: DocumentTypeRef,
        name_1: String,
        description_1: Option<String>,
    ) -> Result<DocumentFileId, AuthorError> {
        check_document_type_ref(&self.model, &kind)?;
        Ok(DocumentFileId(self.model.document_file_arena.push(
            DocumentFile {
                id,
                name,
                description,
                kind,
                name_1,
                description_1,
            },
        )))
    }

    /// `DOCUMENT_PRODUCT_ASSOCIATION` — strict AP242 constructor.
    pub fn add_document_product_association(
        &mut self,
        name: String,
        description: Option<String>,
        relating_document: DocumentRef,
        related_product: ProductOrFormationOrDefinitionRef,
    ) -> Result<DocumentProductAssociationId, AuthorError> {
        check_document_ref(&self.model, &relating_document)?;
        check_product_or_formation_or_definition_ref(&self.model, &related_product)?;
        Ok(DocumentProductAssociationId(
            self.model
                .document_product_association_arena
                .push(DocumentProductAssociation {
                    name,
                    description,
                    relating_document,
                    related_product,
                }),
        ))
    }

    /// `DOCUMENT_PRODUCT_EQUIVALENCE` — strict AP242 constructor.
    pub fn add_document_product_equivalence(
        &mut self,
        name: String,
        description: Option<String>,
        relating_document: DocumentRef,
        related_product: ProductOrFormationOrDefinitionRef,
    ) -> Result<DocumentProductEquivalenceId, AuthorError> {
        check_document_ref(&self.model, &relating_document)?;
        check_product_or_formation_or_definition_ref(&self.model, &related_product)?;
        Ok(DocumentProductEquivalenceId(
            self.model
                .document_product_equivalence_arena
                .push(DocumentProductEquivalence {
                    name,
                    description,
                    relating_document,
                    related_product,
                }),
        ))
    }

    /// `DOCUMENT_REFERENCE` — strict AP242 constructor.
    pub fn add_document_reference(
        &mut self,
        assigned_document: DocumentRef,
        source: String,
    ) -> Result<DocumentReferenceId, AuthorError> {
        check_document_ref(&self.model, &assigned_document)?;
        Ok(DocumentReferenceId(
            self.model.document_reference_arena.push(DocumentReference {
                assigned_document,
                source,
            }),
        ))
    }

    /// `DOCUMENT_REPRESENTATION_TYPE` — strict AP242 constructor.
    pub fn add_document_representation_type(
        &mut self,
        name: String,
        represented_document: DocumentRef,
    ) -> Result<DocumentRepresentationTypeId, AuthorError> {
        check_document_ref(&self.model, &represented_document)?;
        Ok(DocumentRepresentationTypeId(
            self.model
                .document_representation_type_arena
                .push(DocumentRepresentationType {
                    name,
                    represented_document,
                }),
        ))
    }

    /// `DOCUMENT_TYPE` — strict AP242 constructor.
    pub fn add_document_type(
        &mut self,
        product_data_type: String,
    ) -> Result<DocumentTypeId, AuthorError> {
        Ok(DocumentTypeId(
            self.model
                .document_type_arena
                .push(DocumentType { product_data_type }),
        ))
    }

    /// `DRAUGHTING_ANNOTATION_OCCURRENCE` — strict AP242 constructor.
    pub fn add_draughting_annotation_occurrence(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: StyledItemTargetRef,
    ) -> Result<DraughtingAnnotationOccurrenceId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_styled_item_target_ref(&self.model, &item)?;
        Ok(DraughtingAnnotationOccurrenceId(
            self.model
                .draughting_annotation_occurrence_arena
                .push(DraughtingAnnotationOccurrence { name, styles, item }),
        ))
    }

    /// `DRAUGHTING_CALLOUT` — strict AP242 constructor.
    pub fn add_draughting_callout(
        &mut self,
        name: String,
        contents: Vec<DraughtingCalloutElementRef>,
    ) -> Result<DraughtingCalloutId, AuthorError> {
        {
            let x = &contents;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "DRAUGHTING_CALLOUT",
                    attribute: "contents",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &contents {
            check_draughting_callout_element_ref(&self.model, e0)?;
        }
        Ok(DraughtingCalloutId(
            self.model
                .draughting_callout_arena
                .push(DraughtingCallout { name, contents }),
        ))
    }

    /// `DRAUGHTING_CALLOUT_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_draughting_callout_relationship(
        &mut self,
        name: String,
        description: String,
        relating_draughting_callout: DraughtingCalloutRef,
        related_draughting_callout: DraughtingCalloutRef,
    ) -> Result<DraughtingCalloutRelationshipId, AuthorError> {
        check_draughting_callout_ref(&self.model, &relating_draughting_callout)?;
        check_draughting_callout_ref(&self.model, &related_draughting_callout)?;
        Ok(DraughtingCalloutRelationshipId(
            self.model
                .draughting_callout_relationship_arena
                .push(DraughtingCalloutRelationship {
                    name,
                    description,
                    relating_draughting_callout,
                    related_draughting_callout,
                }),
        ))
    }

    /// `DRAUGHTING_MODEL` — strict AP242 constructor.
    pub fn add_draughting_model(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<DraughtingModelId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "DRAUGHTING_MODEL",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(DraughtingModelId(self.model.draughting_model_arena.push(
            DraughtingModel {
                name,
                items,
                context_of_items,
            },
        )))
    }

    /// `DRAUGHTING_MODEL_ITEM_ASSOCIATION` — strict AP242 constructor.
    pub fn add_draughting_model_item_association(
        &mut self,
        name: String,
        description: Option<String>,
        definition: DraughtingModelItemDefinitionRef,
        used_representation: AnnotationRepresentationSelectRef,
        identified_item: DraughtingModelItemAssociationSelectRef,
    ) -> Result<DraughtingModelItemAssociationId, AuthorError> {
        check_draughting_model_item_definition_ref(&self.model, &definition)?;
        check_annotation_representation_select_ref(&self.model, &used_representation)?;
        check_draughting_model_item_association_select_ref(&self.model, &identified_item)?;
        Ok(DraughtingModelItemAssociationId(
            self.model.draughting_model_item_association_arena.push(
                DraughtingModelItemAssociation {
                    name,
                    description,
                    definition,
                    used_representation,
                    identified_item,
                },
            ),
        ))
    }

    /// `DRAUGHTING_MODEL_ITEM_ASSOCIATION_WITH_PLACEHOLDER` — strict AP242 constructor.
    pub fn add_draughting_model_item_association_with_placeholder(
        &mut self,
        name: String,
        description: Option<String>,
        definition: DraughtingModelItemDefinitionRef,
        used_representation: AnnotationRepresentationSelectRef,
        identified_item: DraughtingModelItemAssociationSelectRef,
        annotation_placeholder: AnnotationPlaceholderOccurrenceRef,
    ) -> Result<DraughtingModelItemAssociationWithPlaceholderId, AuthorError> {
        check_draughting_model_item_definition_ref(&self.model, &definition)?;
        check_annotation_representation_select_ref(&self.model, &used_representation)?;
        check_draughting_model_item_association_select_ref(&self.model, &identified_item)?;
        check_annotation_placeholder_occurrence_ref(&self.model, &annotation_placeholder)?;
        Ok(DraughtingModelItemAssociationWithPlaceholderId(
            self.model
                .draughting_model_item_association_with_placeholder_arena
                .push(DraughtingModelItemAssociationWithPlaceholder {
                    name,
                    description,
                    definition,
                    used_representation,
                    identified_item,
                    annotation_placeholder,
                }),
        ))
    }

    /// `DRAUGHTING_PRE_DEFINED_COLOUR` — strict AP242 constructor.
    pub fn add_draughting_pre_defined_colour(
        &mut self,
        name: String,
    ) -> Result<DraughtingPreDefinedColourId, AuthorError> {
        Ok(DraughtingPreDefinedColourId(
            self.model
                .draughting_pre_defined_colour_arena
                .push(DraughtingPreDefinedColour { name }),
        ))
    }

    /// `DRAUGHTING_PRE_DEFINED_CURVE_FONT` — strict AP242 constructor.
    pub fn add_draughting_pre_defined_curve_font(
        &mut self,
        name: String,
    ) -> Result<DraughtingPreDefinedCurveFontId, AuthorError> {
        Ok(DraughtingPreDefinedCurveFontId(
            self.model
                .draughting_pre_defined_curve_font_arena
                .push(DraughtingPreDefinedCurveFont { name }),
        ))
    }

    /// `DRAUGHTING_PRE_DEFINED_TEXT_FONT` — strict AP242 constructor.
    pub fn add_draughting_pre_defined_text_font(
        &mut self,
        name: String,
    ) -> Result<DraughtingPreDefinedTextFontId, AuthorError> {
        Ok(DraughtingPreDefinedTextFontId(
            self.model
                .draughting_pre_defined_text_font_arena
                .push(DraughtingPreDefinedTextFont { name }),
        ))
    }

    /// `EDGE` — strict AP242 constructor.
    pub fn add_edge(
        &mut self,
        name: String,
        edge_start: Option<VertexRef>,
        edge_end: Option<VertexRef>,
    ) -> Result<EdgeId, AuthorError> {
        if let Some(x) = &edge_start {
            check_vertex_ref(&self.model, x)?;
        }
        if let Some(x) = &edge_end {
            check_vertex_ref(&self.model, x)?;
        }
        Ok(EdgeId(self.model.edge_arena.push(Edge {
            name,
            edge_start,
            edge_end,
        })))
    }

    /// `EDGE_CURVE` — strict AP242 constructor.
    pub fn add_edge_curve(
        &mut self,
        name: String,
        edge_start: VertexRef,
        edge_end: VertexRef,
        edge_geometry: CurveRef,
        same_sense: bool,
    ) -> Result<EdgeCurveId, AuthorError> {
        check_vertex_ref(&self.model, &edge_start)?;
        check_vertex_ref(&self.model, &edge_end)?;
        check_curve_ref(&self.model, &edge_geometry)?;
        Ok(EdgeCurveId(self.model.edge_curve_arena.push(EdgeCurve {
            name,
            edge_start,
            edge_end,
            edge_geometry,
            same_sense,
        })))
    }

    /// `EDGE_LOOP` — strict AP242 constructor.
    pub fn add_edge_loop(
        &mut self,
        name: String,
        edge_list: Vec<OrientedEdgeRef>,
    ) -> Result<EdgeLoopId, AuthorError> {
        {
            let x = &edge_list;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "EDGE_LOOP",
                    attribute: "edge_list",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &edge_list {
            check_oriented_edge_ref(&self.model, e0)?;
        }
        Ok(EdgeLoopId(
            self.model
                .edge_loop_arena
                .push(EdgeLoop { name, edge_list }),
        ))
    }

    /// `EFFECTIVITY` — strict AP242 constructor.
    pub fn add_effectivity(&mut self, id: String) -> Result<EffectivityId, AuthorError> {
        Ok(EffectivityId(
            self.model.effectivity_arena.push(Effectivity { id }),
        ))
    }

    /// `ELEMENTARY_SURFACE` — strict AP242 constructor.
    pub fn add_elementary_surface(
        &mut self,
        name: String,
        position: Axis2Placement3dRef,
    ) -> Result<ElementarySurfaceId, AuthorError> {
        check_axis2_placement3d_ref(&self.model, &position)?;
        Ok(ElementarySurfaceId(
            self.model
                .elementary_surface_arena
                .push(ElementarySurface { name, position }),
        ))
    }

    /// `ELLIPSE` — strict AP242 constructor.
    pub fn add_ellipse(
        &mut self,
        name: String,
        position: Axis2PlacementRef,
        semi_axis_1: f64,
        semi_axis_2: f64,
    ) -> Result<EllipseId, AuthorError> {
        check_axis2_placement_ref(&self.model, &position)?;
        Ok(EllipseId(self.model.ellipse_arena.push(Ellipse {
            name,
            position,
            semi_axis_1,
            semi_axis_2,
        })))
    }

    /// `EXPRESSION` — strict AP242 constructor.
    pub fn add_expression(&mut self) -> Result<ExpressionId, AuthorError> {
        Ok(ExpressionId(
            self.model.expression_arena.push(Expression {}),
        ))
    }

    /// `EXTERNAL_IDENTIFICATION_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_external_identification_assignment(
        &mut self,
        assigned_id: String,
        role: IdentificationRoleRef,
        source: ExternalSourceRef,
    ) -> Result<ExternalIdentificationAssignmentId, AuthorError> {
        check_identification_role_ref(&self.model, &role)?;
        check_external_source_ref(&self.model, &source)?;
        Ok(ExternalIdentificationAssignmentId(
            self.model.external_identification_assignment_arena.push(
                ExternalIdentificationAssignment {
                    assigned_id,
                    role,
                    source,
                },
            ),
        ))
    }

    /// `EXTERNAL_SOURCE` — strict AP242 constructor.
    pub fn add_external_source(
        &mut self,
        source_id: StringSelectValue,
    ) -> Result<ExternalSourceId, AuthorError> {
        Ok(ExternalSourceId(
            self.model
                .external_source_arena
                .push(ExternalSource { source_id }),
        ))
    }

    /// `EXTERNALLY_DEFINED_CHARACTER_GLYPH` — strict AP242 constructor.
    pub fn add_externally_defined_character_glyph(
        &mut self,
        item_id: StringSelectValue,
        source: ExternalSourceRef,
    ) -> Result<ExternallyDefinedCharacterGlyphId, AuthorError> {
        check_external_source_ref(&self.model, &source)?;
        Ok(ExternallyDefinedCharacterGlyphId(
            self.model
                .externally_defined_character_glyph_arena
                .push(ExternallyDefinedCharacterGlyph { item_id, source }),
        ))
    }

    /// `EXTERNALLY_DEFINED_CURVE_FONT` — strict AP242 constructor.
    pub fn add_externally_defined_curve_font(
        &mut self,
        item_id: StringSelectValue,
        source: ExternalSourceRef,
    ) -> Result<ExternallyDefinedCurveFontId, AuthorError> {
        check_external_source_ref(&self.model, &source)?;
        Ok(ExternallyDefinedCurveFontId(
            self.model
                .externally_defined_curve_font_arena
                .push(ExternallyDefinedCurveFont { item_id, source }),
        ))
    }

    /// `EXTERNALLY_DEFINED_HATCH_STYLE` — strict AP242 constructor.
    pub fn add_externally_defined_hatch_style(
        &mut self,
        item_id: StringSelectValue,
        source: ExternalSourceRef,
        name: String,
    ) -> Result<ExternallyDefinedHatchStyleId, AuthorError> {
        check_external_source_ref(&self.model, &source)?;
        Ok(ExternallyDefinedHatchStyleId(
            self.model
                .externally_defined_hatch_style_arena
                .push(ExternallyDefinedHatchStyle {
                    item_id,
                    source,
                    name,
                }),
        ))
    }

    /// `EXTERNALLY_DEFINED_ITEM` — strict AP242 constructor.
    pub fn add_externally_defined_item(
        &mut self,
        item_id: StringSelectValue,
        source: ExternalSourceRef,
    ) -> Result<ExternallyDefinedItemId, AuthorError> {
        check_external_source_ref(&self.model, &source)?;
        Ok(ExternallyDefinedItemId(
            self.model
                .externally_defined_item_arena
                .push(ExternallyDefinedItem { item_id, source }),
        ))
    }

    /// `EXTERNALLY_DEFINED_STYLE` — strict AP242 constructor.
    pub fn add_externally_defined_style(
        &mut self,
        item_id: StringSelectValue,
        source: ExternalSourceRef,
    ) -> Result<ExternallyDefinedStyleId, AuthorError> {
        check_external_source_ref(&self.model, &source)?;
        Ok(ExternallyDefinedStyleId(
            self.model
                .externally_defined_style_arena
                .push(ExternallyDefinedStyle { item_id, source }),
        ))
    }

    /// `EXTERNALLY_DEFINED_SYMBOL` — strict AP242 constructor.
    pub fn add_externally_defined_symbol(
        &mut self,
        item_id: StringSelectValue,
        source: ExternalSourceRef,
    ) -> Result<ExternallyDefinedSymbolId, AuthorError> {
        check_external_source_ref(&self.model, &source)?;
        Ok(ExternallyDefinedSymbolId(
            self.model
                .externally_defined_symbol_arena
                .push(ExternallyDefinedSymbol { item_id, source }),
        ))
    }

    /// `EXTERNALLY_DEFINED_TEXT_FONT` — strict AP242 constructor.
    pub fn add_externally_defined_text_font(
        &mut self,
        item_id: StringSelectValue,
        source: ExternalSourceRef,
    ) -> Result<ExternallyDefinedTextFontId, AuthorError> {
        check_external_source_ref(&self.model, &source)?;
        Ok(ExternallyDefinedTextFontId(
            self.model
                .externally_defined_text_font_arena
                .push(ExternallyDefinedTextFont { item_id, source }),
        ))
    }

    /// `EXTERNALLY_DEFINED_TILE` — strict AP242 constructor.
    pub fn add_externally_defined_tile(
        &mut self,
        item_id: StringSelectValue,
        source: ExternalSourceRef,
    ) -> Result<ExternallyDefinedTileId, AuthorError> {
        check_external_source_ref(&self.model, &source)?;
        Ok(ExternallyDefinedTileId(
            self.model
                .externally_defined_tile_arena
                .push(ExternallyDefinedTile { item_id, source }),
        ))
    }

    /// `EXTERNALLY_DEFINED_TILE_STYLE` — strict AP242 constructor.
    pub fn add_externally_defined_tile_style(
        &mut self,
        item_id: StringSelectValue,
        source: ExternalSourceRef,
        name: String,
    ) -> Result<ExternallyDefinedTileStyleId, AuthorError> {
        check_external_source_ref(&self.model, &source)?;
        Ok(ExternallyDefinedTileStyleId(
            self.model
                .externally_defined_tile_style_arena
                .push(ExternallyDefinedTileStyle {
                    item_id,
                    source,
                    name,
                }),
        ))
    }

    /// `FACE` — strict AP242 constructor.
    pub fn add_face(
        &mut self,
        name: String,
        bounds: Vec<FaceBoundRef>,
    ) -> Result<FaceId, AuthorError> {
        {
            let x = &bounds;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "FACE",
                    attribute: "bounds",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &bounds {
            check_face_bound_ref(&self.model, e0)?;
        }
        Ok(FaceId(self.model.face_arena.push(Face { name, bounds })))
    }

    /// `FACE_BOUND` — strict AP242 constructor.
    pub fn add_face_bound(
        &mut self,
        name: String,
        bound: LoopRef,
        orientation: bool,
    ) -> Result<FaceBoundId, AuthorError> {
        check_loop_ref(&self.model, &bound)?;
        Ok(FaceBoundId(self.model.face_bound_arena.push(FaceBound {
            name,
            bound,
            orientation,
        })))
    }

    /// `FACE_OUTER_BOUND` — strict AP242 constructor.
    pub fn add_face_outer_bound(
        &mut self,
        name: String,
        bound: LoopRef,
        orientation: bool,
    ) -> Result<FaceOuterBoundId, AuthorError> {
        check_loop_ref(&self.model, &bound)?;
        Ok(FaceOuterBoundId(self.model.face_outer_bound_arena.push(
            FaceOuterBound {
                name,
                bound,
                orientation,
            },
        )))
    }

    /// `FACE_SURFACE` — strict AP242 constructor.
    pub fn add_face_surface(
        &mut self,
        name: String,
        bounds: Vec<FaceBoundRef>,
        face_geometry: SurfaceRef,
        same_sense: bool,
    ) -> Result<FaceSurfaceId, AuthorError> {
        {
            let x = &bounds;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "FACE_SURFACE",
                    attribute: "bounds",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &bounds {
            check_face_bound_ref(&self.model, e0)?;
        }
        check_surface_ref(&self.model, &face_geometry)?;
        Ok(FaceSurfaceId(self.model.face_surface_arena.push(
            FaceSurface {
                name,
                bounds,
                face_geometry,
                same_sense,
            },
        )))
    }

    /// `FEATURE_FOR_DATUM_TARGET_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_feature_for_datum_target_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        relating_shape_aspect: ShapeAspectRef,
        related_shape_aspect: ShapeAspectRef,
    ) -> Result<FeatureForDatumTargetRelationshipId, AuthorError> {
        check_shape_aspect_ref(&self.model, &relating_shape_aspect)?;
        check_shape_aspect_ref(&self.model, &related_shape_aspect)?;
        Ok(FeatureForDatumTargetRelationshipId(
            self.model.feature_for_datum_target_relationship_arena.push(
                FeatureForDatumTargetRelationship {
                    name,
                    description,
                    relating_shape_aspect,
                    related_shape_aspect,
                },
            ),
        ))
    }

    /// `FILL_AREA_STYLE` — strict AP242 constructor.
    pub fn add_fill_area_style(
        &mut self,
        name: String,
        fill_styles: Vec<FillStyleSelectRef>,
    ) -> Result<FillAreaStyleId, AuthorError> {
        {
            let x = &fill_styles;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "FILL_AREA_STYLE",
                    attribute: "fill_styles",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &fill_styles {
            check_fill_style_select_ref(&self.model, e0)?;
        }
        Ok(FillAreaStyleId(
            self.model
                .fill_area_style_arena
                .push(FillAreaStyle { name, fill_styles }),
        ))
    }

    /// `FILL_AREA_STYLE_COLOUR` — strict AP242 constructor.
    pub fn add_fill_area_style_colour(
        &mut self,
        name: String,
        fill_colour: ColourRef,
    ) -> Result<FillAreaStyleColourId, AuthorError> {
        check_colour_ref(&self.model, &fill_colour)?;
        Ok(FillAreaStyleColourId(
            self.model
                .fill_area_style_colour_arena
                .push(FillAreaStyleColour { name, fill_colour }),
        ))
    }

    /// `FILL_AREA_STYLE_HATCHING` — strict AP242 constructor.
    pub fn add_fill_area_style_hatching(
        &mut self,
        name: String,
        hatch_line_appearance: CurveStyleRef,
        start_of_next_hatch_line: OneDirectionRepeatFactorRef,
        point_of_reference_hatch_line: CartesianPointRef,
        pattern_start: CartesianPointRef,
        hatch_line_angle: f64,
    ) -> Result<FillAreaStyleHatchingId, AuthorError> {
        check_curve_style_ref(&self.model, &hatch_line_appearance)?;
        check_one_direction_repeat_factor_ref(&self.model, &start_of_next_hatch_line)?;
        check_cartesian_point_ref(&self.model, &point_of_reference_hatch_line)?;
        check_cartesian_point_ref(&self.model, &pattern_start)?;
        Ok(FillAreaStyleHatchingId(
            self.model
                .fill_area_style_hatching_arena
                .push(FillAreaStyleHatching {
                    name,
                    hatch_line_appearance,
                    start_of_next_hatch_line,
                    point_of_reference_hatch_line,
                    pattern_start,
                    hatch_line_angle,
                }),
        ))
    }

    /// `FILL_AREA_STYLE_TILE_COLOURED_REGION` — strict AP242 constructor.
    pub fn add_fill_area_style_tile_coloured_region(
        &mut self,
        name: String,
        closed_curve: CurveOrAnnotationCurveOccurrenceRef,
        region_colour: ColourRef,
    ) -> Result<FillAreaStyleTileColouredRegionId, AuthorError> {
        check_curve_or_annotation_curve_occurrence_ref(&self.model, &closed_curve)?;
        check_colour_ref(&self.model, &region_colour)?;
        Ok(FillAreaStyleTileColouredRegionId(
            self.model.fill_area_style_tile_coloured_region_arena.push(
                FillAreaStyleTileColouredRegion {
                    name,
                    closed_curve,
                    region_colour,
                },
            ),
        ))
    }

    /// `FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE` — strict AP242 constructor.
    pub fn add_fill_area_style_tile_curve_with_style(
        &mut self,
        name: String,
        styled_curve: AnnotationCurveOccurrenceRef,
    ) -> Result<FillAreaStyleTileCurveWithStyleId, AuthorError> {
        check_annotation_curve_occurrence_ref(&self.model, &styled_curve)?;
        Ok(FillAreaStyleTileCurveWithStyleId(
            self.model
                .fill_area_style_tile_curve_with_style_arena
                .push(FillAreaStyleTileCurveWithStyle { name, styled_curve }),
        ))
    }

    /// `FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE` — strict AP242 constructor.
    pub fn add_fill_area_style_tile_symbol_with_style(
        &mut self,
        name: String,
        symbol: AnnotationSymbolOccurrenceRef,
    ) -> Result<FillAreaStyleTileSymbolWithStyleId, AuthorError> {
        check_annotation_symbol_occurrence_ref(&self.model, &symbol)?;
        Ok(FillAreaStyleTileSymbolWithStyleId(
            self.model
                .fill_area_style_tile_symbol_with_style_arena
                .push(FillAreaStyleTileSymbolWithStyle { name, symbol }),
        ))
    }

    /// `FILL_AREA_STYLE_TILES` — strict AP242 constructor.
    pub fn add_fill_area_style_tiles(
        &mut self,
        name: String,
        tiling_pattern: TwoDirectionRepeatFactorRef,
        tiles: Vec<FillAreaStyleTileShapeSelectRef>,
        tiling_scale: f64,
    ) -> Result<FillAreaStyleTilesId, AuthorError> {
        check_two_direction_repeat_factor_ref(&self.model, &tiling_pattern)?;
        {
            let x = &tiles;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "FILL_AREA_STYLE_TILES",
                    attribute: "tiles",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &tiles {
            check_fill_area_style_tile_shape_select_ref(&self.model, e0)?;
        }
        Ok(FillAreaStyleTilesId(
            self.model
                .fill_area_style_tiles_arena
                .push(FillAreaStyleTiles {
                    name,
                    tiling_pattern,
                    tiles,
                    tiling_scale,
                }),
        ))
    }

    /// `FLATNESS_TOLERANCE` — strict AP242 constructor.
    pub fn add_flatness_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
    ) -> Result<FlatnessToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        Ok(FlatnessToleranceId(
            self.model.flatness_tolerance_arena.push(FlatnessTolerance {
                name,
                description,
                magnitude,
                toleranced_shape_aspect,
            }),
        ))
    }

    /// `FOUNDED_ITEM` — strict AP242 constructor.
    pub fn add_founded_item(&mut self) -> Result<FoundedItemId, AuthorError> {
        Ok(FoundedItemId(
            self.model.founded_item_arena.push(FoundedItem {}),
        ))
    }

    /// `FUNCTIONALLY_DEFINED_TRANSFORMATION` — strict AP242 constructor.
    pub fn add_functionally_defined_transformation(
        &mut self,
        name: String,
        description: Option<String>,
    ) -> Result<FunctionallyDefinedTransformationId, AuthorError> {
        Ok(FunctionallyDefinedTransformationId(
            self.model
                .functionally_defined_transformation_arena
                .push(FunctionallyDefinedTransformation { name, description }),
        ))
    }

    /// `GENERAL_DATUM_REFERENCE` — strict AP242 constructor.
    pub fn add_general_datum_reference(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
        base: DatumOrCommonDatumRef,
        modifiers: Option<Vec<DatumReferenceModifierRef>>,
    ) -> Result<GeneralDatumReferenceId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        check_datum_or_common_datum_ref(&self.model, &base)?;
        if let Some(x) = &modifiers {
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "GENERAL_DATUM_REFERENCE",
                    attribute: "modifiers",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        if let Some(x) = &modifiers {
            for e0 in x {
                check_datum_reference_modifier_ref(&self.model, e0)?;
            }
        }
        Ok(GeneralDatumReferenceId(
            self.model
                .general_datum_reference_arena
                .push(GeneralDatumReference {
                    name,
                    description,
                    of_shape,
                    product_definitional,
                    base,
                    modifiers,
                }),
        ))
    }

    /// `GENERAL_PROPERTY` — strict AP242 constructor.
    pub fn add_general_property(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
    ) -> Result<GeneralPropertyId, AuthorError> {
        Ok(GeneralPropertyId(self.model.general_property_arena.push(
            GeneralProperty {
                id,
                name,
                description,
            },
        )))
    }

    /// `GENERAL_PROPERTY_ASSOCIATION` — strict AP242 constructor.
    pub fn add_general_property_association(
        &mut self,
        name: String,
        description: Option<String>,
        base_definition: GeneralPropertyRef,
        derived_definition: DerivedPropertySelectRef,
    ) -> Result<GeneralPropertyAssociationId, AuthorError> {
        check_general_property_ref(&self.model, &base_definition)?;
        check_derived_property_select_ref(&self.model, &derived_definition)?;
        Ok(GeneralPropertyAssociationId(
            self.model
                .general_property_association_arena
                .push(GeneralPropertyAssociation {
                    name,
                    description,
                    base_definition,
                    derived_definition,
                }),
        ))
    }

    /// `GENERIC_EXPRESSION` — strict AP242 constructor.
    pub fn add_generic_expression(&mut self) -> Result<GenericExpressionId, AuthorError> {
        Ok(GenericExpressionId(
            self.model
                .generic_expression_arena
                .push(GenericExpression {}),
        ))
    }

    /// `GENERIC_LITERAL` — strict AP242 constructor.
    pub fn add_generic_literal(&mut self) -> Result<GenericLiteralId, AuthorError> {
        Ok(GenericLiteralId(
            self.model.generic_literal_arena.push(GenericLiteral {}),
        ))
    }

    /// `GENERIC_PRODUCT_DEFINITION_REFERENCE` — strict AP242 constructor.
    pub fn add_generic_product_definition_reference(
        &mut self,
        source: ExternalSourceRef,
    ) -> Result<GenericProductDefinitionReferenceId, AuthorError> {
        check_external_source_ref(&self.model, &source)?;
        Ok(GenericProductDefinitionReferenceId(
            self.model
                .generic_product_definition_reference_arena
                .push(GenericProductDefinitionReference { source }),
        ))
    }

    /// `GEOMETRIC_CURVE_SET` — strict AP242 constructor.
    pub fn add_geometric_curve_set(
        &mut self,
        name: String,
        elements: Vec<GeometricSetSelectRef>,
    ) -> Result<GeometricCurveSetId, AuthorError> {
        {
            let x = &elements;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "GEOMETRIC_CURVE_SET",
                    attribute: "elements",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &elements {
            check_geometric_set_select_ref(&self.model, e0)?;
        }
        Ok(GeometricCurveSetId(
            self.model
                .geometric_curve_set_arena
                .push(GeometricCurveSet { name, elements }),
        ))
    }

    /// `GEOMETRIC_ITEM_SPECIFIC_USAGE` — strict AP242 constructor.
    pub fn add_geometric_item_specific_usage(
        &mut self,
        name: String,
        description: Option<String>,
        definition: GeometricItemSpecificUsageSelectRef,
        used_representation: ShapeModelRef,
        identified_item: GeometricModelItemRef,
    ) -> Result<GeometricItemSpecificUsageId, AuthorError> {
        check_geometric_item_specific_usage_select_ref(&self.model, &definition)?;
        check_shape_model_ref(&self.model, &used_representation)?;
        check_geometric_model_item_ref(&self.model, &identified_item)?;
        Ok(GeometricItemSpecificUsageId(
            self.model
                .geometric_item_specific_usage_arena
                .push(GeometricItemSpecificUsage {
                    name,
                    description,
                    definition,
                    used_representation,
                    identified_item,
                }),
        ))
    }

    /// `GEOMETRIC_REPRESENTATION_CONTEXT` — strict AP242 constructor.
    pub fn add_geometric_representation_context(
        &mut self,
        context_identifier: String,
        context_type: String,
        coordinate_space_dimension: i64,
    ) -> Result<GeometricRepresentationContextId, AuthorError> {
        Ok(GeometricRepresentationContextId(
            self.model.geometric_representation_context_arena.push(
                GeometricRepresentationContext {
                    context_identifier,
                    context_type,
                    coordinate_space_dimension,
                },
            ),
        ))
    }

    /// `GEOMETRIC_REPRESENTATION_ITEM` — strict AP242 constructor.
    pub fn add_geometric_representation_item(
        &mut self,
        name: String,
    ) -> Result<GeometricRepresentationItemId, AuthorError> {
        Ok(GeometricRepresentationItemId(
            self.model
                .geometric_representation_item_arena
                .push(GeometricRepresentationItem { name }),
        ))
    }

    /// `GEOMETRIC_SET` — strict AP242 constructor.
    pub fn add_geometric_set(
        &mut self,
        name: String,
        elements: Vec<GeometricSetSelectRef>,
    ) -> Result<GeometricSetId, AuthorError> {
        {
            let x = &elements;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "GEOMETRIC_SET",
                    attribute: "elements",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &elements {
            check_geometric_set_select_ref(&self.model, e0)?;
        }
        Ok(GeometricSetId(
            self.model
                .geometric_set_arena
                .push(GeometricSet { name, elements }),
        ))
    }

    /// `GEOMETRIC_TOLERANCE` — strict AP242 constructor.
    pub fn add_geometric_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
    ) -> Result<GeometricToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        Ok(GeometricToleranceId(
            self.model
                .geometric_tolerance_arena
                .push(GeometricTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                }),
        ))
    }

    /// `GEOMETRIC_TOLERANCE_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_geometric_tolerance_relationship(
        &mut self,
        name: String,
        description: String,
        relating_geometric_tolerance: GeometricToleranceRef,
        related_geometric_tolerance: GeometricToleranceRef,
    ) -> Result<GeometricToleranceRelationshipId, AuthorError> {
        check_geometric_tolerance_ref(&self.model, &relating_geometric_tolerance)?;
        check_geometric_tolerance_ref(&self.model, &related_geometric_tolerance)?;
        Ok(GeometricToleranceRelationshipId(
            self.model.geometric_tolerance_relationship_arena.push(
                GeometricToleranceRelationship {
                    name,
                    description,
                    relating_geometric_tolerance,
                    related_geometric_tolerance,
                },
            ),
        ))
    }

    /// `GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE` — strict AP242 constructor.
    pub fn add_geometric_tolerance_with_datum_reference(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        datum_system: Vec<DatumSystemOrReferenceRef>,
    ) -> Result<GeometricToleranceWithDatumReferenceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        {
            let x = &datum_system;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
                    attribute: "datum_system",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &datum_system {
            check_datum_system_or_reference_ref(&self.model, e0)?;
        }
        Ok(GeometricToleranceWithDatumReferenceId(
            self.model
                .geometric_tolerance_with_datum_reference_arena
                .push(GeometricToleranceWithDatumReference {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    datum_system,
                }),
        ))
    }

    /// `GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT` — strict AP242 constructor.
    pub fn add_geometric_tolerance_with_defined_area_unit(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        unit_size: LengthOrPlaneAngleMeasureWithUnitSelectRef,
        area_type: AreaUnitType,
        second_unit_size: Option<LengthOrPlaneAngleMeasureWithUnitSelectRef>,
    ) -> Result<GeometricToleranceWithDefinedAreaUnitId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        check_length_or_plane_angle_measure_with_unit_select_ref(&self.model, &unit_size)?;
        if let Some(x) = &second_unit_size {
            check_length_or_plane_angle_measure_with_unit_select_ref(&self.model, x)?;
        }
        Ok(GeometricToleranceWithDefinedAreaUnitId(
            self.model
                .geometric_tolerance_with_defined_area_unit_arena
                .push(GeometricToleranceWithDefinedAreaUnit {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    unit_size,
                    area_type,
                    second_unit_size,
                }),
        ))
    }

    /// `GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT` — strict AP242 constructor.
    pub fn add_geometric_tolerance_with_defined_unit(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        unit_size: LengthOrPlaneAngleMeasureWithUnitSelectRef,
    ) -> Result<GeometricToleranceWithDefinedUnitId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        check_length_or_plane_angle_measure_with_unit_select_ref(&self.model, &unit_size)?;
        Ok(GeometricToleranceWithDefinedUnitId(
            self.model.geometric_tolerance_with_defined_unit_arena.push(
                GeometricToleranceWithDefinedUnit {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    unit_size,
                },
            ),
        ))
    }

    /// `GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE` — strict AP242 constructor.
    pub fn add_geometric_tolerance_with_maximum_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        modifiers: Vec<GeometricToleranceModifier>,
        maximum_upper_tolerance: LengthMeasureWithUnitRef,
    ) -> Result<GeometricToleranceWithMaximumToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        {
            let x = &modifiers;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE",
                    attribute: "modifiers",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        check_length_measure_with_unit_ref(&self.model, &maximum_upper_tolerance)?;
        Ok(GeometricToleranceWithMaximumToleranceId(
            self.model
                .geometric_tolerance_with_maximum_tolerance_arena
                .push(GeometricToleranceWithMaximumTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    modifiers,
                    maximum_upper_tolerance,
                }),
        ))
    }

    /// `GEOMETRIC_TOLERANCE_WITH_MODIFIERS` — strict AP242 constructor.
    pub fn add_geometric_tolerance_with_modifiers(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        modifiers: Vec<GeometricToleranceModifier>,
    ) -> Result<GeometricToleranceWithModifiersId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        {
            let x = &modifiers;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
                    attribute: "modifiers",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        Ok(GeometricToleranceWithModifiersId(
            self.model.geometric_tolerance_with_modifiers_arena.push(
                GeometricToleranceWithModifiers {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    modifiers,
                },
            ),
        ))
    }

    /// `GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION` — strict AP242 constructor.
    pub fn add_geometrically_bounded_surface_shape_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<GeometricallyBoundedSurfaceShapeRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(GeometricallyBoundedSurfaceShapeRepresentationId(
            self.model
                .geometrically_bounded_surface_shape_representation_arena
                .push(GeometricallyBoundedSurfaceShapeRepresentation {
                    name,
                    items,
                    context_of_items,
                }),
        ))
    }

    /// `GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION` — strict AP242 constructor.
    pub fn add_geometrically_bounded_wireframe_shape_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<GeometricallyBoundedWireframeShapeRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(GeometricallyBoundedWireframeShapeRepresentationId(
            self.model
                .geometrically_bounded_wireframe_shape_representation_arena
                .push(GeometricallyBoundedWireframeShapeRepresentation {
                    name,
                    items,
                    context_of_items,
                }),
        ))
    }

    /// `GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT` — strict AP242 constructor.
    pub fn add_global_uncertainty_assigned_context(
        &mut self,
        context_identifier: String,
        context_type: String,
        uncertainty: Vec<UncertaintyMeasureWithUnitRef>,
    ) -> Result<GlobalUncertaintyAssignedContextId, AuthorError> {
        {
            let x = &uncertainty;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT",
                    attribute: "uncertainty",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &uncertainty {
            check_uncertainty_measure_with_unit_ref(&self.model, e0)?;
        }
        Ok(GlobalUncertaintyAssignedContextId(
            self.model.global_uncertainty_assigned_context_arena.push(
                GlobalUncertaintyAssignedContext {
                    context_identifier,
                    context_type,
                    uncertainty,
                },
            ),
        ))
    }

    /// `GLOBAL_UNIT_ASSIGNED_CONTEXT` — strict AP242 constructor.
    pub fn add_global_unit_assigned_context(
        &mut self,
        context_identifier: String,
        context_type: String,
        units: Vec<UnitRef>,
    ) -> Result<GlobalUnitAssignedContextId, AuthorError> {
        {
            let x = &units;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "GLOBAL_UNIT_ASSIGNED_CONTEXT",
                    attribute: "units",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &units {
            check_unit_ref(&self.model, e0)?;
        }
        Ok(GlobalUnitAssignedContextId(
            self.model
                .global_unit_assigned_context_arena
                .push(GlobalUnitAssignedContext {
                    context_identifier,
                    context_type,
                    units,
                }),
        ))
    }

    /// `GROUP` — strict AP242 constructor.
    pub fn add_group(
        &mut self,
        name: String,
        description: Option<String>,
    ) -> Result<GroupId, AuthorError> {
        Ok(GroupId(
            self.model.group_arena.push(Group { name, description }),
        ))
    }

    /// `GROUP_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_group_assignment(
        &mut self,
        assigned_group: GroupRef,
    ) -> Result<GroupAssignmentId, AuthorError> {
        check_group_ref(&self.model, &assigned_group)?;
        Ok(GroupAssignmentId(
            self.model
                .group_assignment_arena
                .push(GroupAssignment { assigned_group }),
        ))
    }

    /// `HYPERBOLA` — strict AP242 constructor.
    pub fn add_hyperbola(
        &mut self,
        name: String,
        position: Axis2PlacementRef,
        semi_axis: f64,
        semi_imag_axis: f64,
    ) -> Result<HyperbolaId, AuthorError> {
        check_axis2_placement_ref(&self.model, &position)?;
        Ok(HyperbolaId(self.model.hyperbola_arena.push(Hyperbola {
            name,
            position,
            semi_axis,
            semi_imag_axis,
        })))
    }

    /// `ID_ATTRIBUTE` — strict AP242 constructor.
    pub fn add_id_attribute(
        &mut self,
        attribute_value: String,
        identified_item: IdAttributeSelectRef,
    ) -> Result<IdAttributeId, AuthorError> {
        check_id_attribute_select_ref(&self.model, &identified_item)?;
        Ok(IdAttributeId(self.model.id_attribute_arena.push(
            IdAttribute {
                attribute_value,
                identified_item,
            },
        )))
    }

    /// `IDENTIFICATION_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_identification_assignment(
        &mut self,
        assigned_id: String,
        role: IdentificationRoleRef,
    ) -> Result<IdentificationAssignmentId, AuthorError> {
        check_identification_role_ref(&self.model, &role)?;
        Ok(IdentificationAssignmentId(
            self.model
                .identification_assignment_arena
                .push(IdentificationAssignment { assigned_id, role }),
        ))
    }

    /// `IDENTIFICATION_ROLE` — strict AP242 constructor.
    pub fn add_identification_role(
        &mut self,
        name: String,
        description: Option<String>,
    ) -> Result<IdentificationRoleId, AuthorError> {
        Ok(IdentificationRoleId(
            self.model
                .identification_role_arena
                .push(IdentificationRole { name, description }),
        ))
    }

    /// `INT_LITERAL` — strict AP242 constructor.
    pub fn add_int_literal(&mut self, the_value: i64) -> Result<IntLiteralId, AuthorError> {
        Ok(IntLiteralId(
            self.model.int_literal_arena.push(IntLiteral { the_value }),
        ))
    }

    /// `INTEGER_REPRESENTATION_ITEM` — strict AP242 constructor.
    pub fn add_integer_representation_item(
        &mut self,
        name: String,
        the_value: i64,
    ) -> Result<IntegerRepresentationItemId, AuthorError> {
        Ok(IntegerRepresentationItemId(
            self.model
                .integer_representation_item_arena
                .push(IntegerRepresentationItem { name, the_value }),
        ))
    }

    /// `INTERSECTION_CURVE` — strict AP242 constructor.
    pub fn add_intersection_curve(
        &mut self,
        name: String,
        curve_3d: CurveRef,
        associated_geometry: Vec<PcurveOrSurfaceRef>,
        master_representation: PreferredSurfaceCurveRepresentation,
    ) -> Result<IntersectionCurveId, AuthorError> {
        check_curve_ref(&self.model, &curve_3d)?;
        {
            let x = &associated_geometry;
            if x.len() < 1 || x.len() > 2 {
                return Err(AuthorError::Cardinality {
                    entity: "INTERSECTION_CURVE",
                    attribute: "associated_geometry",
                    got: x.len(),
                    min: 1,
                    max: Some(2),
                });
            }
        }
        for e0 in &associated_geometry {
            check_pcurve_or_surface_ref(&self.model, e0)?;
        }
        Ok(IntersectionCurveId(
            self.model.intersection_curve_arena.push(IntersectionCurve {
                name,
                curve_3d,
                associated_geometry,
                master_representation,
            }),
        ))
    }

    /// `INVISIBILITY` — strict AP242 constructor.
    pub fn add_invisibility(
        &mut self,
        invisible_items: Vec<InvisibleItemRef>,
    ) -> Result<InvisibilityId, AuthorError> {
        {
            let x = &invisible_items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "INVISIBILITY",
                    attribute: "invisible_items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &invisible_items {
            check_invisible_item_ref(&self.model, e0)?;
        }
        Ok(InvisibilityId(
            self.model
                .invisibility_arena
                .push(Invisibility { invisible_items }),
        ))
    }

    /// `ITEM_DEFINED_TRANSFORMATION` — strict AP242 constructor.
    pub fn add_item_defined_transformation(
        &mut self,
        name: String,
        description: Option<String>,
        transform_item_1: RepresentationItemRef,
        transform_item_2: RepresentationItemRef,
    ) -> Result<ItemDefinedTransformationId, AuthorError> {
        check_representation_item_ref(&self.model, &transform_item_1)?;
        check_representation_item_ref(&self.model, &transform_item_2)?;
        Ok(ItemDefinedTransformationId(
            self.model
                .item_defined_transformation_arena
                .push(ItemDefinedTransformation {
                    name,
                    description,
                    transform_item_1,
                    transform_item_2,
                }),
        ))
    }

    /// `ITEM_IDENTIFIED_REPRESENTATION_USAGE` — strict AP242 constructor.
    pub fn add_item_identified_representation_usage(
        &mut self,
        name: String,
        description: Option<String>,
        definition: ItemIdentifiedRepresentationUsageDefinitionRef,
        used_representation: RepresentationRef,
        identified_item: ItemIdentifiedRepresentationUsageSelectRef,
    ) -> Result<ItemIdentifiedRepresentationUsageId, AuthorError> {
        check_item_identified_representation_usage_definition_ref(&self.model, &definition)?;
        check_representation_ref(&self.model, &used_representation)?;
        check_item_identified_representation_usage_select_ref(&self.model, &identified_item)?;
        Ok(ItemIdentifiedRepresentationUsageId(
            self.model.item_identified_representation_usage_arena.push(
                ItemIdentifiedRepresentationUsage {
                    name,
                    description,
                    definition,
                    used_representation,
                    identified_item,
                },
            ),
        ))
    }

    /// `LEADER_CURVE` — strict AP242 constructor.
    pub fn add_leader_curve(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: CurveOrCurveSetRef,
    ) -> Result<LeaderCurveId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_curve_or_curve_set_ref(&self.model, &item)?;
        Ok(LeaderCurveId(
            self.model
                .leader_curve_arena
                .push(LeaderCurve { name, styles, item }),
        ))
    }

    /// `LEADER_DIRECTED_CALLOUT` — strict AP242 constructor.
    pub fn add_leader_directed_callout(
        &mut self,
        name: String,
        contents: Vec<DraughtingCalloutElementRef>,
    ) -> Result<LeaderDirectedCalloutId, AuthorError> {
        {
            let x = &contents;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "LEADER_DIRECTED_CALLOUT",
                    attribute: "contents",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &contents {
            check_draughting_callout_element_ref(&self.model, e0)?;
        }
        Ok(LeaderDirectedCalloutId(
            self.model
                .leader_directed_callout_arena
                .push(LeaderDirectedCallout { name, contents }),
        ))
    }

    /// `LEADER_TERMINATOR` — strict AP242 constructor.
    pub fn add_leader_terminator(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: AnnotationSymbolOccurrenceItemRef,
        annotated_curve: AnnotationCurveOccurrenceRef,
    ) -> Result<LeaderTerminatorId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_annotation_symbol_occurrence_item_ref(&self.model, &item)?;
        check_annotation_curve_occurrence_ref(&self.model, &annotated_curve)?;
        Ok(LeaderTerminatorId(self.model.leader_terminator_arena.push(
            LeaderTerminator {
                name,
                styles,
                item,
                annotated_curve,
            },
        )))
    }

    /// `LENGTH_MEASURE_WITH_UNIT` — strict AP242 constructor.
    pub fn add_length_measure_with_unit(
        &mut self,
        value_component: MeasureValue,
        unit_component: UnitRef,
    ) -> Result<LengthMeasureWithUnitId, AuthorError> {
        check_unit_ref(&self.model, &unit_component)?;
        Ok(LengthMeasureWithUnitId(
            self.model
                .length_measure_with_unit_arena
                .push(LengthMeasureWithUnit {
                    value_component,
                    unit_component,
                }),
        ))
    }

    /// `LENGTH_UNIT` — strict AP242 constructor.
    pub fn add_length_unit(
        &mut self,
        dimensions: DimensionalExponentsRef,
    ) -> Result<LengthUnitId, AuthorError> {
        check_dimensional_exponents_ref(&self.model, &dimensions)?;
        Ok(LengthUnitId(
            self.model.length_unit_arena.push(LengthUnit { dimensions }),
        ))
    }

    /// `LIMITS_AND_FITS` — strict AP242 constructor.
    pub fn add_limits_and_fits(
        &mut self,
        form_variance: String,
        zone_variance: String,
        grade: String,
        source: String,
    ) -> Result<LimitsAndFitsId, AuthorError> {
        Ok(LimitsAndFitsId(self.model.limits_and_fits_arena.push(
            LimitsAndFits {
                form_variance,
                zone_variance,
                grade,
                source,
            },
        )))
    }

    /// `LINE` — strict AP242 constructor.
    pub fn add_line(
        &mut self,
        name: String,
        pnt: CartesianPointRef,
        dir: VectorRef,
    ) -> Result<LineId, AuthorError> {
        check_cartesian_point_ref(&self.model, &pnt)?;
        check_vector_ref(&self.model, &dir)?;
        Ok(LineId(self.model.line_arena.push(Line { name, pnt, dir })))
    }

    /// `LINE_PROFILE_TOLERANCE` — strict AP242 constructor.
    pub fn add_line_profile_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
    ) -> Result<LineProfileToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        Ok(LineProfileToleranceId(
            self.model
                .line_profile_tolerance_arena
                .push(LineProfileTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                }),
        ))
    }

    /// `LITERAL_NUMBER` — strict AP242 constructor.
    pub fn add_literal_number(&mut self, the_value: f64) -> Result<LiteralNumberId, AuthorError> {
        Ok(LiteralNumberId(
            self.model
                .literal_number_arena
                .push(LiteralNumber { the_value }),
        ))
    }

    /// `LOCAL_TIME` — strict AP242 constructor.
    pub fn add_local_time(
        &mut self,
        hour_component: i64,
        minute_component: Option<i64>,
        second_component: Option<f64>,
        zone: CoordinatedUniversalTimeOffsetRef,
    ) -> Result<LocalTimeId, AuthorError> {
        check_coordinated_universal_time_offset_ref(&self.model, &zone)?;
        Ok(LocalTimeId(self.model.local_time_arena.push(LocalTime {
            hour_component,
            minute_component,
            second_component,
            zone,
        })))
    }

    /// `LOOP` — strict AP242 constructor.
    pub fn add_loop(&mut self, name: String) -> Result<LoopId, AuthorError> {
        Ok(LoopId(self.model.loop_arena.push(Loop { name })))
    }

    /// `MAKE_FROM_USAGE_OPTION` — strict AP242 constructor.
    pub fn add_make_from_usage_option(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
        relating_product_definition: ProductDefinitionOrReferenceRef,
        related_product_definition: ProductDefinitionOrReferenceRef,
        ranking: i64,
        ranking_rationale: String,
        quantity: MeasureWithUnitRef,
    ) -> Result<MakeFromUsageOptionId, AuthorError> {
        check_product_definition_or_reference_ref(&self.model, &relating_product_definition)?;
        check_product_definition_or_reference_ref(&self.model, &related_product_definition)?;
        check_measure_with_unit_ref(&self.model, &quantity)?;
        Ok(MakeFromUsageOptionId(
            self.model
                .make_from_usage_option_arena
                .push(MakeFromUsageOption {
                    id,
                    name,
                    description,
                    relating_product_definition,
                    related_product_definition,
                    ranking,
                    ranking_rationale,
                    quantity,
                }),
        ))
    }

    /// `MANIFOLD_SOLID_BREP` — strict AP242 constructor.
    pub fn add_manifold_solid_brep(
        &mut self,
        name: String,
        outer: ClosedShellRef,
    ) -> Result<ManifoldSolidBrepId, AuthorError> {
        check_closed_shell_ref(&self.model, &outer)?;
        Ok(ManifoldSolidBrepId(
            self.model
                .manifold_solid_brep_arena
                .push(ManifoldSolidBrep { name, outer }),
        ))
    }

    /// `MANIFOLD_SURFACE_SHAPE_REPRESENTATION` — strict AP242 constructor.
    pub fn add_manifold_surface_shape_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<ManifoldSurfaceShapeRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(ManifoldSurfaceShapeRepresentationId(
            self.model.manifold_surface_shape_representation_arena.push(
                ManifoldSurfaceShapeRepresentation {
                    name,
                    items,
                    context_of_items,
                },
            ),
        ))
    }

    /// `MAPPED_ITEM` — strict AP242 constructor.
    pub fn add_mapped_item(
        &mut self,
        name: String,
        mapping_source: RepresentationMapRef,
        mapping_target: RepresentationItemRef,
    ) -> Result<MappedItemId, AuthorError> {
        check_representation_map_ref(&self.model, &mapping_source)?;
        check_representation_item_ref(&self.model, &mapping_target)?;
        Ok(MappedItemId(self.model.mapped_item_arena.push(
            MappedItem {
                name,
                mapping_source,
                mapping_target,
            },
        )))
    }

    /// `MASS_MEASURE_WITH_UNIT` — strict AP242 constructor.
    pub fn add_mass_measure_with_unit(
        &mut self,
        value_component: MeasureValue,
        unit_component: UnitRef,
    ) -> Result<MassMeasureWithUnitId, AuthorError> {
        check_unit_ref(&self.model, &unit_component)?;
        Ok(MassMeasureWithUnitId(
            self.model
                .mass_measure_with_unit_arena
                .push(MassMeasureWithUnit {
                    value_component,
                    unit_component,
                }),
        ))
    }

    /// `MASS_UNIT` — strict AP242 constructor.
    pub fn add_mass_unit(
        &mut self,
        dimensions: DimensionalExponentsRef,
    ) -> Result<MassUnitId, AuthorError> {
        check_dimensional_exponents_ref(&self.model, &dimensions)?;
        Ok(MassUnitId(
            self.model.mass_unit_arena.push(MassUnit { dimensions }),
        ))
    }

    /// `MEASURE_QUALIFICATION` — strict AP242 constructor.
    pub fn add_measure_qualification(
        &mut self,
        name: String,
        description: String,
        qualified_measure: MeasureWithUnitRef,
        qualifiers: Vec<ValueQualifierRef>,
    ) -> Result<MeasureQualificationId, AuthorError> {
        check_measure_with_unit_ref(&self.model, &qualified_measure)?;
        {
            let x = &qualifiers;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "MEASURE_QUALIFICATION",
                    attribute: "qualifiers",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &qualifiers {
            check_value_qualifier_ref(&self.model, e0)?;
        }
        Ok(MeasureQualificationId(
            self.model
                .measure_qualification_arena
                .push(MeasureQualification {
                    name,
                    description,
                    qualified_measure,
                    qualifiers,
                }),
        ))
    }

    /// `MEASURE_REPRESENTATION_ITEM` — strict AP242 constructor.
    pub fn add_measure_representation_item(
        &mut self,
        name: String,
        value_component: MeasureValue,
        unit_component: UnitRef,
    ) -> Result<MeasureRepresentationItemId, AuthorError> {
        check_unit_ref(&self.model, &unit_component)?;
        Ok(MeasureRepresentationItemId(
            self.model
                .measure_representation_item_arena
                .push(MeasureRepresentationItem {
                    name,
                    value_component,
                    unit_component,
                }),
        ))
    }

    /// `MEASURE_WITH_UNIT` — strict AP242 constructor.
    pub fn add_measure_with_unit(
        &mut self,
        value_component: MeasureValue,
        unit_component: UnitRef,
    ) -> Result<MeasureWithUnitId, AuthorError> {
        check_unit_ref(&self.model, &unit_component)?;
        Ok(MeasureWithUnitId(self.model.measure_with_unit_arena.push(
            MeasureWithUnit {
                value_component,
                unit_component,
            },
        )))
    }

    /// `MECHANICAL_CONTEXT` — strict AP242 constructor.
    pub fn add_mechanical_context(
        &mut self,
        name: String,
        frame_of_reference: ApplicationContextRef,
        discipline_type: String,
    ) -> Result<MechanicalContextId, AuthorError> {
        check_application_context_ref(&self.model, &frame_of_reference)?;
        Ok(MechanicalContextId(
            self.model.mechanical_context_arena.push(MechanicalContext {
                name,
                frame_of_reference,
                discipline_type,
            }),
        ))
    }

    /// `MECHANICAL_DESIGN_AND_DRAUGHTING_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_mechanical_design_and_draughting_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        rep_1: MechanicalDesignAndDraughtingRelationshipSelectRef,
        rep_2: MechanicalDesignAndDraughtingRelationshipSelectRef,
    ) -> Result<MechanicalDesignAndDraughtingRelationshipId, AuthorError> {
        check_mechanical_design_and_draughting_relationship_select_ref(&self.model, &rep_1)?;
        check_mechanical_design_and_draughting_relationship_select_ref(&self.model, &rep_2)?;
        Ok(MechanicalDesignAndDraughtingRelationshipId(
            self.model
                .mechanical_design_and_draughting_relationship_arena
                .push(MechanicalDesignAndDraughtingRelationship {
                    name,
                    description,
                    rep_1,
                    rep_2,
                }),
        ))
    }

    /// `MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION` — strict AP242 constructor.
    pub fn add_mechanical_design_geometric_presentation_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<MechanicalDesignGeometricPresentationRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(MechanicalDesignGeometricPresentationRepresentationId(
            self.model
                .mechanical_design_geometric_presentation_representation_arena
                .push(MechanicalDesignGeometricPresentationRepresentation {
                    name,
                    items,
                    context_of_items,
                }),
        ))
    }

    /// `MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING` — strict AP242 constructor.
    pub fn add_mechanical_design_presentation_representation_with_draughting(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<MechanicalDesignPresentationRepresentationWithDraughtingId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(MechanicalDesignPresentationRepresentationWithDraughtingId(
            self.model
                .mechanical_design_presentation_representation_with_draughting_arena
                .push(MechanicalDesignPresentationRepresentationWithDraughting {
                    name,
                    items,
                    context_of_items,
                }),
        ))
    }

    /// `MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION` — strict AP242 constructor.
    pub fn add_mechanical_design_shaded_presentation_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<MechanicalDesignShadedPresentationRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(MechanicalDesignShadedPresentationRepresentationId(
            self.model
                .mechanical_design_shaded_presentation_representation_arena
                .push(MechanicalDesignShadedPresentationRepresentation {
                    name,
                    items,
                    context_of_items,
                }),
        ))
    }

    /// `MODEL_GEOMETRIC_VIEW` — strict AP242 constructor.
    pub fn add_model_geometric_view(
        &mut self,
        name: String,
        description: Option<String>,
        item: RepresentationItemRef,
        rep: RepresentationRef,
    ) -> Result<ModelGeometricViewId, AuthorError> {
        check_representation_item_ref(&self.model, &item)?;
        check_representation_ref(&self.model, &rep)?;
        Ok(ModelGeometricViewId(
            self.model
                .model_geometric_view_arena
                .push(ModelGeometricView {
                    name,
                    description,
                    item,
                    rep,
                }),
        ))
    }

    /// `MODIFIED_GEOMETRIC_TOLERANCE` — strict AP242 constructor.
    pub fn add_modified_geometric_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        modifier: LimitCondition,
    ) -> Result<ModifiedGeometricToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        Ok(ModifiedGeometricToleranceId(
            self.model
                .modified_geometric_tolerance_arena
                .push(ModifiedGeometricTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    modifier,
                }),
        ))
    }

    /// `NAME_ATTRIBUTE` — strict AP242 constructor.
    pub fn add_name_attribute(
        &mut self,
        attribute_value: String,
        named_item: NameAttributeSelectRef,
    ) -> Result<NameAttributeId, AuthorError> {
        check_name_attribute_select_ref(&self.model, &named_item)?;
        Ok(NameAttributeId(self.model.name_attribute_arena.push(
            NameAttribute {
                attribute_value,
                named_item,
            },
        )))
    }

    /// `NAMED_UNIT` — strict AP242 constructor.
    pub fn add_named_unit(
        &mut self,
        dimensions: Option<DimensionalExponentsRef>,
    ) -> Result<NamedUnitId, AuthorError> {
        if let Some(x) = &dimensions {
            check_dimensional_exponents_ref(&self.model, x)?;
        }
        Ok(NamedUnitId(
            self.model.named_unit_arena.push(NamedUnit { dimensions }),
        ))
    }

    /// `NEXT_ASSEMBLY_USAGE_OCCURRENCE` — strict AP242 constructor.
    pub fn add_next_assembly_usage_occurrence(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
        relating_product_definition: ProductDefinitionOrReferenceRef,
        related_product_definition: ProductDefinitionOrReferenceRef,
        reference_designator: Option<String>,
    ) -> Result<NextAssemblyUsageOccurrenceId, AuthorError> {
        check_product_definition_or_reference_ref(&self.model, &relating_product_definition)?;
        check_product_definition_or_reference_ref(&self.model, &related_product_definition)?;
        Ok(NextAssemblyUsageOccurrenceId(
            self.model
                .next_assembly_usage_occurrence_arena
                .push(NextAssemblyUsageOccurrence {
                    id,
                    name,
                    description,
                    relating_product_definition,
                    related_product_definition,
                    reference_designator,
                }),
        ))
    }

    /// `NUMERIC_EXPRESSION` — strict AP242 constructor.
    pub fn add_numeric_expression(&mut self) -> Result<NumericExpressionId, AuthorError> {
        Ok(NumericExpressionId(
            self.model
                .numeric_expression_arena
                .push(NumericExpression {}),
        ))
    }

    /// `OBJECT_ROLE` — strict AP242 constructor.
    pub fn add_object_role(
        &mut self,
        name: String,
        description: Option<String>,
    ) -> Result<ObjectRoleId, AuthorError> {
        Ok(ObjectRoleId(
            self.model
                .object_role_arena
                .push(ObjectRole { name, description }),
        ))
    }

    /// `OFFSET_SURFACE` — strict AP242 constructor.
    pub fn add_offset_surface(
        &mut self,
        name: String,
        basis_surface: SurfaceRef,
        distance: f64,
        self_intersect: Logical,
    ) -> Result<OffsetSurfaceId, AuthorError> {
        check_surface_ref(&self.model, &basis_surface)?;
        Ok(OffsetSurfaceId(self.model.offset_surface_arena.push(
            OffsetSurface {
                name,
                basis_surface,
                distance,
                self_intersect,
            },
        )))
    }

    /// `ONE_DIRECTION_REPEAT_FACTOR` — strict AP242 constructor.
    pub fn add_one_direction_repeat_factor(
        &mut self,
        name: String,
        repeat_factor: VectorRef,
    ) -> Result<OneDirectionRepeatFactorId, AuthorError> {
        check_vector_ref(&self.model, &repeat_factor)?;
        Ok(OneDirectionRepeatFactorId(
            self.model
                .one_direction_repeat_factor_arena
                .push(OneDirectionRepeatFactor {
                    name,
                    repeat_factor,
                }),
        ))
    }

    /// `OPEN_SHELL` — strict AP242 constructor.
    pub fn add_open_shell(
        &mut self,
        name: String,
        cfs_faces: Vec<FaceRef>,
    ) -> Result<OpenShellId, AuthorError> {
        {
            let x = &cfs_faces;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "OPEN_SHELL",
                    attribute: "cfs_faces",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &cfs_faces {
            check_face_ref(&self.model, e0)?;
        }
        Ok(OpenShellId(
            self.model
                .open_shell_arena
                .push(OpenShell { name, cfs_faces }),
        ))
    }

    /// `ORGANIZATION` — strict AP242 constructor.
    pub fn add_organization(
        &mut self,
        id: Option<String>,
        name: String,
        description: Option<String>,
    ) -> Result<OrganizationId, AuthorError> {
        Ok(OrganizationId(self.model.organization_arena.push(
            Organization {
                id,
                name,
                description,
            },
        )))
    }

    /// `ORGANIZATION_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_organization_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        relating_organization: OrganizationRef,
        related_organization: OrganizationRef,
    ) -> Result<OrganizationRelationshipId, AuthorError> {
        check_organization_ref(&self.model, &relating_organization)?;
        check_organization_ref(&self.model, &related_organization)?;
        Ok(OrganizationRelationshipId(
            self.model
                .organization_relationship_arena
                .push(OrganizationRelationship {
                    name,
                    description,
                    relating_organization,
                    related_organization,
                }),
        ))
    }

    /// `ORGANIZATION_ROLE` — strict AP242 constructor.
    pub fn add_organization_role(
        &mut self,
        name: String,
    ) -> Result<OrganizationRoleId, AuthorError> {
        Ok(OrganizationRoleId(
            self.model
                .organization_role_arena
                .push(OrganizationRole { name }),
        ))
    }

    /// `ORGANIZATION_TYPE` — strict AP242 constructor.
    pub fn add_organization_type(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
    ) -> Result<OrganizationTypeId, AuthorError> {
        Ok(OrganizationTypeId(self.model.organization_type_arena.push(
            OrganizationType {
                id,
                name,
                description,
            },
        )))
    }

    /// `ORGANIZATION_TYPE_ROLE` — strict AP242 constructor.
    pub fn add_organization_type_role(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
    ) -> Result<OrganizationTypeRoleId, AuthorError> {
        Ok(OrganizationTypeRoleId(
            self.model
                .organization_type_role_arena
                .push(OrganizationTypeRole {
                    id,
                    name,
                    description,
                }),
        ))
    }

    /// `ORGANIZATIONAL_ADDRESS` — strict AP242 constructor.
    pub fn add_organizational_address(
        &mut self,
        internal_location: Option<String>,
        street_number: Option<String>,
        street: Option<String>,
        postal_box: Option<String>,
        town: Option<String>,
        region: Option<String>,
        postal_code: Option<String>,
        country: Option<String>,
        facsimile_number: Option<String>,
        telephone_number: Option<String>,
        electronic_mail_address: Option<String>,
        telex_number: Option<String>,
        organizations: Vec<OrganizationRef>,
        description: Option<String>,
    ) -> Result<OrganizationalAddressId, AuthorError> {
        {
            let x = &organizations;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "ORGANIZATIONAL_ADDRESS",
                    attribute: "organizations",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &organizations {
            check_organization_ref(&self.model, e0)?;
        }
        Ok(OrganizationalAddressId(
            self.model
                .organizational_address_arena
                .push(OrganizationalAddress {
                    internal_location,
                    street_number,
                    street,
                    postal_box,
                    town,
                    region,
                    postal_code,
                    country,
                    facsimile_number,
                    telephone_number,
                    electronic_mail_address,
                    telex_number,
                    organizations,
                    description,
                }),
        ))
    }

    /// `ORGANIZATIONAL_PROJECT` — strict AP242 constructor.
    pub fn add_organizational_project(
        &mut self,
        name: String,
        description: Option<String>,
        responsible_organizations: Vec<OrganizationRef>,
    ) -> Result<OrganizationalProjectId, AuthorError> {
        {
            let x = &responsible_organizations;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "ORGANIZATIONAL_PROJECT",
                    attribute: "responsible_organizations",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &responsible_organizations {
            check_organization_ref(&self.model, e0)?;
        }
        Ok(OrganizationalProjectId(
            self.model
                .organizational_project_arena
                .push(OrganizationalProject {
                    name,
                    description,
                    responsible_organizations,
                }),
        ))
    }

    /// `ORGANIZATIONAL_PROJECT_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_organizational_project_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        relating_organizational_project: OrganizationalProjectRef,
        related_organizational_project: OrganizationalProjectRef,
    ) -> Result<OrganizationalProjectRelationshipId, AuthorError> {
        check_organizational_project_ref(&self.model, &relating_organizational_project)?;
        check_organizational_project_ref(&self.model, &related_organizational_project)?;
        Ok(OrganizationalProjectRelationshipId(
            self.model.organizational_project_relationship_arena.push(
                OrganizationalProjectRelationship {
                    name,
                    description,
                    relating_organizational_project,
                    related_organizational_project,
                },
            ),
        ))
    }

    /// `ORGANIZATIONAL_PROJECT_ROLE` — strict AP242 constructor.
    pub fn add_organizational_project_role(
        &mut self,
        name: String,
        description: Option<String>,
    ) -> Result<OrganizationalProjectRoleId, AuthorError> {
        Ok(OrganizationalProjectRoleId(
            self.model
                .organizational_project_role_arena
                .push(OrganizationalProjectRole { name, description }),
        ))
    }

    /// `ORIENTED_CLOSED_SHELL` — strict AP242 constructor.
    pub fn add_oriented_closed_shell(
        &mut self,
        name: String,
        closed_shell_element: ClosedShellRef,
        orientation: bool,
    ) -> Result<OrientedClosedShellId, AuthorError> {
        check_closed_shell_ref(&self.model, &closed_shell_element)?;
        Ok(OrientedClosedShellId(
            self.model
                .oriented_closed_shell_arena
                .push(OrientedClosedShell {
                    name,
                    closed_shell_element,
                    orientation,
                }),
        ))
    }

    /// `ORIENTED_EDGE` — strict AP242 constructor.
    pub fn add_oriented_edge(
        &mut self,
        name: String,
        edge_element: EdgeRef,
        orientation: bool,
    ) -> Result<OrientedEdgeId, AuthorError> {
        check_edge_ref(&self.model, &edge_element)?;
        Ok(OrientedEdgeId(self.model.oriented_edge_arena.push(
            OrientedEdge {
                name,
                edge_element,
                orientation,
            },
        )))
    }

    /// `OVER_RIDING_STYLED_ITEM` — strict AP242 constructor.
    pub fn add_over_riding_styled_item(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: StyledItemTargetRef,
        over_ridden_style: StyledItemRef,
    ) -> Result<OverRidingStyledItemId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_styled_item_target_ref(&self.model, &item)?;
        check_styled_item_ref(&self.model, &over_ridden_style)?;
        Ok(OverRidingStyledItemId(
            self.model
                .over_riding_styled_item_arena
                .push(OverRidingStyledItem {
                    name,
                    styles,
                    item,
                    over_ridden_style,
                }),
        ))
    }

    /// `PARALLELISM_TOLERANCE` — strict AP242 constructor.
    pub fn add_parallelism_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        datum_system: Vec<DatumSystemOrReferenceRef>,
    ) -> Result<ParallelismToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        {
            let x = &datum_system;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PARALLELISM_TOLERANCE",
                    attribute: "datum_system",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &datum_system {
            check_datum_system_or_reference_ref(&self.model, e0)?;
        }
        Ok(ParallelismToleranceId(
            self.model
                .parallelism_tolerance_arena
                .push(ParallelismTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    datum_system,
                }),
        ))
    }

    /// `PARAMETRIC_REPRESENTATION_CONTEXT` — strict AP242 constructor.
    pub fn add_parametric_representation_context(
        &mut self,
        context_identifier: String,
        context_type: String,
    ) -> Result<ParametricRepresentationContextId, AuthorError> {
        Ok(ParametricRepresentationContextId(
            self.model.parametric_representation_context_arena.push(
                ParametricRepresentationContext {
                    context_identifier,
                    context_type,
                },
            ),
        ))
    }

    /// `PATH` — strict AP242 constructor.
    pub fn add_path(
        &mut self,
        name: String,
        edge_list: Vec<OrientedEdgeRef>,
    ) -> Result<PathId, AuthorError> {
        {
            let x = &edge_list;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PATH",
                    attribute: "edge_list",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &edge_list {
            check_oriented_edge_ref(&self.model, e0)?;
        }
        Ok(PathId(self.model.path_arena.push(Path { name, edge_list })))
    }

    /// `PCURVE` — strict AP242 constructor.
    pub fn add_pcurve(
        &mut self,
        name: String,
        basis_surface: SurfaceRef,
        reference_to_curve: DefinitionalRepresentationRef,
    ) -> Result<PcurveId, AuthorError> {
        check_surface_ref(&self.model, &basis_surface)?;
        check_definitional_representation_ref(&self.model, &reference_to_curve)?;
        Ok(PcurveId(self.model.pcurve_arena.push(Pcurve {
            name,
            basis_surface,
            reference_to_curve,
        })))
    }

    /// `PERPENDICULARITY_TOLERANCE` — strict AP242 constructor.
    pub fn add_perpendicularity_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        datum_system: Vec<DatumSystemOrReferenceRef>,
    ) -> Result<PerpendicularityToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        {
            let x = &datum_system;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PERPENDICULARITY_TOLERANCE",
                    attribute: "datum_system",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &datum_system {
            check_datum_system_or_reference_ref(&self.model, e0)?;
        }
        Ok(PerpendicularityToleranceId(
            self.model
                .perpendicularity_tolerance_arena
                .push(PerpendicularityTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    datum_system,
                }),
        ))
    }

    /// `PERSON` — strict AP242 constructor.
    pub fn add_person(
        &mut self,
        id: String,
        last_name: Option<String>,
        first_name: Option<String>,
        middle_names: Option<Vec<String>>,
        prefix_titles: Option<Vec<String>>,
        suffix_titles: Option<Vec<String>>,
    ) -> Result<PersonId, AuthorError> {
        if let Some(x) = &middle_names {
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PERSON",
                    attribute: "middle_names",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        if let Some(x) = &prefix_titles {
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PERSON",
                    attribute: "prefix_titles",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        if let Some(x) = &suffix_titles {
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PERSON",
                    attribute: "suffix_titles",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        Ok(PersonId(self.model.person_arena.push(Person {
            id,
            last_name,
            first_name,
            middle_names,
            prefix_titles,
            suffix_titles,
        })))
    }

    /// `PERSON_AND_ORGANIZATION` — strict AP242 constructor.
    pub fn add_person_and_organization(
        &mut self,
        the_person: PersonRef,
        the_organization: OrganizationRef,
    ) -> Result<PersonAndOrganizationId, AuthorError> {
        check_person_ref(&self.model, &the_person)?;
        check_organization_ref(&self.model, &the_organization)?;
        Ok(PersonAndOrganizationId(
            self.model
                .person_and_organization_arena
                .push(PersonAndOrganization {
                    the_person,
                    the_organization,
                }),
        ))
    }

    /// `PERSON_AND_ORGANIZATION_ADDRESS` — strict AP242 constructor.
    pub fn add_person_and_organization_address(
        &mut self,
        internal_location: Option<String>,
        street_number: Option<String>,
        street: Option<String>,
        postal_box: Option<String>,
        town: Option<String>,
        region: Option<String>,
        postal_code: Option<String>,
        country: Option<String>,
        facsimile_number: Option<String>,
        telephone_number: Option<String>,
        electronic_mail_address: Option<String>,
        telex_number: Option<String>,
        organizations: Vec<OrganizationRef>,
        description: Option<String>,
        people: Vec<PersonRef>,
        description_1: Option<String>,
    ) -> Result<PersonAndOrganizationAddressId, AuthorError> {
        {
            let x = &organizations;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PERSON_AND_ORGANIZATION_ADDRESS",
                    attribute: "organizations",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &organizations {
            check_organization_ref(&self.model, e0)?;
        }
        {
            let x = &people;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PERSON_AND_ORGANIZATION_ADDRESS",
                    attribute: "people",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &people {
            check_person_ref(&self.model, e0)?;
        }
        Ok(PersonAndOrganizationAddressId(
            self.model
                .person_and_organization_address_arena
                .push(PersonAndOrganizationAddress {
                    internal_location,
                    street_number,
                    street,
                    postal_box,
                    town,
                    region,
                    postal_code,
                    country,
                    facsimile_number,
                    telephone_number,
                    electronic_mail_address,
                    telex_number,
                    organizations,
                    description,
                    people,
                    description_1,
                }),
        ))
    }

    /// `PERSON_AND_ORGANIZATION_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_person_and_organization_assignment(
        &mut self,
        assigned_person_and_organization: PersonAndOrganizationRef,
        role: PersonAndOrganizationRoleRef,
    ) -> Result<PersonAndOrganizationAssignmentId, AuthorError> {
        check_person_and_organization_ref(&self.model, &assigned_person_and_organization)?;
        check_person_and_organization_role_ref(&self.model, &role)?;
        Ok(PersonAndOrganizationAssignmentId(
            self.model.person_and_organization_assignment_arena.push(
                PersonAndOrganizationAssignment {
                    assigned_person_and_organization,
                    role,
                },
            ),
        ))
    }

    /// `PERSON_AND_ORGANIZATION_ROLE` — strict AP242 constructor.
    pub fn add_person_and_organization_role(
        &mut self,
        name: String,
    ) -> Result<PersonAndOrganizationRoleId, AuthorError> {
        Ok(PersonAndOrganizationRoleId(
            self.model
                .person_and_organization_role_arena
                .push(PersonAndOrganizationRole { name }),
        ))
    }

    /// `PERSONAL_ADDRESS` — strict AP242 constructor.
    pub fn add_personal_address(
        &mut self,
        internal_location: Option<String>,
        street_number: Option<String>,
        street: Option<String>,
        postal_box: Option<String>,
        town: Option<String>,
        region: Option<String>,
        postal_code: Option<String>,
        country: Option<String>,
        facsimile_number: Option<String>,
        telephone_number: Option<String>,
        electronic_mail_address: Option<String>,
        telex_number: Option<String>,
        people: Vec<PersonRef>,
        description: Option<String>,
    ) -> Result<PersonalAddressId, AuthorError> {
        {
            let x = &people;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PERSONAL_ADDRESS",
                    attribute: "people",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &people {
            check_person_ref(&self.model, e0)?;
        }
        Ok(PersonalAddressId(self.model.personal_address_arena.push(
            PersonalAddress {
                internal_location,
                street_number,
                street,
                postal_box,
                town,
                region,
                postal_code,
                country,
                facsimile_number,
                telephone_number,
                electronic_mail_address,
                telex_number,
                people,
                description,
            },
        )))
    }

    /// `PLACED_DATUM_TARGET_FEATURE` — strict AP242 constructor.
    pub fn add_placed_datum_target_feature(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
        target_id: String,
    ) -> Result<PlacedDatumTargetFeatureId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(PlacedDatumTargetFeatureId(
            self.model
                .placed_datum_target_feature_arena
                .push(PlacedDatumTargetFeature {
                    name,
                    description,
                    of_shape,
                    product_definitional,
                    target_id,
                }),
        ))
    }

    /// `PLACEMENT` — strict AP242 constructor.
    pub fn add_placement(
        &mut self,
        name: String,
        location: CartesianPointRef,
    ) -> Result<PlacementId, AuthorError> {
        check_cartesian_point_ref(&self.model, &location)?;
        Ok(PlacementId(
            self.model
                .placement_arena
                .push(Placement { name, location }),
        ))
    }

    /// `PLANAR_BOX` — strict AP242 constructor.
    pub fn add_planar_box(
        &mut self,
        name: String,
        size_in_x: f64,
        size_in_y: f64,
        placement: Axis2PlacementRef,
    ) -> Result<PlanarBoxId, AuthorError> {
        check_axis2_placement_ref(&self.model, &placement)?;
        Ok(PlanarBoxId(self.model.planar_box_arena.push(PlanarBox {
            name,
            size_in_x,
            size_in_y,
            placement,
        })))
    }

    /// `PLANAR_EXTENT` — strict AP242 constructor.
    pub fn add_planar_extent(
        &mut self,
        name: String,
        size_in_x: f64,
        size_in_y: f64,
    ) -> Result<PlanarExtentId, AuthorError> {
        Ok(PlanarExtentId(self.model.planar_extent_arena.push(
            PlanarExtent {
                name,
                size_in_x,
                size_in_y,
            },
        )))
    }

    /// `PLANE` — strict AP242 constructor.
    pub fn add_plane(
        &mut self,
        name: String,
        position: Axis2Placement3dRef,
    ) -> Result<PlaneId, AuthorError> {
        check_axis2_placement3d_ref(&self.model, &position)?;
        Ok(PlaneId(
            self.model.plane_arena.push(Plane { name, position }),
        ))
    }

    /// `PLANE_ANGLE_MEASURE_WITH_UNIT` — strict AP242 constructor.
    pub fn add_plane_angle_measure_with_unit(
        &mut self,
        value_component: MeasureValue,
        unit_component: UnitRef,
    ) -> Result<PlaneAngleMeasureWithUnitId, AuthorError> {
        check_unit_ref(&self.model, &unit_component)?;
        Ok(PlaneAngleMeasureWithUnitId(
            self.model
                .plane_angle_measure_with_unit_arena
                .push(PlaneAngleMeasureWithUnit {
                    value_component,
                    unit_component,
                }),
        ))
    }

    /// `PLANE_ANGLE_UNIT` — strict AP242 constructor.
    pub fn add_plane_angle_unit(
        &mut self,
        dimensions: DimensionalExponentsRef,
    ) -> Result<PlaneAngleUnitId, AuthorError> {
        check_dimensional_exponents_ref(&self.model, &dimensions)?;
        Ok(PlaneAngleUnitId(
            self.model
                .plane_angle_unit_arena
                .push(PlaneAngleUnit { dimensions }),
        ))
    }

    /// `PLUS_MINUS_TOLERANCE` — strict AP242 constructor.
    pub fn add_plus_minus_tolerance(
        &mut self,
        range: ToleranceMethodDefinitionRef,
        toleranced_dimension: DimensionalCharacteristicRef,
    ) -> Result<PlusMinusToleranceId, AuthorError> {
        check_tolerance_method_definition_ref(&self.model, &range)?;
        check_dimensional_characteristic_ref(&self.model, &toleranced_dimension)?;
        Ok(PlusMinusToleranceId(
            self.model
                .plus_minus_tolerance_arena
                .push(PlusMinusTolerance {
                    range,
                    toleranced_dimension,
                }),
        ))
    }

    /// `POINT` — strict AP242 constructor.
    pub fn add_point(&mut self, name: String) -> Result<PointId, AuthorError> {
        Ok(PointId(self.model.point_arena.push(Point { name })))
    }

    /// `POINT_STYLE` — strict AP242 constructor.
    pub fn add_point_style(
        &mut self,
        name: String,
        marker: Option<MarkerSelectRef>,
        marker_size: Option<SizeSelectRef>,
        marker_colour: Option<ColourRef>,
    ) -> Result<PointStyleId, AuthorError> {
        if let Some(x) = &marker {
            check_marker_select_ref(&self.model, x)?;
        }
        if let Some(x) = &marker_size {
            check_size_select_ref(&self.model, x)?;
        }
        if let Some(x) = &marker_colour {
            check_colour_ref(&self.model, x)?;
        }
        Ok(PointStyleId(self.model.point_style_arena.push(
            PointStyle {
                name,
                marker,
                marker_size,
                marker_colour,
            },
        )))
    }

    /// `POLY_LOOP` — strict AP242 constructor.
    pub fn add_poly_loop(
        &mut self,
        name: String,
        polygon: Vec<CartesianPointRef>,
    ) -> Result<PolyLoopId, AuthorError> {
        {
            let x = &polygon;
            if x.len() < 3 {
                return Err(AuthorError::Cardinality {
                    entity: "POLY_LOOP",
                    attribute: "polygon",
                    got: x.len(),
                    min: 3,
                    max: None,
                });
            }
        }
        for e0 in &polygon {
            check_cartesian_point_ref(&self.model, e0)?;
        }
        Ok(PolyLoopId(
            self.model.poly_loop_arena.push(PolyLoop { name, polygon }),
        ))
    }

    /// `POLYLINE` — strict AP242 constructor.
    pub fn add_polyline(
        &mut self,
        name: String,
        points: Vec<CartesianPointRef>,
    ) -> Result<PolylineId, AuthorError> {
        {
            let x = &points;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "POLYLINE",
                    attribute: "points",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &points {
            check_cartesian_point_ref(&self.model, e0)?;
        }
        Ok(PolylineId(
            self.model.polyline_arena.push(Polyline { name, points }),
        ))
    }

    /// `POSITION_TOLERANCE` — strict AP242 constructor.
    pub fn add_position_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
    ) -> Result<PositionToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        Ok(PositionToleranceId(
            self.model.position_tolerance_arena.push(PositionTolerance {
                name,
                description,
                magnitude,
                toleranced_shape_aspect,
            }),
        ))
    }

    /// `PRE_DEFINED_CHARACTER_GLYPH` — strict AP242 constructor.
    pub fn add_pre_defined_character_glyph(
        &mut self,
        name: String,
    ) -> Result<PreDefinedCharacterGlyphId, AuthorError> {
        Ok(PreDefinedCharacterGlyphId(
            self.model
                .pre_defined_character_glyph_arena
                .push(PreDefinedCharacterGlyph { name }),
        ))
    }

    /// `PRE_DEFINED_COLOUR` — strict AP242 constructor.
    pub fn add_pre_defined_colour(
        &mut self,
        name: String,
    ) -> Result<PreDefinedColourId, AuthorError> {
        Ok(PreDefinedColourId(
            self.model
                .pre_defined_colour_arena
                .push(PreDefinedColour { name }),
        ))
    }

    /// `PRE_DEFINED_CURVE_FONT` — strict AP242 constructor.
    pub fn add_pre_defined_curve_font(
        &mut self,
        name: String,
    ) -> Result<PreDefinedCurveFontId, AuthorError> {
        Ok(PreDefinedCurveFontId(
            self.model
                .pre_defined_curve_font_arena
                .push(PreDefinedCurveFont { name }),
        ))
    }

    /// `PRE_DEFINED_ITEM` — strict AP242 constructor.
    pub fn add_pre_defined_item(&mut self, name: String) -> Result<PreDefinedItemId, AuthorError> {
        Ok(PreDefinedItemId(
            self.model
                .pre_defined_item_arena
                .push(PreDefinedItem { name }),
        ))
    }

    /// `PRE_DEFINED_MARKER` — strict AP242 constructor.
    pub fn add_pre_defined_marker(
        &mut self,
        name: String,
    ) -> Result<PreDefinedMarkerId, AuthorError> {
        Ok(PreDefinedMarkerId(
            self.model
                .pre_defined_marker_arena
                .push(PreDefinedMarker { name }),
        ))
    }

    /// `PRE_DEFINED_POINT_MARKER_SYMBOL` — strict AP242 constructor.
    pub fn add_pre_defined_point_marker_symbol(
        &mut self,
        name: String,
    ) -> Result<PreDefinedPointMarkerSymbolId, AuthorError> {
        Ok(PreDefinedPointMarkerSymbolId(
            self.model
                .pre_defined_point_marker_symbol_arena
                .push(PreDefinedPointMarkerSymbol { name }),
        ))
    }

    /// `PRE_DEFINED_SURFACE_SIDE_STYLE` — strict AP242 constructor.
    pub fn add_pre_defined_surface_side_style(
        &mut self,
        name: String,
    ) -> Result<PreDefinedSurfaceSideStyleId, AuthorError> {
        Ok(PreDefinedSurfaceSideStyleId(
            self.model
                .pre_defined_surface_side_style_arena
                .push(PreDefinedSurfaceSideStyle { name }),
        ))
    }

    /// `PRE_DEFINED_SYMBOL` — strict AP242 constructor.
    pub fn add_pre_defined_symbol(
        &mut self,
        name: String,
    ) -> Result<PreDefinedSymbolId, AuthorError> {
        Ok(PreDefinedSymbolId(
            self.model
                .pre_defined_symbol_arena
                .push(PreDefinedSymbol { name }),
        ))
    }

    /// `PRE_DEFINED_TERMINATOR_SYMBOL` — strict AP242 constructor.
    pub fn add_pre_defined_terminator_symbol(
        &mut self,
        name: String,
    ) -> Result<PreDefinedTerminatorSymbolId, AuthorError> {
        Ok(PreDefinedTerminatorSymbolId(
            self.model
                .pre_defined_terminator_symbol_arena
                .push(PreDefinedTerminatorSymbol { name }),
        ))
    }

    /// `PRE_DEFINED_TEXT_FONT` — strict AP242 constructor.
    pub fn add_pre_defined_text_font(
        &mut self,
        name: String,
    ) -> Result<PreDefinedTextFontId, AuthorError> {
        Ok(PreDefinedTextFontId(
            self.model
                .pre_defined_text_font_arena
                .push(PreDefinedTextFont { name }),
        ))
    }

    /// `PRE_DEFINED_TILE` — strict AP242 constructor.
    pub fn add_pre_defined_tile(&mut self, name: String) -> Result<PreDefinedTileId, AuthorError> {
        Ok(PreDefinedTileId(
            self.model
                .pre_defined_tile_arena
                .push(PreDefinedTile { name }),
        ))
    }

    /// `PRECISION_QUALIFIER` — strict AP242 constructor.
    pub fn add_precision_qualifier(
        &mut self,
        precision_value: i64,
    ) -> Result<PrecisionQualifierId, AuthorError> {
        Ok(PrecisionQualifierId(
            self.model
                .precision_qualifier_arena
                .push(PrecisionQualifier { precision_value }),
        ))
    }

    /// `PRESENTATION_AREA` — strict AP242 constructor.
    pub fn add_presentation_area(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<PresentationAreaId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PRESENTATION_AREA",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(PresentationAreaId(self.model.presentation_area_arena.push(
            PresentationArea {
                name,
                items,
                context_of_items,
            },
        )))
    }

    /// `PRESENTATION_LAYER_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_presentation_layer_assignment(
        &mut self,
        name: String,
        description: String,
        assigned_items: Vec<LayeredItemRef>,
    ) -> Result<PresentationLayerAssignmentId, AuthorError> {
        {
            let x = &assigned_items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PRESENTATION_LAYER_ASSIGNMENT",
                    attribute: "assigned_items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &assigned_items {
            check_layered_item_ref(&self.model, e0)?;
        }
        Ok(PresentationLayerAssignmentId(
            self.model
                .presentation_layer_assignment_arena
                .push(PresentationLayerAssignment {
                    name,
                    description,
                    assigned_items,
                }),
        ))
    }

    /// `PRESENTATION_REPRESENTATION` — strict AP242 constructor.
    pub fn add_presentation_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<PresentationRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PRESENTATION_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(PresentationRepresentationId(
            self.model
                .presentation_representation_arena
                .push(PresentationRepresentation {
                    name,
                    items,
                    context_of_items,
                }),
        ))
    }

    /// `PRESENTATION_SET` — strict AP242 constructor.
    pub fn add_presentation_set(&mut self) -> Result<PresentationSetId, AuthorError> {
        Ok(PresentationSetId(
            self.model.presentation_set_arena.push(PresentationSet {}),
        ))
    }

    /// `PRESENTATION_SIZE` — strict AP242 constructor.
    pub fn add_presentation_size(
        &mut self,
        unit: PresentationSizeAssignmentSelectRef,
        size: PlanarBoxRef,
    ) -> Result<PresentationSizeId, AuthorError> {
        check_presentation_size_assignment_select_ref(&self.model, &unit)?;
        check_planar_box_ref(&self.model, &size)?;
        Ok(PresentationSizeId(
            self.model
                .presentation_size_arena
                .push(PresentationSize { unit, size }),
        ))
    }

    /// `PRESENTATION_STYLE_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_presentation_style_assignment(
        &mut self,
        styles: Vec<PresentationStyleSelectRef>,
    ) -> Result<PresentationStyleAssignmentId, AuthorError> {
        {
            let x = &styles;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PRESENTATION_STYLE_ASSIGNMENT",
                    attribute: "styles",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &styles {
            check_presentation_style_select_ref(&self.model, e0)?;
        }
        Ok(PresentationStyleAssignmentId(
            self.model
                .presentation_style_assignment_arena
                .push(PresentationStyleAssignment { styles }),
        ))
    }

    /// `PRESENTATION_STYLE_BY_CONTEXT` — strict AP242 constructor.
    pub fn add_presentation_style_by_context(
        &mut self,
        styles: Vec<PresentationStyleSelectRef>,
        style_context: StyleContextSelectRef,
    ) -> Result<PresentationStyleByContextId, AuthorError> {
        {
            let x = &styles;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PRESENTATION_STYLE_BY_CONTEXT",
                    attribute: "styles",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &styles {
            check_presentation_style_select_ref(&self.model, e0)?;
        }
        check_style_context_select_ref(&self.model, &style_context)?;
        Ok(PresentationStyleByContextId(
            self.model
                .presentation_style_by_context_arena
                .push(PresentationStyleByContext {
                    styles,
                    style_context,
                }),
        ))
    }

    /// `PRESENTATION_VIEW` — strict AP242 constructor.
    pub fn add_presentation_view(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<PresentationViewId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PRESENTATION_VIEW",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(PresentationViewId(self.model.presentation_view_arena.push(
            PresentationView {
                name,
                items,
                context_of_items,
            },
        )))
    }

    /// `PRESENTED_ITEM` — strict AP242 constructor.
    pub fn add_presented_item(&mut self) -> Result<PresentedItemId, AuthorError> {
        Ok(PresentedItemId(
            self.model.presented_item_arena.push(PresentedItem {}),
        ))
    }

    /// `PRESENTED_ITEM_REPRESENTATION` — strict AP242 constructor.
    pub fn add_presented_item_representation(
        &mut self,
        presentation: PresentationRepresentationSelectRef,
        item: PresentedItemRef,
    ) -> Result<PresentedItemRepresentationId, AuthorError> {
        check_presentation_representation_select_ref(&self.model, &presentation)?;
        check_presented_item_ref(&self.model, &item)?;
        Ok(PresentedItemRepresentationId(
            self.model
                .presented_item_representation_arena
                .push(PresentedItemRepresentation { presentation, item }),
        ))
    }

    /// `PRODUCT` — strict AP242 constructor.
    pub fn add_product(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
        frame_of_reference: Vec<ProductContextRef>,
    ) -> Result<ProductId, AuthorError> {
        {
            let x = &frame_of_reference;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PRODUCT",
                    attribute: "frame_of_reference",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &frame_of_reference {
            check_product_context_ref(&self.model, e0)?;
        }
        Ok(ProductId(self.model.product_arena.push(Product {
            id,
            name,
            description,
            frame_of_reference,
        })))
    }

    /// `PRODUCT_CATEGORY` — strict AP242 constructor.
    pub fn add_product_category(
        &mut self,
        name: String,
        description: Option<String>,
    ) -> Result<ProductCategoryId, AuthorError> {
        Ok(ProductCategoryId(
            self.model
                .product_category_arena
                .push(ProductCategory { name, description }),
        ))
    }

    /// `PRODUCT_CATEGORY_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_product_category_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        category: ProductCategoryRef,
        sub_category: ProductCategoryRef,
    ) -> Result<ProductCategoryRelationshipId, AuthorError> {
        check_product_category_ref(&self.model, &category)?;
        check_product_category_ref(&self.model, &sub_category)?;
        Ok(ProductCategoryRelationshipId(
            self.model
                .product_category_relationship_arena
                .push(ProductCategoryRelationship {
                    name,
                    description,
                    category,
                    sub_category,
                }),
        ))
    }

    /// `PRODUCT_CONCEPT` — strict AP242 constructor.
    pub fn add_product_concept(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
        market_context: ProductConceptContextRef,
    ) -> Result<ProductConceptId, AuthorError> {
        check_product_concept_context_ref(&self.model, &market_context)?;
        Ok(ProductConceptId(self.model.product_concept_arena.push(
            ProductConcept {
                id,
                name,
                description,
                market_context,
            },
        )))
    }

    /// `PRODUCT_CONCEPT_CONTEXT` — strict AP242 constructor.
    pub fn add_product_concept_context(
        &mut self,
        name: String,
        frame_of_reference: ApplicationContextRef,
        market_segment_type: String,
    ) -> Result<ProductConceptContextId, AuthorError> {
        check_application_context_ref(&self.model, &frame_of_reference)?;
        Ok(ProductConceptContextId(
            self.model
                .product_concept_context_arena
                .push(ProductConceptContext {
                    name,
                    frame_of_reference,
                    market_segment_type,
                }),
        ))
    }

    /// `PRODUCT_CONCEPT_FEATURE` — strict AP242 constructor.
    pub fn add_product_concept_feature(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
    ) -> Result<ProductConceptFeatureId, AuthorError> {
        Ok(ProductConceptFeatureId(
            self.model
                .product_concept_feature_arena
                .push(ProductConceptFeature {
                    id,
                    name,
                    description,
                }),
        ))
    }

    /// `PRODUCT_CONCEPT_FEATURE_CATEGORY` — strict AP242 constructor.
    pub fn add_product_concept_feature_category(
        &mut self,
        name: String,
        description: Option<String>,
    ) -> Result<ProductConceptFeatureCategoryId, AuthorError> {
        Ok(ProductConceptFeatureCategoryId(
            self.model
                .product_concept_feature_category_arena
                .push(ProductConceptFeatureCategory { name, description }),
        ))
    }

    /// `PRODUCT_CONTEXT` — strict AP242 constructor.
    pub fn add_product_context(
        &mut self,
        name: String,
        frame_of_reference: ApplicationContextRef,
        discipline_type: String,
    ) -> Result<ProductContextId, AuthorError> {
        check_application_context_ref(&self.model, &frame_of_reference)?;
        Ok(ProductContextId(self.model.product_context_arena.push(
            ProductContext {
                name,
                frame_of_reference,
                discipline_type,
            },
        )))
    }

    /// `PRODUCT_DEFINITION` — strict AP242 constructor.
    pub fn add_product_definition(
        &mut self,
        id: String,
        description: Option<String>,
        formation: ProductDefinitionFormationRef,
        frame_of_reference: ProductDefinitionContextRef,
    ) -> Result<ProductDefinitionId, AuthorError> {
        check_product_definition_formation_ref(&self.model, &formation)?;
        check_product_definition_context_ref(&self.model, &frame_of_reference)?;
        Ok(ProductDefinitionId(
            self.model.product_definition_arena.push(ProductDefinition {
                id,
                description,
                formation,
                frame_of_reference,
            }),
        ))
    }

    /// `PRODUCT_DEFINITION_CONTEXT` — strict AP242 constructor.
    pub fn add_product_definition_context(
        &mut self,
        name: String,
        frame_of_reference: ApplicationContextRef,
        life_cycle_stage: String,
    ) -> Result<ProductDefinitionContextId, AuthorError> {
        check_application_context_ref(&self.model, &frame_of_reference)?;
        Ok(ProductDefinitionContextId(
            self.model
                .product_definition_context_arena
                .push(ProductDefinitionContext {
                    name,
                    frame_of_reference,
                    life_cycle_stage,
                }),
        ))
    }

    /// `PRODUCT_DEFINITION_CONTEXT_ASSOCIATION` — strict AP242 constructor.
    pub fn add_product_definition_context_association(
        &mut self,
        definition: ProductDefinitionRef,
        frame_of_reference: ProductDefinitionContextRef,
        role: ProductDefinitionContextRoleRef,
    ) -> Result<ProductDefinitionContextAssociationId, AuthorError> {
        check_product_definition_ref(&self.model, &definition)?;
        check_product_definition_context_ref(&self.model, &frame_of_reference)?;
        check_product_definition_context_role_ref(&self.model, &role)?;
        Ok(ProductDefinitionContextAssociationId(
            self.model
                .product_definition_context_association_arena
                .push(ProductDefinitionContextAssociation {
                    definition,
                    frame_of_reference,
                    role,
                }),
        ))
    }

    /// `PRODUCT_DEFINITION_CONTEXT_ROLE` — strict AP242 constructor.
    pub fn add_product_definition_context_role(
        &mut self,
        name: String,
        description: Option<String>,
    ) -> Result<ProductDefinitionContextRoleId, AuthorError> {
        Ok(ProductDefinitionContextRoleId(
            self.model
                .product_definition_context_role_arena
                .push(ProductDefinitionContextRole { name, description }),
        ))
    }

    /// `PRODUCT_DEFINITION_EFFECTIVITY` — strict AP242 constructor.
    pub fn add_product_definition_effectivity(
        &mut self,
        id: String,
        usage: ProductDefinitionRelationshipRef,
    ) -> Result<ProductDefinitionEffectivityId, AuthorError> {
        check_product_definition_relationship_ref(&self.model, &usage)?;
        Ok(ProductDefinitionEffectivityId(
            self.model
                .product_definition_effectivity_arena
                .push(ProductDefinitionEffectivity { id, usage }),
        ))
    }

    /// `PRODUCT_DEFINITION_FORMATION` — strict AP242 constructor.
    pub fn add_product_definition_formation(
        &mut self,
        id: String,
        description: Option<String>,
        of_product: ProductRef,
    ) -> Result<ProductDefinitionFormationId, AuthorError> {
        check_product_ref(&self.model, &of_product)?;
        Ok(ProductDefinitionFormationId(
            self.model
                .product_definition_formation_arena
                .push(ProductDefinitionFormation {
                    id,
                    description,
                    of_product,
                }),
        ))
    }

    /// `PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE` — strict AP242 constructor.
    pub fn add_product_definition_formation_with_specified_source(
        &mut self,
        id: String,
        description: Option<String>,
        of_product: ProductRef,
        make_or_buy: Source,
    ) -> Result<ProductDefinitionFormationWithSpecifiedSourceId, AuthorError> {
        check_product_ref(&self.model, &of_product)?;
        Ok(ProductDefinitionFormationWithSpecifiedSourceId(
            self.model
                .product_definition_formation_with_specified_source_arena
                .push(ProductDefinitionFormationWithSpecifiedSource {
                    id,
                    description,
                    of_product,
                    make_or_buy,
                }),
        ))
    }

    /// `PRODUCT_DEFINITION_OCCURRENCE` — strict AP242 constructor.
    pub fn add_product_definition_occurrence(
        &mut self,
        id: String,
        name: Option<String>,
        description: Option<String>,
        definition: Option<ProductDefinitionOrReferenceRef>,
        quantity: Option<MeasureWithUnitRef>,
    ) -> Result<ProductDefinitionOccurrenceId, AuthorError> {
        if let Some(x) = &definition {
            check_product_definition_or_reference_ref(&self.model, x)?;
        }
        if let Some(x) = &quantity {
            check_measure_with_unit_ref(&self.model, x)?;
        }
        Ok(ProductDefinitionOccurrenceId(
            self.model
                .product_definition_occurrence_arena
                .push(ProductDefinitionOccurrence {
                    id,
                    name,
                    description,
                    definition,
                    quantity,
                }),
        ))
    }

    /// `PRODUCT_DEFINITION_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_product_definition_relationship(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
        relating_product_definition: ProductDefinitionOrReferenceRef,
        related_product_definition: ProductDefinitionOrReferenceRef,
    ) -> Result<ProductDefinitionRelationshipId, AuthorError> {
        check_product_definition_or_reference_ref(&self.model, &relating_product_definition)?;
        check_product_definition_or_reference_ref(&self.model, &related_product_definition)?;
        Ok(ProductDefinitionRelationshipId(
            self.model
                .product_definition_relationship_arena
                .push(ProductDefinitionRelationship {
                    id,
                    name,
                    description,
                    relating_product_definition,
                    related_product_definition,
                }),
        ))
    }

    /// `PRODUCT_DEFINITION_RELATIONSHIP_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_product_definition_relationship_relationship(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
        relating: ProductDefinitionRelationshipRef,
        related: ProductDefinitionRelationshipRef,
    ) -> Result<ProductDefinitionRelationshipRelationshipId, AuthorError> {
        check_product_definition_relationship_ref(&self.model, &relating)?;
        check_product_definition_relationship_ref(&self.model, &related)?;
        Ok(ProductDefinitionRelationshipRelationshipId(
            self.model
                .product_definition_relationship_relationship_arena
                .push(ProductDefinitionRelationshipRelationship {
                    id,
                    name,
                    description,
                    relating,
                    related,
                }),
        ))
    }

    /// `PRODUCT_DEFINITION_SHAPE` — strict AP242 constructor.
    pub fn add_product_definition_shape(
        &mut self,
        name: String,
        description: Option<String>,
        definition: CharacterizedDefinitionRef,
    ) -> Result<ProductDefinitionShapeId, AuthorError> {
        check_characterized_definition_ref(&self.model, &definition)?;
        Ok(ProductDefinitionShapeId(
            self.model
                .product_definition_shape_arena
                .push(ProductDefinitionShape {
                    name,
                    description,
                    definition,
                }),
        ))
    }

    /// `PRODUCT_DEFINITION_SUBSTITUTE` — strict AP242 constructor.
    pub fn add_product_definition_substitute(
        &mut self,
        description: Option<String>,
        context_relationship: ProductDefinitionRelationshipRef,
        substitute_definition: ProductDefinitionRef,
    ) -> Result<ProductDefinitionSubstituteId, AuthorError> {
        check_product_definition_relationship_ref(&self.model, &context_relationship)?;
        check_product_definition_ref(&self.model, &substitute_definition)?;
        Ok(ProductDefinitionSubstituteId(
            self.model
                .product_definition_substitute_arena
                .push(ProductDefinitionSubstitute {
                    description,
                    context_relationship,
                    substitute_definition,
                }),
        ))
    }

    /// `PRODUCT_DEFINITION_USAGE` — strict AP242 constructor.
    pub fn add_product_definition_usage(
        &mut self,
        id: String,
        name: String,
        description: Option<String>,
        relating_product_definition: ProductDefinitionOrReferenceRef,
        related_product_definition: ProductDefinitionOrReferenceRef,
    ) -> Result<ProductDefinitionUsageId, AuthorError> {
        check_product_definition_or_reference_ref(&self.model, &relating_product_definition)?;
        check_product_definition_or_reference_ref(&self.model, &related_product_definition)?;
        Ok(ProductDefinitionUsageId(
            self.model
                .product_definition_usage_arena
                .push(ProductDefinitionUsage {
                    id,
                    name,
                    description,
                    relating_product_definition,
                    related_product_definition,
                }),
        ))
    }

    /// `PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS` — strict AP242 constructor.
    pub fn add_product_definition_with_associated_documents(
        &mut self,
        id: String,
        description: Option<String>,
        formation: ProductDefinitionFormationRef,
        frame_of_reference: ProductDefinitionContextRef,
        documentation_ids: Vec<DocumentRef>,
    ) -> Result<ProductDefinitionWithAssociatedDocumentsId, AuthorError> {
        check_product_definition_formation_ref(&self.model, &formation)?;
        check_product_definition_context_ref(&self.model, &frame_of_reference)?;
        {
            let x = &documentation_ids;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                    attribute: "documentation_ids",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &documentation_ids {
            check_document_ref(&self.model, e0)?;
        }
        Ok(ProductDefinitionWithAssociatedDocumentsId(
            self.model
                .product_definition_with_associated_documents_arena
                .push(ProductDefinitionWithAssociatedDocuments {
                    id,
                    description,
                    formation,
                    frame_of_reference,
                    documentation_ids,
                }),
        ))
    }

    /// `PRODUCT_RELATED_PRODUCT_CATEGORY` — strict AP242 constructor.
    pub fn add_product_related_product_category(
        &mut self,
        name: String,
        description: Option<String>,
        products: Vec<ProductRef>,
    ) -> Result<ProductRelatedProductCategoryId, AuthorError> {
        {
            let x = &products;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "PRODUCT_RELATED_PRODUCT_CATEGORY",
                    attribute: "products",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &products {
            check_product_ref(&self.model, e0)?;
        }
        Ok(ProductRelatedProductCategoryId(
            self.model
                .product_related_product_category_arena
                .push(ProductRelatedProductCategory {
                    name,
                    description,
                    products,
                }),
        ))
    }

    /// `PROJECTED_ZONE_DEFINITION` — strict AP242 constructor.
    pub fn add_projected_zone_definition(
        &mut self,
        zone: ToleranceZoneRef,
        boundaries: Vec<ShapeAspectRef>,
        projection_end: ShapeAspectRef,
        projected_length: LengthMeasureWithUnitRef,
    ) -> Result<ProjectedZoneDefinitionId, AuthorError> {
        check_tolerance_zone_ref(&self.model, &zone)?;
        for e0 in &boundaries {
            check_shape_aspect_ref(&self.model, e0)?;
        }
        check_shape_aspect_ref(&self.model, &projection_end)?;
        check_length_measure_with_unit_ref(&self.model, &projected_length)?;
        Ok(ProjectedZoneDefinitionId(
            self.model
                .projected_zone_definition_arena
                .push(ProjectedZoneDefinition {
                    zone,
                    boundaries,
                    projection_end,
                    projected_length,
                }),
        ))
    }

    /// `PROPERTY_DEFINITION` — strict AP242 constructor.
    pub fn add_property_definition(
        &mut self,
        name: String,
        description: Option<String>,
        definition: CharacterizedDefinitionRef,
    ) -> Result<PropertyDefinitionId, AuthorError> {
        check_characterized_definition_ref(&self.model, &definition)?;
        Ok(PropertyDefinitionId(
            self.model
                .property_definition_arena
                .push(PropertyDefinition {
                    name,
                    description,
                    definition,
                }),
        ))
    }

    /// `PROPERTY_DEFINITION_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_property_definition_relationship(
        &mut self,
        name: String,
        description: String,
        relating_property_definition: PropertyDefinitionRef,
        related_property_definition: PropertyDefinitionRef,
    ) -> Result<PropertyDefinitionRelationshipId, AuthorError> {
        check_property_definition_ref(&self.model, &relating_property_definition)?;
        check_property_definition_ref(&self.model, &related_property_definition)?;
        Ok(PropertyDefinitionRelationshipId(
            self.model.property_definition_relationship_arena.push(
                PropertyDefinitionRelationship {
                    name,
                    description,
                    relating_property_definition,
                    related_property_definition,
                },
            ),
        ))
    }

    /// `PROPERTY_DEFINITION_REPRESENTATION` — strict AP242 constructor.
    pub fn add_property_definition_representation(
        &mut self,
        definition: RepresentedDefinitionRef,
        used_representation: RepresentationRef,
    ) -> Result<PropertyDefinitionRepresentationId, AuthorError> {
        check_represented_definition_ref(&self.model, &definition)?;
        check_representation_ref(&self.model, &used_representation)?;
        Ok(PropertyDefinitionRepresentationId(
            self.model.property_definition_representation_arena.push(
                PropertyDefinitionRepresentation {
                    definition,
                    used_representation,
                },
            ),
        ))
    }

    /// `QUALIFIED_REPRESENTATION_ITEM` — strict AP242 constructor.
    pub fn add_qualified_representation_item(
        &mut self,
        name: String,
        qualifiers: Vec<ValueQualifierRef>,
    ) -> Result<QualifiedRepresentationItemId, AuthorError> {
        {
            let x = &qualifiers;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "QUALIFIED_REPRESENTATION_ITEM",
                    attribute: "qualifiers",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &qualifiers {
            check_value_qualifier_ref(&self.model, e0)?;
        }
        Ok(QualifiedRepresentationItemId(
            self.model
                .qualified_representation_item_arena
                .push(QualifiedRepresentationItem { name, qualifiers }),
        ))
    }

    /// `QUASI_UNIFORM_CURVE` — strict AP242 constructor.
    pub fn add_quasi_uniform_curve(
        &mut self,
        name: String,
        degree: i64,
        control_points_list: Vec<CartesianPointRef>,
        curve_form: BSplineCurveForm,
        closed_curve: Logical,
        self_intersect: Logical,
    ) -> Result<QuasiUniformCurveId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "QUASI_UNIFORM_CURVE",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            check_cartesian_point_ref(&self.model, e0)?;
        }
        Ok(QuasiUniformCurveId(
            self.model
                .quasi_uniform_curve_arena
                .push(QuasiUniformCurve {
                    name,
                    degree,
                    control_points_list,
                    curve_form,
                    closed_curve,
                    self_intersect,
                }),
        ))
    }

    /// `QUASI_UNIFORM_SURFACE` — strict AP242 constructor.
    pub fn add_quasi_uniform_surface(
        &mut self,
        name: String,
        u_degree: i64,
        v_degree: i64,
        control_points_list: Vec<Vec<CartesianPointRef>>,
        surface_form: BSplineSurfaceForm,
        u_closed: Logical,
        v_closed: Logical,
        self_intersect: Logical,
    ) -> Result<QuasiUniformSurfaceId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "QUASI_UNIFORM_SURFACE",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            for e1 in e0 {
                check_cartesian_point_ref(&self.model, e1)?;
            }
        }
        Ok(QuasiUniformSurfaceId(
            self.model
                .quasi_uniform_surface_arena
                .push(QuasiUniformSurface {
                    name,
                    u_degree,
                    v_degree,
                    control_points_list,
                    surface_form,
                    u_closed,
                    v_closed,
                    self_intersect,
                }),
        ))
    }

    /// `RATIO_MEASURE_WITH_UNIT` — strict AP242 constructor.
    pub fn add_ratio_measure_with_unit(
        &mut self,
        value_component: MeasureValue,
        unit_component: UnitRef,
    ) -> Result<RatioMeasureWithUnitId, AuthorError> {
        check_unit_ref(&self.model, &unit_component)?;
        Ok(RatioMeasureWithUnitId(
            self.model
                .ratio_measure_with_unit_arena
                .push(RatioMeasureWithUnit {
                    value_component,
                    unit_component,
                }),
        ))
    }

    /// `RATIO_UNIT` — strict AP242 constructor.
    pub fn add_ratio_unit(
        &mut self,
        dimensions: DimensionalExponentsRef,
    ) -> Result<RatioUnitId, AuthorError> {
        check_dimensional_exponents_ref(&self.model, &dimensions)?;
        Ok(RatioUnitId(
            self.model.ratio_unit_arena.push(RatioUnit { dimensions }),
        ))
    }

    /// `RATIONAL_B_SPLINE_CURVE` — strict AP242 constructor.
    pub fn add_rational_b_spline_curve(
        &mut self,
        name: String,
        degree: i64,
        control_points_list: Vec<CartesianPointRef>,
        curve_form: BSplineCurveForm,
        closed_curve: Logical,
        self_intersect: Logical,
        weights_data: Vec<f64>,
    ) -> Result<RationalBSplineCurveId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            check_cartesian_point_ref(&self.model, e0)?;
        }
        {
            let x = &weights_data;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                    attribute: "weights_data",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        Ok(RationalBSplineCurveId(
            self.model
                .rational_b_spline_curve_arena
                .push(RationalBSplineCurve {
                    name,
                    degree,
                    control_points_list,
                    curve_form,
                    closed_curve,
                    self_intersect,
                    weights_data,
                }),
        ))
    }

    /// `RATIONAL_B_SPLINE_SURFACE` — strict AP242 constructor.
    pub fn add_rational_b_spline_surface(
        &mut self,
        name: String,
        u_degree: i64,
        v_degree: i64,
        control_points_list: Vec<Vec<CartesianPointRef>>,
        surface_form: BSplineSurfaceForm,
        u_closed: Logical,
        v_closed: Logical,
        self_intersect: Logical,
        weights_data: Vec<Vec<f64>>,
    ) -> Result<RationalBSplineSurfaceId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            for e1 in e0 {
                check_cartesian_point_ref(&self.model, e1)?;
            }
        }
        {
            let x = &weights_data;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                    attribute: "weights_data",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        Ok(RationalBSplineSurfaceId(
            self.model
                .rational_b_spline_surface_arena
                .push(RationalBSplineSurface {
                    name,
                    u_degree,
                    v_degree,
                    control_points_list,
                    surface_form,
                    u_closed,
                    v_closed,
                    self_intersect,
                    weights_data,
                }),
        ))
    }

    /// `REAL_LITERAL` — strict AP242 constructor.
    pub fn add_real_literal(&mut self, the_value: f64) -> Result<RealLiteralId, AuthorError> {
        Ok(RealLiteralId(
            self.model
                .real_literal_arena
                .push(RealLiteral { the_value }),
        ))
    }

    /// `REAL_REPRESENTATION_ITEM` — strict AP242 constructor.
    pub fn add_real_representation_item(
        &mut self,
        name: String,
        the_value: f64,
    ) -> Result<RealRepresentationItemId, AuthorError> {
        Ok(RealRepresentationItemId(
            self.model
                .real_representation_item_arena
                .push(RealRepresentationItem { name, the_value }),
        ))
    }

    /// `REPOSITIONED_TESSELLATED_ITEM` — strict AP242 constructor.
    pub fn add_repositioned_tessellated_item(
        &mut self,
        name: String,
        location: Axis2Placement3dRef,
    ) -> Result<RepositionedTessellatedItemId, AuthorError> {
        check_axis2_placement3d_ref(&self.model, &location)?;
        Ok(RepositionedTessellatedItemId(
            self.model
                .repositioned_tessellated_item_arena
                .push(RepositionedTessellatedItem { name, location }),
        ))
    }

    /// `REPRESENTATION` — strict AP242 constructor.
    pub fn add_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<RepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(RepresentationId(self.model.representation_arena.push(
            Representation {
                name,
                items,
                context_of_items,
            },
        )))
    }

    /// `REPRESENTATION_CONTEXT` — strict AP242 constructor.
    pub fn add_representation_context(
        &mut self,
        context_identifier: String,
        context_type: String,
    ) -> Result<RepresentationContextId, AuthorError> {
        Ok(RepresentationContextId(
            self.model
                .representation_context_arena
                .push(RepresentationContext {
                    context_identifier,
                    context_type,
                }),
        ))
    }

    /// `REPRESENTATION_CONTEXT_REFERENCE` — strict AP242 constructor.
    pub fn add_representation_context_reference(
        &mut self,
        context_identifier: String,
    ) -> Result<RepresentationContextReferenceId, AuthorError> {
        Ok(RepresentationContextReferenceId(
            self.model
                .representation_context_reference_arena
                .push(RepresentationContextReference { context_identifier }),
        ))
    }

    /// `REPRESENTATION_ITEM` — strict AP242 constructor.
    pub fn add_representation_item(
        &mut self,
        name: String,
    ) -> Result<RepresentationItemId, AuthorError> {
        Ok(RepresentationItemId(
            self.model
                .representation_item_arena
                .push(RepresentationItem { name }),
        ))
    }

    /// `REPRESENTATION_MAP` — strict AP242 constructor.
    pub fn add_representation_map(
        &mut self,
        mapping_origin: RepresentationItemRef,
        mapped_representation: RepresentationRef,
    ) -> Result<RepresentationMapId, AuthorError> {
        check_representation_item_ref(&self.model, &mapping_origin)?;
        check_representation_ref(&self.model, &mapped_representation)?;
        Ok(RepresentationMapId(
            self.model.representation_map_arena.push(RepresentationMap {
                mapping_origin,
                mapped_representation,
            }),
        ))
    }

    /// `REPRESENTATION_REFERENCE` — strict AP242 constructor.
    pub fn add_representation_reference(
        &mut self,
        id: String,
        context_of_items: RepresentationContextReferenceRef,
    ) -> Result<RepresentationReferenceId, AuthorError> {
        check_representation_context_reference_ref(&self.model, &context_of_items)?;
        Ok(RepresentationReferenceId(
            self.model
                .representation_reference_arena
                .push(RepresentationReference {
                    id,
                    context_of_items,
                }),
        ))
    }

    /// `REPRESENTATION_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_representation_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        rep_1: RepresentationOrRepresentationReferenceRef,
        rep_2: RepresentationOrRepresentationReferenceRef,
    ) -> Result<RepresentationRelationshipId, AuthorError> {
        check_representation_or_representation_reference_ref(&self.model, &rep_1)?;
        check_representation_or_representation_reference_ref(&self.model, &rep_2)?;
        Ok(RepresentationRelationshipId(
            self.model
                .representation_relationship_arena
                .push(RepresentationRelationship {
                    name,
                    description,
                    rep_1,
                    rep_2,
                }),
        ))
    }

    /// `REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION` — strict AP242 constructor.
    pub fn add_representation_relationship_with_transformation(
        &mut self,
        name: String,
        description: Option<String>,
        rep_1: RepresentationOrRepresentationReferenceRef,
        rep_2: RepresentationOrRepresentationReferenceRef,
        transformation_operator: TransformationRef,
    ) -> Result<RepresentationRelationshipWithTransformationId, AuthorError> {
        check_representation_or_representation_reference_ref(&self.model, &rep_1)?;
        check_representation_or_representation_reference_ref(&self.model, &rep_2)?;
        check_transformation_ref(&self.model, &transformation_operator)?;
        Ok(RepresentationRelationshipWithTransformationId(
            self.model
                .representation_relationship_with_transformation_arena
                .push(RepresentationRelationshipWithTransformation {
                    name,
                    description,
                    rep_1,
                    rep_2,
                    transformation_operator,
                }),
        ))
    }

    /// `RESOURCE_PROPERTY` — strict AP242 constructor.
    pub fn add_resource_property(
        &mut self,
        name: String,
        description: String,
        resource: CharacterizedResourceDefinitionRef,
    ) -> Result<ResourcePropertyId, AuthorError> {
        check_characterized_resource_definition_ref(&self.model, &resource)?;
        Ok(ResourcePropertyId(self.model.resource_property_arena.push(
            ResourceProperty {
                name,
                description,
                resource,
            },
        )))
    }

    /// `RESOURCE_REQUIREMENT_TYPE` — strict AP242 constructor.
    pub fn add_resource_requirement_type(
        &mut self,
        name: String,
        description: String,
    ) -> Result<ResourceRequirementTypeId, AuthorError> {
        Ok(ResourceRequirementTypeId(
            self.model
                .resource_requirement_type_arena
                .push(ResourceRequirementType { name, description }),
        ))
    }

    /// `ROLE_ASSOCIATION` — strict AP242 constructor.
    pub fn add_role_association(
        &mut self,
        role: ObjectRoleRef,
        item_with_role: RoleSelectRef,
    ) -> Result<RoleAssociationId, AuthorError> {
        check_object_role_ref(&self.model, &role)?;
        check_role_select_ref(&self.model, &item_with_role)?;
        Ok(RoleAssociationId(self.model.role_association_arena.push(
            RoleAssociation {
                role,
                item_with_role,
            },
        )))
    }

    /// `ROUNDNESS_TOLERANCE` — strict AP242 constructor.
    pub fn add_roundness_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
    ) -> Result<RoundnessToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        Ok(RoundnessToleranceId(
            self.model
                .roundness_tolerance_arena
                .push(RoundnessTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                }),
        ))
    }

    /// `SEAM_CURVE` — strict AP242 constructor.
    pub fn add_seam_curve(
        &mut self,
        name: String,
        curve_3d: CurveRef,
        associated_geometry: Vec<PcurveOrSurfaceRef>,
        master_representation: PreferredSurfaceCurveRepresentation,
    ) -> Result<SeamCurveId, AuthorError> {
        check_curve_ref(&self.model, &curve_3d)?;
        {
            let x = &associated_geometry;
            if x.len() < 1 || x.len() > 2 {
                return Err(AuthorError::Cardinality {
                    entity: "SEAM_CURVE",
                    attribute: "associated_geometry",
                    got: x.len(),
                    min: 1,
                    max: Some(2),
                });
            }
        }
        for e0 in &associated_geometry {
            check_pcurve_or_surface_ref(&self.model, e0)?;
        }
        Ok(SeamCurveId(self.model.seam_curve_arena.push(SeamCurve {
            name,
            curve_3d,
            associated_geometry,
            master_representation,
        })))
    }

    /// `SECURITY_CLASSIFICATION` — strict AP242 constructor.
    pub fn add_security_classification(
        &mut self,
        name: String,
        purpose: String,
        security_level: SecurityClassificationLevelRef,
    ) -> Result<SecurityClassificationId, AuthorError> {
        check_security_classification_level_ref(&self.model, &security_level)?;
        Ok(SecurityClassificationId(
            self.model
                .security_classification_arena
                .push(SecurityClassification {
                    name,
                    purpose,
                    security_level,
                }),
        ))
    }

    /// `SECURITY_CLASSIFICATION_ASSIGNMENT` — strict AP242 constructor.
    pub fn add_security_classification_assignment(
        &mut self,
        assigned_security_classification: SecurityClassificationRef,
    ) -> Result<SecurityClassificationAssignmentId, AuthorError> {
        check_security_classification_ref(&self.model, &assigned_security_classification)?;
        Ok(SecurityClassificationAssignmentId(
            self.model.security_classification_assignment_arena.push(
                SecurityClassificationAssignment {
                    assigned_security_classification,
                },
            ),
        ))
    }

    /// `SECURITY_CLASSIFICATION_LEVEL` — strict AP242 constructor.
    pub fn add_security_classification_level(
        &mut self,
        name: String,
    ) -> Result<SecurityClassificationLevelId, AuthorError> {
        Ok(SecurityClassificationLevelId(
            self.model
                .security_classification_level_arena
                .push(SecurityClassificationLevel { name }),
        ))
    }

    /// `SHAPE_ASPECT` — strict AP242 constructor.
    pub fn add_shape_aspect(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Option<Logical>,
    ) -> Result<ShapeAspectId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        Ok(ShapeAspectId(self.model.shape_aspect_arena.push(
            ShapeAspect {
                name,
                description,
                of_shape,
                product_definitional,
            },
        )))
    }

    /// `SHAPE_ASPECT_ASSOCIATIVITY` — strict AP242 constructor.
    pub fn add_shape_aspect_associativity(
        &mut self,
        name: String,
        description: Option<String>,
        relating_shape_aspect: ShapeAspectRef,
        related_shape_aspect: ShapeAspectRef,
    ) -> Result<ShapeAspectAssociativityId, AuthorError> {
        check_shape_aspect_ref(&self.model, &relating_shape_aspect)?;
        check_shape_aspect_ref(&self.model, &related_shape_aspect)?;
        Ok(ShapeAspectAssociativityId(
            self.model
                .shape_aspect_associativity_arena
                .push(ShapeAspectAssociativity {
                    name,
                    description,
                    relating_shape_aspect,
                    related_shape_aspect,
                }),
        ))
    }

    /// `SHAPE_ASPECT_DERIVING_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_shape_aspect_deriving_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        relating_shape_aspect: ShapeAspectRef,
        related_shape_aspect: ShapeAspectRef,
    ) -> Result<ShapeAspectDerivingRelationshipId, AuthorError> {
        check_shape_aspect_ref(&self.model, &relating_shape_aspect)?;
        check_shape_aspect_ref(&self.model, &related_shape_aspect)?;
        Ok(ShapeAspectDerivingRelationshipId(
            self.model.shape_aspect_deriving_relationship_arena.push(
                ShapeAspectDerivingRelationship {
                    name,
                    description,
                    relating_shape_aspect,
                    related_shape_aspect,
                },
            ),
        ))
    }

    /// `SHAPE_ASPECT_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_shape_aspect_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        relating_shape_aspect: ShapeAspectRef,
        related_shape_aspect: ShapeAspectRef,
    ) -> Result<ShapeAspectRelationshipId, AuthorError> {
        check_shape_aspect_ref(&self.model, &relating_shape_aspect)?;
        check_shape_aspect_ref(&self.model, &related_shape_aspect)?;
        Ok(ShapeAspectRelationshipId(
            self.model
                .shape_aspect_relationship_arena
                .push(ShapeAspectRelationship {
                    name,
                    description,
                    relating_shape_aspect,
                    related_shape_aspect,
                }),
        ))
    }

    /// `SHAPE_DEFINITION_REPRESENTATION` — strict AP242 constructor.
    pub fn add_shape_definition_representation(
        &mut self,
        definition: RepresentedDefinitionRef,
        used_representation: RepresentationRef,
    ) -> Result<ShapeDefinitionRepresentationId, AuthorError> {
        check_represented_definition_ref(&self.model, &definition)?;
        check_representation_ref(&self.model, &used_representation)?;
        Ok(ShapeDefinitionRepresentationId(
            self.model
                .shape_definition_representation_arena
                .push(ShapeDefinitionRepresentation {
                    definition,
                    used_representation,
                }),
        ))
    }

    /// `SHAPE_DIMENSION_REPRESENTATION` — strict AP242 constructor.
    pub fn add_shape_dimension_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<ShapeDimensionRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(ShapeDimensionRepresentationId(
            self.model
                .shape_dimension_representation_arena
                .push(ShapeDimensionRepresentation {
                    name,
                    items,
                    context_of_items,
                }),
        ))
    }

    /// `SHAPE_REPRESENTATION` — strict AP242 constructor.
    pub fn add_shape_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<ShapeRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "SHAPE_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(ShapeRepresentationId(
            self.model
                .shape_representation_arena
                .push(ShapeRepresentation {
                    name,
                    items,
                    context_of_items,
                }),
        ))
    }

    /// `SHAPE_REPRESENTATION_RELATIONSHIP` — strict AP242 constructor.
    pub fn add_shape_representation_relationship(
        &mut self,
        name: String,
        description: Option<String>,
        rep_1: RepresentationOrRepresentationReferenceRef,
        rep_2: RepresentationOrRepresentationReferenceRef,
    ) -> Result<ShapeRepresentationRelationshipId, AuthorError> {
        check_representation_or_representation_reference_ref(&self.model, &rep_1)?;
        check_representation_or_representation_reference_ref(&self.model, &rep_2)?;
        Ok(ShapeRepresentationRelationshipId(
            self.model.shape_representation_relationship_arena.push(
                ShapeRepresentationRelationship {
                    name,
                    description,
                    rep_1,
                    rep_2,
                },
            ),
        ))
    }

    /// `SHAPE_REPRESENTATION_WITH_PARAMETERS` — strict AP242 constructor.
    pub fn add_shape_representation_with_parameters(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<ShapeRepresentationWithParametersId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(ShapeRepresentationWithParametersId(
            self.model.shape_representation_with_parameters_arena.push(
                ShapeRepresentationWithParameters {
                    name,
                    items,
                    context_of_items,
                },
            ),
        ))
    }

    /// `SHELL_BASED_SURFACE_MODEL` — strict AP242 constructor.
    pub fn add_shell_based_surface_model(
        &mut self,
        name: String,
        sbsm_boundary: Vec<ShellRef>,
    ) -> Result<ShellBasedSurfaceModelId, AuthorError> {
        {
            let x = &sbsm_boundary;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "SHELL_BASED_SURFACE_MODEL",
                    attribute: "sbsm_boundary",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &sbsm_boundary {
            check_shell_ref(&self.model, e0)?;
        }
        Ok(ShellBasedSurfaceModelId(
            self.model
                .shell_based_surface_model_arena
                .push(ShellBasedSurfaceModel {
                    name,
                    sbsm_boundary,
                }),
        ))
    }

    /// `SI_UNIT` — strict AP242 constructor.
    pub fn add_si_unit(
        &mut self,
        prefix: Option<SiPrefix>,
        name: SiUnitName,
    ) -> Result<SiUnitId, AuthorError> {
        Ok(SiUnitId(
            self.model.si_unit_arena.push(SiUnit { prefix, name }),
        ))
    }

    /// `SIMPLE_GENERIC_EXPRESSION` — strict AP242 constructor.
    pub fn add_simple_generic_expression(
        &mut self,
    ) -> Result<SimpleGenericExpressionId, AuthorError> {
        Ok(SimpleGenericExpressionId(
            self.model
                .simple_generic_expression_arena
                .push(SimpleGenericExpression {}),
        ))
    }

    /// `SIMPLE_NUMERIC_EXPRESSION` — strict AP242 constructor.
    pub fn add_simple_numeric_expression(
        &mut self,
    ) -> Result<SimpleNumericExpressionId, AuthorError> {
        Ok(SimpleNumericExpressionId(
            self.model
                .simple_numeric_expression_arena
                .push(SimpleNumericExpression {}),
        ))
    }

    /// `SOLID_ANGLE_UNIT` — strict AP242 constructor.
    pub fn add_solid_angle_unit(
        &mut self,
        dimensions: DimensionalExponentsRef,
    ) -> Result<SolidAngleUnitId, AuthorError> {
        check_dimensional_exponents_ref(&self.model, &dimensions)?;
        Ok(SolidAngleUnitId(
            self.model
                .solid_angle_unit_arena
                .push(SolidAngleUnit { dimensions }),
        ))
    }

    /// `SOLID_MODEL` — strict AP242 constructor.
    pub fn add_solid_model(&mut self, name: String) -> Result<SolidModelId, AuthorError> {
        Ok(SolidModelId(
            self.model.solid_model_arena.push(SolidModel { name }),
        ))
    }

    /// `SPHERICAL_SURFACE` — strict AP242 constructor.
    pub fn add_spherical_surface(
        &mut self,
        name: String,
        position: Axis2Placement3dRef,
        radius: f64,
    ) -> Result<SphericalSurfaceId, AuthorError> {
        check_axis2_placement3d_ref(&self.model, &position)?;
        Ok(SphericalSurfaceId(self.model.spherical_surface_arena.push(
            SphericalSurface {
                name,
                position,
                radius,
            },
        )))
    }

    /// `START_REQUEST` — strict AP242 constructor.
    pub fn add_start_request(
        &mut self,
        assigned_action_request: VersionedActionRequestRef,
        items: Vec<StartRequestItemRef>,
    ) -> Result<StartRequestId, AuthorError> {
        check_versioned_action_request_ref(&self.model, &assigned_action_request)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "START_REQUEST",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_start_request_item_ref(&self.model, e0)?;
        }
        Ok(StartRequestId(self.model.start_request_arena.push(
            StartRequest {
                assigned_action_request,
                items,
            },
        )))
    }

    /// `START_WORK` — strict AP242 constructor.
    pub fn add_start_work(
        &mut self,
        assigned_action: ActionRef,
        items: Vec<WorkItemRef>,
    ) -> Result<StartWorkId, AuthorError> {
        check_action_ref(&self.model, &assigned_action)?;
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "START_WORK",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_work_item_ref(&self.model, e0)?;
        }
        Ok(StartWorkId(self.model.start_work_arena.push(StartWork {
            assigned_action,
            items,
        })))
    }

    /// `STATE_OBSERVED` — strict AP242 constructor.
    pub fn add_state_observed(
        &mut self,
        name: String,
        description: Option<String>,
    ) -> Result<StateObservedId, AuthorError> {
        Ok(StateObservedId(
            self.model
                .state_observed_arena
                .push(StateObserved { name, description }),
        ))
    }

    /// `STATE_TYPE` — strict AP242 constructor.
    pub fn add_state_type(
        &mut self,
        name: String,
        description: Option<String>,
    ) -> Result<StateTypeId, AuthorError> {
        Ok(StateTypeId(
            self.model
                .state_type_arena
                .push(StateType { name, description }),
        ))
    }

    /// `STRAIGHTNESS_TOLERANCE` — strict AP242 constructor.
    pub fn add_straightness_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
    ) -> Result<StraightnessToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        Ok(StraightnessToleranceId(
            self.model
                .straightness_tolerance_arena
                .push(StraightnessTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                }),
        ))
    }

    /// `STYLED_ITEM` — strict AP242 constructor.
    pub fn add_styled_item(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: StyledItemTargetRef,
    ) -> Result<StyledItemId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_styled_item_target_ref(&self.model, &item)?;
        Ok(StyledItemId(
            self.model
                .styled_item_arena
                .push(StyledItem { name, styles, item }),
        ))
    }

    /// `SURFACE` — strict AP242 constructor.
    pub fn add_surface(&mut self, name: String) -> Result<SurfaceId, AuthorError> {
        Ok(SurfaceId(self.model.surface_arena.push(Surface { name })))
    }

    /// `SURFACE_CURVE` — strict AP242 constructor.
    pub fn add_surface_curve(
        &mut self,
        name: String,
        curve_3d: CurveRef,
        associated_geometry: Vec<PcurveOrSurfaceRef>,
        master_representation: PreferredSurfaceCurveRepresentation,
    ) -> Result<SurfaceCurveId, AuthorError> {
        check_curve_ref(&self.model, &curve_3d)?;
        {
            let x = &associated_geometry;
            if x.len() < 1 || x.len() > 2 {
                return Err(AuthorError::Cardinality {
                    entity: "SURFACE_CURVE",
                    attribute: "associated_geometry",
                    got: x.len(),
                    min: 1,
                    max: Some(2),
                });
            }
        }
        for e0 in &associated_geometry {
            check_pcurve_or_surface_ref(&self.model, e0)?;
        }
        Ok(SurfaceCurveId(self.model.surface_curve_arena.push(
            SurfaceCurve {
                name,
                curve_3d,
                associated_geometry,
                master_representation,
            },
        )))
    }

    /// `SURFACE_OF_LINEAR_EXTRUSION` — strict AP242 constructor.
    pub fn add_surface_of_linear_extrusion(
        &mut self,
        name: String,
        swept_curve: CurveRef,
        extrusion_axis: VectorRef,
    ) -> Result<SurfaceOfLinearExtrusionId, AuthorError> {
        check_curve_ref(&self.model, &swept_curve)?;
        check_vector_ref(&self.model, &extrusion_axis)?;
        Ok(SurfaceOfLinearExtrusionId(
            self.model
                .surface_of_linear_extrusion_arena
                .push(SurfaceOfLinearExtrusion {
                    name,
                    swept_curve,
                    extrusion_axis,
                }),
        ))
    }

    /// `SURFACE_OF_REVOLUTION` — strict AP242 constructor.
    pub fn add_surface_of_revolution(
        &mut self,
        name: String,
        swept_curve: CurveRef,
        axis_position: Axis1PlacementRef,
    ) -> Result<SurfaceOfRevolutionId, AuthorError> {
        check_curve_ref(&self.model, &swept_curve)?;
        check_axis1_placement_ref(&self.model, &axis_position)?;
        Ok(SurfaceOfRevolutionId(
            self.model
                .surface_of_revolution_arena
                .push(SurfaceOfRevolution {
                    name,
                    swept_curve,
                    axis_position,
                }),
        ))
    }

    /// `SURFACE_PROFILE_TOLERANCE` — strict AP242 constructor.
    pub fn add_surface_profile_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
    ) -> Result<SurfaceProfileToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        Ok(SurfaceProfileToleranceId(
            self.model
                .surface_profile_tolerance_arena
                .push(SurfaceProfileTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                }),
        ))
    }

    /// `SURFACE_RENDERING_PROPERTIES` — strict AP242 constructor.
    pub fn add_surface_rendering_properties(
        &mut self,
        rendered_colour: ColourRef,
    ) -> Result<SurfaceRenderingPropertiesId, AuthorError> {
        check_colour_ref(&self.model, &rendered_colour)?;
        Ok(SurfaceRenderingPropertiesId(
            self.model
                .surface_rendering_properties_arena
                .push(SurfaceRenderingProperties { rendered_colour }),
        ))
    }

    /// `SURFACE_SIDE_STYLE` — strict AP242 constructor.
    pub fn add_surface_side_style(
        &mut self,
        name: String,
        styles: Vec<SurfaceStyleElementSelectRef>,
    ) -> Result<SurfaceSideStyleId, AuthorError> {
        {
            let x = &styles;
            if x.len() < 1 || x.len() > 7 {
                return Err(AuthorError::Cardinality {
                    entity: "SURFACE_SIDE_STYLE",
                    attribute: "styles",
                    got: x.len(),
                    min: 1,
                    max: Some(7),
                });
            }
        }
        for e0 in &styles {
            check_surface_style_element_select_ref(&self.model, e0)?;
        }
        Ok(SurfaceSideStyleId(
            self.model
                .surface_side_style_arena
                .push(SurfaceSideStyle { name, styles }),
        ))
    }

    /// `SURFACE_STYLE_BOUNDARY` — strict AP242 constructor.
    pub fn add_surface_style_boundary(
        &mut self,
        style_of_boundary: CurveOrRenderRef,
    ) -> Result<SurfaceStyleBoundaryId, AuthorError> {
        check_curve_or_render_ref(&self.model, &style_of_boundary)?;
        Ok(SurfaceStyleBoundaryId(
            self.model
                .surface_style_boundary_arena
                .push(SurfaceStyleBoundary { style_of_boundary }),
        ))
    }

    /// `SURFACE_STYLE_CONTROL_GRID` — strict AP242 constructor.
    pub fn add_surface_style_control_grid(
        &mut self,
        style_of_control_grid: CurveOrRenderRef,
    ) -> Result<SurfaceStyleControlGridId, AuthorError> {
        check_curve_or_render_ref(&self.model, &style_of_control_grid)?;
        Ok(SurfaceStyleControlGridId(
            self.model
                .surface_style_control_grid_arena
                .push(SurfaceStyleControlGrid {
                    style_of_control_grid,
                }),
        ))
    }

    /// `SURFACE_STYLE_FILL_AREA` — strict AP242 constructor.
    pub fn add_surface_style_fill_area(
        &mut self,
        fill_area: FillAreaStyleRef,
    ) -> Result<SurfaceStyleFillAreaId, AuthorError> {
        check_fill_area_style_ref(&self.model, &fill_area)?;
        Ok(SurfaceStyleFillAreaId(
            self.model
                .surface_style_fill_area_arena
                .push(SurfaceStyleFillArea { fill_area }),
        ))
    }

    /// `SURFACE_STYLE_PARAMETER_LINE` — strict AP242 constructor.
    pub fn add_surface_style_parameter_line(
        &mut self,
        style_of_parameter_lines: CurveOrRenderRef,
        direction_counts: Vec<IntMeasureValue>,
    ) -> Result<SurfaceStyleParameterLineId, AuthorError> {
        check_curve_or_render_ref(&self.model, &style_of_parameter_lines)?;
        {
            let x = &direction_counts;
            if x.len() < 1 || x.len() > 2 {
                return Err(AuthorError::Cardinality {
                    entity: "SURFACE_STYLE_PARAMETER_LINE",
                    attribute: "direction_counts",
                    got: x.len(),
                    min: 1,
                    max: Some(2),
                });
            }
        }
        Ok(SurfaceStyleParameterLineId(
            self.model
                .surface_style_parameter_line_arena
                .push(SurfaceStyleParameterLine {
                    style_of_parameter_lines,
                    direction_counts,
                }),
        ))
    }

    /// `SURFACE_STYLE_REFLECTANCE_AMBIENT` — strict AP242 constructor.
    pub fn add_surface_style_reflectance_ambient(
        &mut self,
        ambient_reflectance: f64,
    ) -> Result<SurfaceStyleReflectanceAmbientId, AuthorError> {
        Ok(SurfaceStyleReflectanceAmbientId(
            self.model.surface_style_reflectance_ambient_arena.push(
                SurfaceStyleReflectanceAmbient {
                    ambient_reflectance,
                },
            ),
        ))
    }

    /// `SURFACE_STYLE_RENDERING` — strict AP242 constructor.
    pub fn add_surface_style_rendering(
        &mut self,
        rendering_method: ShadingSurfaceMethod,
        surface_colour: ColourRef,
    ) -> Result<SurfaceStyleRenderingId, AuthorError> {
        check_colour_ref(&self.model, &surface_colour)?;
        Ok(SurfaceStyleRenderingId(
            self.model
                .surface_style_rendering_arena
                .push(SurfaceStyleRendering {
                    rendering_method,
                    surface_colour,
                }),
        ))
    }

    /// `SURFACE_STYLE_RENDERING_WITH_PROPERTIES` — strict AP242 constructor.
    pub fn add_surface_style_rendering_with_properties(
        &mut self,
        rendering_method: ShadingSurfaceMethod,
        surface_colour: ColourRef,
        properties: Vec<RenderingPropertiesSelectRef>,
    ) -> Result<SurfaceStyleRenderingWithPropertiesId, AuthorError> {
        check_colour_ref(&self.model, &surface_colour)?;
        {
            let x = &properties;
            if x.len() < 1 || x.len() > 2 {
                return Err(AuthorError::Cardinality {
                    entity: "SURFACE_STYLE_RENDERING_WITH_PROPERTIES",
                    attribute: "properties",
                    got: x.len(),
                    min: 1,
                    max: Some(2),
                });
            }
        }
        for e0 in &properties {
            check_rendering_properties_select_ref(&self.model, e0)?;
        }
        Ok(SurfaceStyleRenderingWithPropertiesId(
            self.model
                .surface_style_rendering_with_properties_arena
                .push(SurfaceStyleRenderingWithProperties {
                    rendering_method,
                    surface_colour,
                    properties,
                }),
        ))
    }

    /// `SURFACE_STYLE_SEGMENTATION_CURVE` — strict AP242 constructor.
    pub fn add_surface_style_segmentation_curve(
        &mut self,
        style_of_segmentation_curve: CurveOrRenderRef,
    ) -> Result<SurfaceStyleSegmentationCurveId, AuthorError> {
        check_curve_or_render_ref(&self.model, &style_of_segmentation_curve)?;
        Ok(SurfaceStyleSegmentationCurveId(
            self.model
                .surface_style_segmentation_curve_arena
                .push(SurfaceStyleSegmentationCurve {
                    style_of_segmentation_curve,
                }),
        ))
    }

    /// `SURFACE_STYLE_SILHOUETTE` — strict AP242 constructor.
    pub fn add_surface_style_silhouette(
        &mut self,
        style_of_silhouette: CurveOrRenderRef,
    ) -> Result<SurfaceStyleSilhouetteId, AuthorError> {
        check_curve_or_render_ref(&self.model, &style_of_silhouette)?;
        Ok(SurfaceStyleSilhouetteId(
            self.model
                .surface_style_silhouette_arena
                .push(SurfaceStyleSilhouette {
                    style_of_silhouette,
                }),
        ))
    }

    /// `SURFACE_STYLE_TRANSPARENT` — strict AP242 constructor.
    pub fn add_surface_style_transparent(
        &mut self,
        transparency: f64,
    ) -> Result<SurfaceStyleTransparentId, AuthorError> {
        Ok(SurfaceStyleTransparentId(
            self.model
                .surface_style_transparent_arena
                .push(SurfaceStyleTransparent { transparency }),
        ))
    }

    /// `SURFACE_STYLE_USAGE` — strict AP242 constructor.
    pub fn add_surface_style_usage(
        &mut self,
        side: SurfaceSide,
        style: SurfaceSideStyleSelectRef,
    ) -> Result<SurfaceStyleUsageId, AuthorError> {
        check_surface_side_style_select_ref(&self.model, &style)?;
        Ok(SurfaceStyleUsageId(
            self.model
                .surface_style_usage_arena
                .push(SurfaceStyleUsage { side, style }),
        ))
    }

    /// `SWEPT_SURFACE` — strict AP242 constructor.
    pub fn add_swept_surface(
        &mut self,
        name: String,
        swept_curve: CurveRef,
    ) -> Result<SweptSurfaceId, AuthorError> {
        check_curve_ref(&self.model, &swept_curve)?;
        Ok(SweptSurfaceId(
            self.model
                .swept_surface_arena
                .push(SweptSurface { name, swept_curve }),
        ))
    }

    /// `SYMBOL_COLOUR` — strict AP242 constructor.
    pub fn add_symbol_colour(
        &mut self,
        colour_of_symbol: ColourRef,
    ) -> Result<SymbolColourId, AuthorError> {
        check_colour_ref(&self.model, &colour_of_symbol)?;
        Ok(SymbolColourId(
            self.model
                .symbol_colour_arena
                .push(SymbolColour { colour_of_symbol }),
        ))
    }

    /// `SYMBOL_REPRESENTATION` — strict AP242 constructor.
    pub fn add_symbol_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<SymbolRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "SYMBOL_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(SymbolRepresentationId(
            self.model
                .symbol_representation_arena
                .push(SymbolRepresentation {
                    name,
                    items,
                    context_of_items,
                }),
        ))
    }

    /// `SYMBOL_STYLE` — strict AP242 constructor.
    pub fn add_symbol_style(
        &mut self,
        name: String,
        style_of_symbol: SymbolStyleSelectRef,
    ) -> Result<SymbolStyleId, AuthorError> {
        check_symbol_style_select_ref(&self.model, &style_of_symbol)?;
        Ok(SymbolStyleId(self.model.symbol_style_arena.push(
            SymbolStyle {
                name,
                style_of_symbol,
            },
        )))
    }

    /// `SYMBOL_TARGET` — strict AP242 constructor.
    pub fn add_symbol_target(
        &mut self,
        name: String,
        placement: Axis2PlacementRef,
        x_scale: f64,
        y_scale: f64,
    ) -> Result<SymbolTargetId, AuthorError> {
        check_axis2_placement_ref(&self.model, &placement)?;
        Ok(SymbolTargetId(self.model.symbol_target_arena.push(
            SymbolTarget {
                name,
                placement,
                x_scale,
                y_scale,
            },
        )))
    }

    /// `SYMMETRY_TOLERANCE` — strict AP242 constructor.
    pub fn add_symmetry_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        datum_system: Vec<DatumSystemOrReferenceRef>,
    ) -> Result<SymmetryToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        {
            let x = &datum_system;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "SYMMETRY_TOLERANCE",
                    attribute: "datum_system",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &datum_system {
            check_datum_system_or_reference_ref(&self.model, e0)?;
        }
        Ok(SymmetryToleranceId(
            self.model.symmetry_tolerance_arena.push(SymmetryTolerance {
                name,
                description,
                magnitude,
                toleranced_shape_aspect,
                datum_system,
            }),
        ))
    }

    /// `TERMINATOR_SYMBOL` — strict AP242 constructor.
    pub fn add_terminator_symbol(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: AnnotationSymbolOccurrenceItemRef,
        annotated_curve: AnnotationCurveOccurrenceRef,
    ) -> Result<TerminatorSymbolId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_annotation_symbol_occurrence_item_ref(&self.model, &item)?;
        check_annotation_curve_occurrence_ref(&self.model, &annotated_curve)?;
        Ok(TerminatorSymbolId(self.model.terminator_symbol_arena.push(
            TerminatorSymbol {
                name,
                styles,
                item,
                annotated_curve,
            },
        )))
    }

    /// `TESSELLATED_ANNOTATION_OCCURRENCE` — strict AP242 constructor.
    pub fn add_tessellated_annotation_occurrence(
        &mut self,
        name: String,
        styles: Vec<PresentationStyleAssignmentRef>,
        item: StyledItemTargetRef,
    ) -> Result<TessellatedAnnotationOccurrenceId, AuthorError> {
        for e0 in &styles {
            check_presentation_style_assignment_ref(&self.model, e0)?;
        }
        check_styled_item_target_ref(&self.model, &item)?;
        Ok(TessellatedAnnotationOccurrenceId(
            self.model
                .tessellated_annotation_occurrence_arena
                .push(TessellatedAnnotationOccurrence { name, styles, item }),
        ))
    }

    /// `TESSELLATED_CURVE_SET` — strict AP242 constructor.
    pub fn add_tessellated_curve_set(
        &mut self,
        name: String,
        coordinates: CoordinatesListRef,
        line_strips: Vec<Vec<i64>>,
    ) -> Result<TessellatedCurveSetId, AuthorError> {
        check_coordinates_list_ref(&self.model, &coordinates)?;
        {
            let x = &line_strips;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "TESSELLATED_CURVE_SET",
                    attribute: "line_strips",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        Ok(TessellatedCurveSetId(
            self.model
                .tessellated_curve_set_arena
                .push(TessellatedCurveSet {
                    name,
                    coordinates,
                    line_strips,
                }),
        ))
    }

    /// `TESSELLATED_FACE` — strict AP242 constructor.
    pub fn add_tessellated_face(
        &mut self,
        name: String,
        coordinates: CoordinatesListRef,
        pnmax: i64,
        normals: Vec<Vec<f64>>,
        geometric_link: Option<FaceOrSurfaceRef>,
    ) -> Result<TessellatedFaceId, AuthorError> {
        check_coordinates_list_ref(&self.model, &coordinates)?;
        if let Some(x) = &geometric_link {
            check_face_or_surface_ref(&self.model, x)?;
        }
        Ok(TessellatedFaceId(self.model.tessellated_face_arena.push(
            TessellatedFace {
                name,
                coordinates,
                pnmax,
                normals,
                geometric_link,
            },
        )))
    }

    /// `TESSELLATED_GEOMETRIC_SET` — strict AP242 constructor.
    pub fn add_tessellated_geometric_set(
        &mut self,
        name: String,
        children: Vec<TessellatedItemRef>,
    ) -> Result<TessellatedGeometricSetId, AuthorError> {
        {
            let x = &children;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                    attribute: "children",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &children {
            check_tessellated_item_ref(&self.model, e0)?;
        }
        Ok(TessellatedGeometricSetId(
            self.model
                .tessellated_geometric_set_arena
                .push(TessellatedGeometricSet { name, children }),
        ))
    }

    /// `TESSELLATED_ITEM` — strict AP242 constructor.
    pub fn add_tessellated_item(&mut self, name: String) -> Result<TessellatedItemId, AuthorError> {
        Ok(TessellatedItemId(
            self.model
                .tessellated_item_arena
                .push(TessellatedItem { name }),
        ))
    }

    /// `TESSELLATED_SHAPE_REPRESENTATION` — strict AP242 constructor.
    pub fn add_tessellated_shape_representation(
        &mut self,
        name: String,
        items: Vec<RepresentationItemRef>,
        context_of_items: RepresentationContextRef,
    ) -> Result<TessellatedShapeRepresentationId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_representation_item_ref(&self.model, e0)?;
        }
        check_representation_context_ref(&self.model, &context_of_items)?;
        Ok(TessellatedShapeRepresentationId(
            self.model.tessellated_shape_representation_arena.push(
                TessellatedShapeRepresentation {
                    name,
                    items,
                    context_of_items,
                },
            ),
        ))
    }

    /// `TESSELLATED_SHELL` — strict AP242 constructor.
    pub fn add_tessellated_shell(
        &mut self,
        name: String,
        items: Vec<TessellatedStructuredItemRef>,
        topological_link: Option<ConnectedFaceSetRef>,
    ) -> Result<TessellatedShellId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "TESSELLATED_SHELL",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_tessellated_structured_item_ref(&self.model, e0)?;
        }
        if let Some(x) = &topological_link {
            check_connected_face_set_ref(&self.model, x)?;
        }
        Ok(TessellatedShellId(self.model.tessellated_shell_arena.push(
            TessellatedShell {
                name,
                items,
                topological_link,
            },
        )))
    }

    /// `TESSELLATED_SOLID` — strict AP242 constructor.
    pub fn add_tessellated_solid(
        &mut self,
        name: String,
        items: Vec<TessellatedStructuredItemRef>,
        geometric_link: Option<ManifoldSolidBrepRef>,
    ) -> Result<TessellatedSolidId, AuthorError> {
        {
            let x = &items;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "TESSELLATED_SOLID",
                    attribute: "items",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &items {
            check_tessellated_structured_item_ref(&self.model, e0)?;
        }
        if let Some(x) = &geometric_link {
            check_manifold_solid_brep_ref(&self.model, x)?;
        }
        Ok(TessellatedSolidId(self.model.tessellated_solid_arena.push(
            TessellatedSolid {
                name,
                items,
                geometric_link,
            },
        )))
    }

    /// `TESSELLATED_STRUCTURED_ITEM` — strict AP242 constructor.
    pub fn add_tessellated_structured_item(
        &mut self,
        name: String,
    ) -> Result<TessellatedStructuredItemId, AuthorError> {
        Ok(TessellatedStructuredItemId(
            self.model
                .tessellated_structured_item_arena
                .push(TessellatedStructuredItem { name }),
        ))
    }

    /// `TESSELLATED_SURFACE_SET` — strict AP242 constructor.
    pub fn add_tessellated_surface_set(
        &mut self,
        name: String,
        coordinates: CoordinatesListRef,
        pnmax: i64,
        normals: Vec<Vec<f64>>,
    ) -> Result<TessellatedSurfaceSetId, AuthorError> {
        check_coordinates_list_ref(&self.model, &coordinates)?;
        Ok(TessellatedSurfaceSetId(
            self.model
                .tessellated_surface_set_arena
                .push(TessellatedSurfaceSet {
                    name,
                    coordinates,
                    pnmax,
                    normals,
                }),
        ))
    }

    /// `TEXT_FONT` — strict AP242 constructor.
    pub fn add_text_font(
        &mut self,
        id: String,
        name: String,
        description: String,
    ) -> Result<TextFontId, AuthorError> {
        Ok(TextFontId(self.model.text_font_arena.push(TextFont {
            id,
            name,
            description,
        })))
    }

    /// `TEXT_LITERAL` — strict AP242 constructor.
    pub fn add_text_literal(
        &mut self,
        name: String,
        literal: String,
        placement: Axis2PlacementRef,
        alignment: String,
        path: TextPath,
        font: FontSelectRef,
    ) -> Result<TextLiteralId, AuthorError> {
        check_axis2_placement_ref(&self.model, &placement)?;
        check_font_select_ref(&self.model, &font)?;
        Ok(TextLiteralId(self.model.text_literal_arena.push(
            TextLiteral {
                name,
                literal,
                placement,
                alignment,
                path,
                font,
            },
        )))
    }

    /// `TEXT_STYLE` — strict AP242 constructor.
    pub fn add_text_style(
        &mut self,
        name: String,
        character_appearance: CharacterStyleSelectRef,
    ) -> Result<TextStyleId, AuthorError> {
        check_character_style_select_ref(&self.model, &character_appearance)?;
        Ok(TextStyleId(self.model.text_style_arena.push(TextStyle {
            name,
            character_appearance,
        })))
    }

    /// `TEXT_STYLE_FOR_DEFINED_FONT` — strict AP242 constructor.
    pub fn add_text_style_for_defined_font(
        &mut self,
        text_colour: ColourRef,
    ) -> Result<TextStyleForDefinedFontId, AuthorError> {
        check_colour_ref(&self.model, &text_colour)?;
        Ok(TextStyleForDefinedFontId(
            self.model
                .text_style_for_defined_font_arena
                .push(TextStyleForDefinedFont { text_colour }),
        ))
    }

    /// `TEXT_STYLE_WITH_BOX_CHARACTERISTICS` — strict AP242 constructor.
    pub fn add_text_style_with_box_characteristics(
        &mut self,
        name: String,
        character_appearance: CharacterStyleSelectRef,
        characteristics: Vec<MeasureValue>,
    ) -> Result<TextStyleWithBoxCharacteristicsId, AuthorError> {
        check_character_style_select_ref(&self.model, &character_appearance)?;
        {
            let x = &characteristics;
            if x.len() < 1 || x.len() > 4 {
                return Err(AuthorError::Cardinality {
                    entity: "TEXT_STYLE_WITH_BOX_CHARACTERISTICS",
                    attribute: "characteristics",
                    got: x.len(),
                    min: 1,
                    max: Some(4),
                });
            }
        }
        Ok(TextStyleWithBoxCharacteristicsId(
            self.model.text_style_with_box_characteristics_arena.push(
                TextStyleWithBoxCharacteristics {
                    name,
                    character_appearance,
                    characteristics,
                },
            ),
        ))
    }

    /// `TEXTURE_STYLE_SPECIFICATION` — strict AP242 constructor.
    pub fn add_texture_style_specification(
        &mut self,
    ) -> Result<TextureStyleSpecificationId, AuthorError> {
        Ok(TextureStyleSpecificationId(
            self.model
                .texture_style_specification_arena
                .push(TextureStyleSpecification {}),
        ))
    }

    /// `TEXTURE_STYLE_TESSELLATION_SPECIFICATION` — strict AP242 constructor.
    pub fn add_texture_style_tessellation_specification(
        &mut self,
    ) -> Result<TextureStyleTessellationSpecificationId, AuthorError> {
        Ok(TextureStyleTessellationSpecificationId(
            self.model
                .texture_style_tessellation_specification_arena
                .push(TextureStyleTessellationSpecification {}),
        ))
    }

    /// `TIME_UNIT` — strict AP242 constructor.
    pub fn add_time_unit(
        &mut self,
        dimensions: DimensionalExponentsRef,
    ) -> Result<TimeUnitId, AuthorError> {
        check_dimensional_exponents_ref(&self.model, &dimensions)?;
        Ok(TimeUnitId(
            self.model.time_unit_arena.push(TimeUnit { dimensions }),
        ))
    }

    /// `TOLERANCE_VALUE` — strict AP242 constructor.
    pub fn add_tolerance_value(
        &mut self,
        lower_bound: MeasureWithUnitRef,
        upper_bound: MeasureWithUnitRef,
    ) -> Result<ToleranceValueId, AuthorError> {
        check_measure_with_unit_ref(&self.model, &lower_bound)?;
        check_measure_with_unit_ref(&self.model, &upper_bound)?;
        Ok(ToleranceValueId(self.model.tolerance_value_arena.push(
            ToleranceValue {
                lower_bound,
                upper_bound,
            },
        )))
    }

    /// `TOLERANCE_ZONE` — strict AP242 constructor.
    pub fn add_tolerance_zone(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
        defining_tolerance: Vec<ToleranceZoneTargetRef>,
        form: ToleranceZoneFormRef,
    ) -> Result<ToleranceZoneId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        {
            let x = &defining_tolerance;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "TOLERANCE_ZONE",
                    attribute: "defining_tolerance",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &defining_tolerance {
            check_tolerance_zone_target_ref(&self.model, e0)?;
        }
        check_tolerance_zone_form_ref(&self.model, &form)?;
        Ok(ToleranceZoneId(self.model.tolerance_zone_arena.push(
            ToleranceZone {
                name,
                description,
                of_shape,
                product_definitional,
                defining_tolerance,
                form,
            },
        )))
    }

    /// `TOLERANCE_ZONE_DEFINITION` — strict AP242 constructor.
    pub fn add_tolerance_zone_definition(
        &mut self,
        zone: ToleranceZoneRef,
        boundaries: Vec<ShapeAspectRef>,
    ) -> Result<ToleranceZoneDefinitionId, AuthorError> {
        check_tolerance_zone_ref(&self.model, &zone)?;
        for e0 in &boundaries {
            check_shape_aspect_ref(&self.model, e0)?;
        }
        Ok(ToleranceZoneDefinitionId(
            self.model
                .tolerance_zone_definition_arena
                .push(ToleranceZoneDefinition { zone, boundaries }),
        ))
    }

    /// `TOLERANCE_ZONE_FORM` — strict AP242 constructor.
    pub fn add_tolerance_zone_form(
        &mut self,
        name: String,
    ) -> Result<ToleranceZoneFormId, AuthorError> {
        Ok(ToleranceZoneFormId(
            self.model
                .tolerance_zone_form_arena
                .push(ToleranceZoneForm { name }),
        ))
    }

    /// `TOLERANCE_ZONE_WITH_DATUM` — strict AP242 constructor.
    pub fn add_tolerance_zone_with_datum(
        &mut self,
        name: String,
        description: Option<String>,
        of_shape: ProductDefinitionShapeRef,
        product_definitional: Logical,
        defining_tolerance: Vec<ToleranceZoneTargetRef>,
        form: ToleranceZoneFormRef,
        datum_reference: DatumSystemRef,
    ) -> Result<ToleranceZoneWithDatumId, AuthorError> {
        check_product_definition_shape_ref(&self.model, &of_shape)?;
        {
            let x = &defining_tolerance;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                    attribute: "defining_tolerance",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &defining_tolerance {
            check_tolerance_zone_target_ref(&self.model, e0)?;
        }
        check_tolerance_zone_form_ref(&self.model, &form)?;
        check_datum_system_ref(&self.model, &datum_reference)?;
        Ok(ToleranceZoneWithDatumId(
            self.model
                .tolerance_zone_with_datum_arena
                .push(ToleranceZoneWithDatum {
                    name,
                    description,
                    of_shape,
                    product_definitional,
                    defining_tolerance,
                    form,
                    datum_reference,
                }),
        ))
    }

    /// `TOPOLOGICAL_REPRESENTATION_ITEM` — strict AP242 constructor.
    pub fn add_topological_representation_item(
        &mut self,
        name: String,
    ) -> Result<TopologicalRepresentationItemId, AuthorError> {
        Ok(TopologicalRepresentationItemId(
            self.model
                .topological_representation_item_arena
                .push(TopologicalRepresentationItem { name }),
        ))
    }

    /// `TOROIDAL_SURFACE` — strict AP242 constructor.
    pub fn add_toroidal_surface(
        &mut self,
        name: String,
        position: Axis2Placement3dRef,
        major_radius: f64,
        minor_radius: f64,
    ) -> Result<ToroidalSurfaceId, AuthorError> {
        check_axis2_placement3d_ref(&self.model, &position)?;
        Ok(ToroidalSurfaceId(self.model.toroidal_surface_arena.push(
            ToroidalSurface {
                name,
                position,
                major_radius,
                minor_radius,
            },
        )))
    }

    /// `TOTAL_RUNOUT_TOLERANCE` — strict AP242 constructor.
    pub fn add_total_runout_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        datum_system: Vec<DatumSystemOrReferenceRef>,
    ) -> Result<TotalRunoutToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        {
            let x = &datum_system;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "TOTAL_RUNOUT_TOLERANCE",
                    attribute: "datum_system",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &datum_system {
            check_datum_system_or_reference_ref(&self.model, e0)?;
        }
        Ok(TotalRunoutToleranceId(
            self.model
                .total_runout_tolerance_arena
                .push(TotalRunoutTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    datum_system,
                }),
        ))
    }

    /// `TRIMMED_CURVE` — strict AP242 constructor.
    pub fn add_trimmed_curve(
        &mut self,
        name: String,
        basis_curve: CurveRef,
        trim_1: Vec<TrimmingSelectRef>,
        trim_2: Vec<TrimmingSelectRef>,
        sense_agreement: bool,
        master_representation: TrimmingPreference,
    ) -> Result<TrimmedCurveId, AuthorError> {
        check_curve_ref(&self.model, &basis_curve)?;
        {
            let x = &trim_1;
            if x.len() < 1 || x.len() > 2 {
                return Err(AuthorError::Cardinality {
                    entity: "TRIMMED_CURVE",
                    attribute: "trim_1",
                    got: x.len(),
                    min: 1,
                    max: Some(2),
                });
            }
        }
        for e0 in &trim_1 {
            check_trimming_select_ref(&self.model, e0)?;
        }
        {
            let x = &trim_2;
            if x.len() < 1 || x.len() > 2 {
                return Err(AuthorError::Cardinality {
                    entity: "TRIMMED_CURVE",
                    attribute: "trim_2",
                    got: x.len(),
                    min: 1,
                    max: Some(2),
                });
            }
        }
        for e0 in &trim_2 {
            check_trimming_select_ref(&self.model, e0)?;
        }
        Ok(TrimmedCurveId(self.model.trimmed_curve_arena.push(
            TrimmedCurve {
                name,
                basis_curve,
                trim_1,
                trim_2,
                sense_agreement,
                master_representation,
            },
        )))
    }

    /// `TWO_DIRECTION_REPEAT_FACTOR` — strict AP242 constructor.
    pub fn add_two_direction_repeat_factor(
        &mut self,
        name: String,
        repeat_factor: VectorRef,
        second_repeat_factor: VectorRef,
    ) -> Result<TwoDirectionRepeatFactorId, AuthorError> {
        check_vector_ref(&self.model, &repeat_factor)?;
        check_vector_ref(&self.model, &second_repeat_factor)?;
        Ok(TwoDirectionRepeatFactorId(
            self.model
                .two_direction_repeat_factor_arena
                .push(TwoDirectionRepeatFactor {
                    name,
                    repeat_factor,
                    second_repeat_factor,
                }),
        ))
    }

    /// `TYPE_QUALIFIER` — strict AP242 constructor.
    pub fn add_type_qualifier(&mut self, name: String) -> Result<TypeQualifierId, AuthorError> {
        Ok(TypeQualifierId(
            self.model.type_qualifier_arena.push(TypeQualifier { name }),
        ))
    }

    /// `UNCERTAINTY_MEASURE_WITH_UNIT` — strict AP242 constructor.
    pub fn add_uncertainty_measure_with_unit(
        &mut self,
        value_component: MeasureValue,
        unit_component: UnitRef,
        name: String,
        description: Option<String>,
    ) -> Result<UncertaintyMeasureWithUnitId, AuthorError> {
        check_unit_ref(&self.model, &unit_component)?;
        Ok(UncertaintyMeasureWithUnitId(
            self.model
                .uncertainty_measure_with_unit_arena
                .push(UncertaintyMeasureWithUnit {
                    value_component,
                    unit_component,
                    name,
                    description,
                }),
        ))
    }

    /// `UNCERTAINTY_QUALIFIER` — strict AP242 constructor.
    pub fn add_uncertainty_qualifier(
        &mut self,
        measure_name: String,
        description: String,
    ) -> Result<UncertaintyQualifierId, AuthorError> {
        Ok(UncertaintyQualifierId(
            self.model
                .uncertainty_qualifier_arena
                .push(UncertaintyQualifier {
                    measure_name,
                    description,
                }),
        ))
    }

    /// `UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE` — strict AP242 constructor.
    pub fn add_unequally_disposed_geometric_tolerance(
        &mut self,
        name: String,
        description: Option<String>,
        magnitude: Option<LengthMeasureWithUnitRef>,
        toleranced_shape_aspect: GeometricToleranceTargetRef,
        displacement: LengthMeasureWithUnitRef,
    ) -> Result<UnequallyDisposedGeometricToleranceId, AuthorError> {
        if let Some(x) = &magnitude {
            check_length_measure_with_unit_ref(&self.model, x)?;
        }
        check_geometric_tolerance_target_ref(&self.model, &toleranced_shape_aspect)?;
        check_length_measure_with_unit_ref(&self.model, &displacement)?;
        Ok(UnequallyDisposedGeometricToleranceId(
            self.model
                .unequally_disposed_geometric_tolerance_arena
                .push(UnequallyDisposedGeometricTolerance {
                    name,
                    description,
                    magnitude,
                    toleranced_shape_aspect,
                    displacement,
                }),
        ))
    }

    /// `UNIFORM_CURVE` — strict AP242 constructor.
    pub fn add_uniform_curve(
        &mut self,
        name: String,
        degree: i64,
        control_points_list: Vec<CartesianPointRef>,
        curve_form: BSplineCurveForm,
        closed_curve: Logical,
        self_intersect: Logical,
    ) -> Result<UniformCurveId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "UNIFORM_CURVE",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            check_cartesian_point_ref(&self.model, e0)?;
        }
        Ok(UniformCurveId(self.model.uniform_curve_arena.push(
            UniformCurve {
                name,
                degree,
                control_points_list,
                curve_form,
                closed_curve,
                self_intersect,
            },
        )))
    }

    /// `UNIFORM_SURFACE` — strict AP242 constructor.
    pub fn add_uniform_surface(
        &mut self,
        name: String,
        u_degree: i64,
        v_degree: i64,
        control_points_list: Vec<Vec<CartesianPointRef>>,
        surface_form: BSplineSurfaceForm,
        u_closed: Logical,
        v_closed: Logical,
        self_intersect: Logical,
    ) -> Result<UniformSurfaceId, AuthorError> {
        {
            let x = &control_points_list;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "UNIFORM_SURFACE",
                    attribute: "control_points_list",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        for e0 in &control_points_list {
            for e1 in e0 {
                check_cartesian_point_ref(&self.model, e1)?;
            }
        }
        Ok(UniformSurfaceId(self.model.uniform_surface_arena.push(
            UniformSurface {
                name,
                u_degree,
                v_degree,
                control_points_list,
                surface_form,
                u_closed,
                v_closed,
                self_intersect,
            },
        )))
    }

    /// `VALUE_FORMAT_TYPE_QUALIFIER` — strict AP242 constructor.
    pub fn add_value_format_type_qualifier(
        &mut self,
        format_type: String,
    ) -> Result<ValueFormatTypeQualifierId, AuthorError> {
        Ok(ValueFormatTypeQualifierId(
            self.model
                .value_format_type_qualifier_arena
                .push(ValueFormatTypeQualifier { format_type }),
        ))
    }

    /// `VALUE_REPRESENTATION_ITEM` — strict AP242 constructor.
    pub fn add_value_representation_item(
        &mut self,
        name: String,
        value_component: MeasureValue,
    ) -> Result<ValueRepresentationItemId, AuthorError> {
        Ok(ValueRepresentationItemId(
            self.model
                .value_representation_item_arena
                .push(ValueRepresentationItem {
                    name,
                    value_component,
                }),
        ))
    }

    /// `VECTOR` — strict AP242 constructor.
    pub fn add_vector(
        &mut self,
        name: String,
        orientation: DirectionRef,
        magnitude: f64,
    ) -> Result<VectorId, AuthorError> {
        check_direction_ref(&self.model, &orientation)?;
        Ok(VectorId(self.model.vector_arena.push(Vector {
            name,
            orientation,
            magnitude,
        })))
    }

    /// `VERSIONED_ACTION_REQUEST` — strict AP242 constructor.
    pub fn add_versioned_action_request(
        &mut self,
        id: String,
        version: Option<String>,
        purpose: String,
        description: Option<String>,
    ) -> Result<VersionedActionRequestId, AuthorError> {
        Ok(VersionedActionRequestId(
            self.model
                .versioned_action_request_arena
                .push(VersionedActionRequest {
                    id,
                    version,
                    purpose,
                    description,
                }),
        ))
    }

    /// `VERTEX` — strict AP242 constructor.
    pub fn add_vertex(&mut self, name: String) -> Result<VertexId, AuthorError> {
        Ok(VertexId(self.model.vertex_arena.push(Vertex { name })))
    }

    /// `VERTEX_LOOP` — strict AP242 constructor.
    pub fn add_vertex_loop(
        &mut self,
        name: String,
        loop_vertex: VertexRef,
    ) -> Result<VertexLoopId, AuthorError> {
        check_vertex_ref(&self.model, &loop_vertex)?;
        Ok(VertexLoopId(
            self.model
                .vertex_loop_arena
                .push(VertexLoop { name, loop_vertex }),
        ))
    }

    /// `VERTEX_POINT` — strict AP242 constructor.
    pub fn add_vertex_point(
        &mut self,
        name: String,
        vertex_geometry: PointRef,
    ) -> Result<VertexPointId, AuthorError> {
        check_point_ref(&self.model, &vertex_geometry)?;
        Ok(VertexPointId(self.model.vertex_point_arena.push(
            VertexPoint {
                name,
                vertex_geometry,
            },
        )))
    }

    /// `VERTEX_SHELL` — strict AP242 constructor.
    pub fn add_vertex_shell(
        &mut self,
        name: String,
        vertex_shell_extent: VertexLoopRef,
    ) -> Result<VertexShellId, AuthorError> {
        check_vertex_loop_ref(&self.model, &vertex_shell_extent)?;
        Ok(VertexShellId(self.model.vertex_shell_arena.push(
            VertexShell {
                name,
                vertex_shell_extent,
            },
        )))
    }

    /// `VIEW_VOLUME` — strict AP242 constructor.
    pub fn add_view_volume(
        &mut self,
        projection_type: CentralOrParallel,
        projection_point: CartesianPointRef,
        view_plane_distance: f64,
        front_plane_distance: f64,
        front_plane_clipping: bool,
        back_plane_distance: f64,
        back_plane_clipping: bool,
        view_volume_sides_clipping: bool,
        view_window: PlanarBoxRef,
    ) -> Result<ViewVolumeId, AuthorError> {
        check_cartesian_point_ref(&self.model, &projection_point)?;
        check_planar_box_ref(&self.model, &view_window)?;
        Ok(ViewVolumeId(self.model.view_volume_arena.push(
            ViewVolume {
                projection_type,
                projection_point,
                view_plane_distance,
                front_plane_distance,
                front_plane_clipping,
                back_plane_distance,
                back_plane_clipping,
                view_volume_sides_clipping,
                view_window,
            },
        )))
    }

    /// `VOLUME_UNIT` — strict AP242 constructor.
    pub fn add_volume_unit(
        &mut self,
        elements: Vec<DerivedUnitElementRef>,
    ) -> Result<VolumeUnitId, AuthorError> {
        {
            let x = &elements;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "VOLUME_UNIT",
                    attribute: "elements",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &elements {
            check_derived_unit_element_ref(&self.model, e0)?;
        }
        Ok(VolumeUnitId(
            self.model.volume_unit_arena.push(VolumeUnit { elements }),
        ))
    }

    /// `WIRE_SHELL` — strict AP242 constructor.
    pub fn add_wire_shell(
        &mut self,
        name: String,
        wire_shell_extent: Vec<LoopRef>,
    ) -> Result<WireShellId, AuthorError> {
        {
            let x = &wire_shell_extent;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "WIRE_SHELL",
                    attribute: "wire_shell_extent",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        for e0 in &wire_shell_extent {
            check_loop_ref(&self.model, e0)?;
        }
        Ok(WireShellId(self.model.wire_shell_arena.push(WireShell {
            name,
            wire_shell_extent,
        })))
    }

    /// `ANNOTATION_PLACEHOLDER_OCCURRENCE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_annotation_placeholder_occurrence_cyclic(
        &mut self,
        build: impl FnOnce(AnnotationPlaceholderOccurrenceId) -> AnnotationPlaceholderOccurrence,
    ) -> Result<AnnotationPlaceholderOccurrenceId, AuthorError> {
        let id = AnnotationPlaceholderOccurrenceId(
            self.model
                .annotation_placeholder_occurrence_arena
                .items
                .len(),
        );
        self.model
            .annotation_placeholder_occurrence_arena
            .push(build(id));
        if let Err(e) = cyclic_check_annotation_placeholder_occurrence(&self.model, id.0) {
            self.model
                .annotation_placeholder_occurrence_arena
                .items
                .pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `ANNOTATION_PLANE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_annotation_plane_cyclic(
        &mut self,
        build: impl FnOnce(AnnotationPlaneId) -> AnnotationPlane,
    ) -> Result<AnnotationPlaneId, AuthorError> {
        let id = AnnotationPlaneId(self.model.annotation_plane_arena.items.len());
        self.model.annotation_plane_arena.push(build(id));
        if let Err(e) = cyclic_check_annotation_plane(&self.model, id.0) {
            self.model.annotation_plane_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `ANNOTATION_SYMBOL` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_annotation_symbol_cyclic(
        &mut self,
        build: impl FnOnce(AnnotationSymbolId) -> AnnotationSymbol,
    ) -> Result<AnnotationSymbolId, AuthorError> {
        let id = AnnotationSymbolId(self.model.annotation_symbol_arena.items.len());
        self.model.annotation_symbol_arena.push(build(id));
        if let Err(e) = cyclic_check_annotation_symbol(&self.model, id.0) {
            self.model.annotation_symbol_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `APPLIED_APPROVAL_ASSIGNMENT` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_applied_approval_assignment_cyclic(
        &mut self,
        build: impl FnOnce(AppliedApprovalAssignmentId) -> AppliedApprovalAssignment,
    ) -> Result<AppliedApprovalAssignmentId, AuthorError> {
        let id =
            AppliedApprovalAssignmentId(self.model.applied_approval_assignment_arena.items.len());
        self.model.applied_approval_assignment_arena.push(build(id));
        if let Err(e) = cyclic_check_applied_approval_assignment(&self.model, id.0) {
            self.model.applied_approval_assignment_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `APPLIED_DATE_AND_TIME_ASSIGNMENT` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_applied_date_and_time_assignment_cyclic(
        &mut self,
        build: impl FnOnce(AppliedDateAndTimeAssignmentId) -> AppliedDateAndTimeAssignment,
    ) -> Result<AppliedDateAndTimeAssignmentId, AuthorError> {
        let id = AppliedDateAndTimeAssignmentId(
            self.model
                .applied_date_and_time_assignment_arena
                .items
                .len(),
        );
        self.model
            .applied_date_and_time_assignment_arena
            .push(build(id));
        if let Err(e) = cyclic_check_applied_date_and_time_assignment(&self.model, id.0) {
            self.model
                .applied_date_and_time_assignment_arena
                .items
                .pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `APPLIED_DOCUMENT_REFERENCE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_applied_document_reference_cyclic(
        &mut self,
        build: impl FnOnce(AppliedDocumentReferenceId) -> AppliedDocumentReference,
    ) -> Result<AppliedDocumentReferenceId, AuthorError> {
        let id =
            AppliedDocumentReferenceId(self.model.applied_document_reference_arena.items.len());
        self.model.applied_document_reference_arena.push(build(id));
        if let Err(e) = cyclic_check_applied_document_reference(&self.model, id.0) {
            self.model.applied_document_reference_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_applied_external_identification_assignment_cyclic(
        &mut self,
        build: impl FnOnce(
            AppliedExternalIdentificationAssignmentId,
        ) -> AppliedExternalIdentificationAssignment,
    ) -> Result<AppliedExternalIdentificationAssignmentId, AuthorError> {
        let id = AppliedExternalIdentificationAssignmentId(
            self.model
                .applied_external_identification_assignment_arena
                .items
                .len(),
        );
        self.model
            .applied_external_identification_assignment_arena
            .push(build(id));
        if let Err(e) = cyclic_check_applied_external_identification_assignment(&self.model, id.0) {
            self.model
                .applied_external_identification_assignment_arena
                .items
                .pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `APPLIED_GROUP_ASSIGNMENT` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_applied_group_assignment_cyclic(
        &mut self,
        build: impl FnOnce(AppliedGroupAssignmentId) -> AppliedGroupAssignment,
    ) -> Result<AppliedGroupAssignmentId, AuthorError> {
        let id = AppliedGroupAssignmentId(self.model.applied_group_assignment_arena.items.len());
        self.model.applied_group_assignment_arena.push(build(id));
        if let Err(e) = cyclic_check_applied_group_assignment(&self.model, id.0) {
            self.model.applied_group_assignment_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_applied_person_and_organization_assignment_cyclic(
        &mut self,
        build: impl FnOnce(
            AppliedPersonAndOrganizationAssignmentId,
        ) -> AppliedPersonAndOrganizationAssignment,
    ) -> Result<AppliedPersonAndOrganizationAssignmentId, AuthorError> {
        let id = AppliedPersonAndOrganizationAssignmentId(
            self.model
                .applied_person_and_organization_assignment_arena
                .items
                .len(),
        );
        self.model
            .applied_person_and_organization_assignment_arena
            .push(build(id));
        if let Err(e) = cyclic_check_applied_person_and_organization_assignment(&self.model, id.0) {
            self.model
                .applied_person_and_organization_assignment_arena
                .items
                .pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `BOUNDED_SURFACE_CURVE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_bounded_surface_curve_cyclic(
        &mut self,
        build: impl FnOnce(BoundedSurfaceCurveId) -> BoundedSurfaceCurve,
    ) -> Result<BoundedSurfaceCurveId, AuthorError> {
        let id = BoundedSurfaceCurveId(self.model.bounded_surface_curve_arena.items.len());
        self.model.bounded_surface_curve_arena.push(build(id));
        if let Err(e) = cyclic_check_bounded_surface_curve(&self.model, id.0) {
            self.model.bounded_surface_curve_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `CAMERA_IMAGE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_camera_image_cyclic(
        &mut self,
        build: impl FnOnce(CameraImageId) -> CameraImage,
    ) -> Result<CameraImageId, AuthorError> {
        let id = CameraImageId(self.model.camera_image_arena.items.len());
        self.model.camera_image_arena.push(build(id));
        if let Err(e) = cyclic_check_camera_image(&self.model, id.0) {
            self.model.camera_image_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `CAMERA_IMAGE_3D_WITH_SCALE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_camera_image3d_with_scale_cyclic(
        &mut self,
        build: impl FnOnce(CameraImage3dWithScaleId) -> CameraImage3dWithScale,
    ) -> Result<CameraImage3dWithScaleId, AuthorError> {
        let id = CameraImage3dWithScaleId(self.model.camera_image3d_with_scale_arena.items.len());
        self.model.camera_image3d_with_scale_arena.push(build(id));
        if let Err(e) = cyclic_check_camera_image3d_with_scale(&self.model, id.0) {
            self.model.camera_image3d_with_scale_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `COMPOSITE_TEXT` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_composite_text_cyclic(
        &mut self,
        build: impl FnOnce(CompositeTextId) -> CompositeText,
    ) -> Result<CompositeTextId, AuthorError> {
        let id = CompositeTextId(self.model.composite_text_arena.items.len());
        self.model.composite_text_arena.push(build(id));
        if let Err(e) = cyclic_check_composite_text(&self.model, id.0) {
            self.model.composite_text_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `COMPOUND_REPRESENTATION_ITEM` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_compound_representation_item_cyclic(
        &mut self,
        build: impl FnOnce(CompoundRepresentationItemId) -> CompoundRepresentationItem,
    ) -> Result<CompoundRepresentationItemId, AuthorError> {
        let id =
            CompoundRepresentationItemId(self.model.compound_representation_item_arena.items.len());
        self.model
            .compound_representation_item_arena
            .push(build(id));
        if let Err(e) = cyclic_check_compound_representation_item(&self.model, id.0) {
            self.model.compound_representation_item_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_context_dependent_over_riding_styled_item_cyclic(
        &mut self,
        build: impl FnOnce(
            ContextDependentOverRidingStyledItemId,
        ) -> ContextDependentOverRidingStyledItem,
    ) -> Result<ContextDependentOverRidingStyledItemId, AuthorError> {
        let id = ContextDependentOverRidingStyledItemId(
            self.model
                .context_dependent_over_riding_styled_item_arena
                .items
                .len(),
        );
        self.model
            .context_dependent_over_riding_styled_item_arena
            .push(build(id));
        if let Err(e) = cyclic_check_context_dependent_over_riding_styled_item(&self.model, id.0) {
            self.model
                .context_dependent_over_riding_styled_item_arena
                .items
                .pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `DATUM_REFERENCE_ELEMENT` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_datum_reference_element_cyclic(
        &mut self,
        build: impl FnOnce(DatumReferenceElementId) -> DatumReferenceElement,
    ) -> Result<DatumReferenceElementId, AuthorError> {
        let id = DatumReferenceElementId(self.model.datum_reference_element_arena.items.len());
        self.model.datum_reference_element_arena.push(build(id));
        if let Err(e) = cyclic_check_datum_reference_element(&self.model, id.0) {
            self.model.datum_reference_element_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `DIMENSIONAL_SIZE_WITH_DATUM_FEATURE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_dimensional_size_with_datum_feature_cyclic(
        &mut self,
        build: impl FnOnce(DimensionalSizeWithDatumFeatureId) -> DimensionalSizeWithDatumFeature,
    ) -> Result<DimensionalSizeWithDatumFeatureId, AuthorError> {
        let id = DimensionalSizeWithDatumFeatureId(
            self.model
                .dimensional_size_with_datum_feature_arena
                .items
                .len(),
        );
        self.model
            .dimensional_size_with_datum_feature_arena
            .push(build(id));
        if let Err(e) = cyclic_check_dimensional_size_with_datum_feature(&self.model, id.0) {
            self.model
                .dimensional_size_with_datum_feature_arena
                .items
                .pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `INTERSECTION_CURVE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_intersection_curve_cyclic(
        &mut self,
        build: impl FnOnce(IntersectionCurveId) -> IntersectionCurve,
    ) -> Result<IntersectionCurveId, AuthorError> {
        let id = IntersectionCurveId(self.model.intersection_curve_arena.items.len());
        self.model.intersection_curve_arena.push(build(id));
        if let Err(e) = cyclic_check_intersection_curve(&self.model, id.0) {
            self.model.intersection_curve_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `MAPPED_ITEM` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_mapped_item_cyclic(
        &mut self,
        build: impl FnOnce(MappedItemId) -> MappedItem,
    ) -> Result<MappedItemId, AuthorError> {
        let id = MappedItemId(self.model.mapped_item_arena.items.len());
        self.model.mapped_item_arena.push(build(id));
        if let Err(e) = cyclic_check_mapped_item(&self.model, id.0) {
            self.model.mapped_item_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `OFFSET_SURFACE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_offset_surface_cyclic(
        &mut self,
        build: impl FnOnce(OffsetSurfaceId) -> OffsetSurface,
    ) -> Result<OffsetSurfaceId, AuthorError> {
        let id = OffsetSurfaceId(self.model.offset_surface_arena.items.len());
        self.model.offset_surface_arena.push(build(id));
        if let Err(e) = cyclic_check_offset_surface(&self.model, id.0) {
            self.model.offset_surface_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `ORIENTED_CLOSED_SHELL` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_oriented_closed_shell_cyclic(
        &mut self,
        build: impl FnOnce(OrientedClosedShellId) -> OrientedClosedShell,
    ) -> Result<OrientedClosedShellId, AuthorError> {
        let id = OrientedClosedShellId(self.model.oriented_closed_shell_arena.items.len());
        self.model.oriented_closed_shell_arena.push(build(id));
        if let Err(e) = cyclic_check_oriented_closed_shell(&self.model, id.0) {
            self.model.oriented_closed_shell_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `ORIENTED_EDGE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_oriented_edge_cyclic(
        &mut self,
        build: impl FnOnce(OrientedEdgeId) -> OrientedEdge,
    ) -> Result<OrientedEdgeId, AuthorError> {
        let id = OrientedEdgeId(self.model.oriented_edge_arena.items.len());
        self.model.oriented_edge_arena.push(build(id));
        if let Err(e) = cyclic_check_oriented_edge(&self.model, id.0) {
            self.model.oriented_edge_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `OVER_RIDING_STYLED_ITEM` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_over_riding_styled_item_cyclic(
        &mut self,
        build: impl FnOnce(OverRidingStyledItemId) -> OverRidingStyledItem,
    ) -> Result<OverRidingStyledItemId, AuthorError> {
        let id = OverRidingStyledItemId(self.model.over_riding_styled_item_arena.items.len());
        self.model.over_riding_styled_item_arena.push(build(id));
        if let Err(e) = cyclic_check_over_riding_styled_item(&self.model, id.0) {
            self.model.over_riding_styled_item_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `PRODUCT_DEFINITION_OCCURRENCE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_product_definition_occurrence_cyclic(
        &mut self,
        build: impl FnOnce(ProductDefinitionOccurrenceId) -> ProductDefinitionOccurrence,
    ) -> Result<ProductDefinitionOccurrenceId, AuthorError> {
        let id = ProductDefinitionOccurrenceId(
            self.model.product_definition_occurrence_arena.items.len(),
        );
        self.model
            .product_definition_occurrence_arena
            .push(build(id));
        if let Err(e) = cyclic_check_product_definition_occurrence(&self.model, id.0) {
            self.model.product_definition_occurrence_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `PRODUCT_DEFINITION_SHAPE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_product_definition_shape_cyclic(
        &mut self,
        build: impl FnOnce(ProductDefinitionShapeId) -> ProductDefinitionShape,
    ) -> Result<ProductDefinitionShapeId, AuthorError> {
        let id = ProductDefinitionShapeId(self.model.product_definition_shape_arena.items.len());
        self.model.product_definition_shape_arena.push(build(id));
        if let Err(e) = cyclic_check_product_definition_shape(&self.model, id.0) {
            self.model.product_definition_shape_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `SEAM_CURVE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_seam_curve_cyclic(
        &mut self,
        build: impl FnOnce(SeamCurveId) -> SeamCurve,
    ) -> Result<SeamCurveId, AuthorError> {
        let id = SeamCurveId(self.model.seam_curve_arena.items.len());
        self.model.seam_curve_arena.push(build(id));
        if let Err(e) = cyclic_check_seam_curve(&self.model, id.0) {
            self.model.seam_curve_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `SURFACE_CURVE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_surface_curve_cyclic(
        &mut self,
        build: impl FnOnce(SurfaceCurveId) -> SurfaceCurve,
    ) -> Result<SurfaceCurveId, AuthorError> {
        let id = SurfaceCurveId(self.model.surface_curve_arena.items.len());
        self.model.surface_curve_arena.push(build(id));
        if let Err(e) = cyclic_check_surface_curve(&self.model, id.0) {
            self.model.surface_curve_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `TESSELLATED_GEOMETRIC_SET` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_tessellated_geometric_set_cyclic(
        &mut self,
        build: impl FnOnce(TessellatedGeometricSetId) -> TessellatedGeometricSet,
    ) -> Result<TessellatedGeometricSetId, AuthorError> {
        let id = TessellatedGeometricSetId(self.model.tessellated_geometric_set_arena.items.len());
        self.model.tessellated_geometric_set_arena.push(build(id));
        if let Err(e) = cyclic_check_tessellated_geometric_set(&self.model, id.0) {
            self.model.tessellated_geometric_set_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// `TRIMMED_CURVE` — self-referencing variant: the closure receives the id
    /// this entity will get, so a field may reference the entity itself.
    /// Validation runs after insertion; on error the insertion is rolled back.
    pub fn add_trimmed_curve_cyclic(
        &mut self,
        build: impl FnOnce(TrimmedCurveId) -> TrimmedCurve,
    ) -> Result<TrimmedCurveId, AuthorError> {
        let id = TrimmedCurveId(self.model.trimmed_curve_arena.items.len());
        self.model.trimmed_curve_arena.push(build(id));
        if let Err(e) = cyclic_check_trimmed_curve(&self.model, id.0) {
            self.model.trimmed_curve_arena.items.pop();
            return Err(e);
        }
        Ok(id)
    }

    /// Complex (multi-part) instance — rule-based strict AP242 assembler.
    /// The part-name set is validated by the schema name-set rule (legality,
    /// supertype-chain completeness, connectivity, ONEOF exclusivity), then
    /// every reference field is checked; parts are stored in Part 21 order
    /// (alphabetical).
    pub fn add_complex(&mut self, mut parts: Vec<UnitPart>) -> Result<ComplexUnitId, AuthorError> {
        let names: Vec<&'static str> = parts.iter().map(part_name).collect();
        complex_rule(&names)?;
        for p in &parts {
            check_unit_part(&self.model, p)?;
        }
        parts.sort_by(|a, b| part_name(a).cmp(part_name(b)));
        Ok(ComplexUnitId(
            self.model.complex_unit_arena.push(ComplexUnit { parts }),
        ))
    }
}

fn cyclic_check_annotation_placeholder_occurrence(
    model: &StepModel,
    id: usize,
) -> Result<(), AuthorError> {
    for e0 in &model.annotation_placeholder_occurrence_arena.items[id].styles {
        check_presentation_style_assignment_ref(model, e0)?;
    }
    check_styled_item_target_ref(
        model,
        &model.annotation_placeholder_occurrence_arena.items[id].item,
    )?;
    Ok(())
}

fn cyclic_check_annotation_plane(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    for e0 in &model.annotation_plane_arena.items[id].styles {
        check_presentation_style_assignment_ref(model, e0)?;
    }
    check_plane_or_planar_box_ref(model, &model.annotation_plane_arena.items[id].item)?;
    if let Some(x) = &model.annotation_plane_arena.items[id].elements {
        for e0 in x {
            check_annotation_plane_element_ref(model, e0)?;
        }
    }
    Ok(())
}

fn cyclic_check_annotation_symbol(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_representation_map_ref(
        model,
        &model.annotation_symbol_arena.items[id].mapping_source,
    )?;
    check_representation_item_ref(
        model,
        &model.annotation_symbol_arena.items[id].mapping_target,
    )?;
    Ok(())
}

fn cyclic_check_applied_approval_assignment(
    model: &StepModel,
    id: usize,
) -> Result<(), AuthorError> {
    check_approval_ref(
        model,
        &model.applied_approval_assignment_arena.items[id].assigned_approval,
    )?;
    for e0 in &model.applied_approval_assignment_arena.items[id].items {
        check_approval_item_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_applied_date_and_time_assignment(
    model: &StepModel,
    id: usize,
) -> Result<(), AuthorError> {
    check_date_and_time_ref(
        model,
        &model.applied_date_and_time_assignment_arena.items[id].assigned_date_and_time,
    )?;
    check_date_time_role_ref(
        model,
        &model.applied_date_and_time_assignment_arena.items[id].role,
    )?;
    for e0 in &model.applied_date_and_time_assignment_arena.items[id].items {
        check_date_and_time_item_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_applied_document_reference(
    model: &StepModel,
    id: usize,
) -> Result<(), AuthorError> {
    check_document_ref(
        model,
        &model.applied_document_reference_arena.items[id].assigned_document,
    )?;
    for e0 in &model.applied_document_reference_arena.items[id].items {
        check_document_reference_item_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_applied_external_identification_assignment(
    model: &StepModel,
    id: usize,
) -> Result<(), AuthorError> {
    check_identification_role_ref(
        model,
        &model.applied_external_identification_assignment_arena.items[id].role,
    )?;
    check_external_source_ref(
        model,
        &model.applied_external_identification_assignment_arena.items[id].source,
    )?;
    for e0 in &model.applied_external_identification_assignment_arena.items[id].items {
        check_external_identification_item_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_applied_group_assignment(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_group_ref(
        model,
        &model.applied_group_assignment_arena.items[id].assigned_group,
    )?;
    for e0 in &model.applied_group_assignment_arena.items[id].items {
        check_groupable_item_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_applied_person_and_organization_assignment(
    model: &StepModel,
    id: usize,
) -> Result<(), AuthorError> {
    check_person_and_organization_ref(
        model,
        &model.applied_person_and_organization_assignment_arena.items[id]
            .assigned_person_and_organization,
    )?;
    check_person_and_organization_role_ref(
        model,
        &model.applied_person_and_organization_assignment_arena.items[id].role,
    )?;
    for e0 in &model.applied_person_and_organization_assignment_arena.items[id].items {
        check_person_and_organization_item_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_bounded_surface_curve(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_curve_ref(model, &model.bounded_surface_curve_arena.items[id].curve_3d)?;
    for e0 in &model.bounded_surface_curve_arena.items[id].associated_geometry {
        check_pcurve_or_surface_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_camera_image(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_representation_map_ref(model, &model.camera_image_arena.items[id].mapping_source)?;
    check_representation_item_ref(model, &model.camera_image_arena.items[id].mapping_target)?;
    Ok(())
}

fn cyclic_check_camera_image3d_with_scale(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_representation_map_ref(
        model,
        &model.camera_image3d_with_scale_arena.items[id].mapping_source,
    )?;
    check_representation_item_ref(
        model,
        &model.camera_image3d_with_scale_arena.items[id].mapping_target,
    )?;
    Ok(())
}

fn cyclic_check_composite_text(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    for e0 in &model.composite_text_arena.items[id].collected_text {
        check_text_or_character_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_compound_representation_item(
    model: &StepModel,
    id: usize,
) -> Result<(), AuthorError> {
    check_compound_item_definition_ref(
        model,
        &model.compound_representation_item_arena.items[id].item_element,
    )?;
    Ok(())
}

fn cyclic_check_context_dependent_over_riding_styled_item(
    model: &StepModel,
    id: usize,
) -> Result<(), AuthorError> {
    for e0 in &model.context_dependent_over_riding_styled_item_arena.items[id].styles {
        check_presentation_style_assignment_ref(model, e0)?;
    }
    check_styled_item_target_ref(
        model,
        &model.context_dependent_over_riding_styled_item_arena.items[id].item,
    )?;
    check_styled_item_ref(
        model,
        &model.context_dependent_over_riding_styled_item_arena.items[id].over_ridden_style,
    )?;
    for e0 in &model.context_dependent_over_riding_styled_item_arena.items[id].style_context {
        check_style_context_select_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_datum_reference_element(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_product_definition_shape_ref(
        model,
        &model.datum_reference_element_arena.items[id].of_shape,
    )?;
    check_datum_or_common_datum_ref(model, &model.datum_reference_element_arena.items[id].base)?;
    if let Some(x) = &model.datum_reference_element_arena.items[id].modifiers {
        for e0 in x {
            check_datum_reference_modifier_ref(model, e0)?;
        }
    }
    Ok(())
}

fn cyclic_check_dimensional_size_with_datum_feature(
    model: &StepModel,
    id: usize,
) -> Result<(), AuthorError> {
    check_product_definition_shape_ref(
        model,
        &model.dimensional_size_with_datum_feature_arena.items[id].of_shape,
    )?;
    check_shape_aspect_ref(
        model,
        &model.dimensional_size_with_datum_feature_arena.items[id].applies_to,
    )?;
    Ok(())
}

fn cyclic_check_intersection_curve(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_curve_ref(model, &model.intersection_curve_arena.items[id].curve_3d)?;
    for e0 in &model.intersection_curve_arena.items[id].associated_geometry {
        check_pcurve_or_surface_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_mapped_item(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_representation_map_ref(model, &model.mapped_item_arena.items[id].mapping_source)?;
    check_representation_item_ref(model, &model.mapped_item_arena.items[id].mapping_target)?;
    Ok(())
}

fn cyclic_check_offset_surface(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_surface_ref(model, &model.offset_surface_arena.items[id].basis_surface)?;
    Ok(())
}

fn cyclic_check_oriented_closed_shell(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_closed_shell_ref(
        model,
        &model.oriented_closed_shell_arena.items[id].closed_shell_element,
    )?;
    Ok(())
}

fn cyclic_check_oriented_edge(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_edge_ref(model, &model.oriented_edge_arena.items[id].edge_element)?;
    Ok(())
}

fn cyclic_check_over_riding_styled_item(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    for e0 in &model.over_riding_styled_item_arena.items[id].styles {
        check_presentation_style_assignment_ref(model, e0)?;
    }
    check_styled_item_target_ref(model, &model.over_riding_styled_item_arena.items[id].item)?;
    check_styled_item_ref(
        model,
        &model.over_riding_styled_item_arena.items[id].over_ridden_style,
    )?;
    Ok(())
}

fn cyclic_check_product_definition_occurrence(
    model: &StepModel,
    id: usize,
) -> Result<(), AuthorError> {
    if let Some(x) = &model.product_definition_occurrence_arena.items[id].definition {
        check_product_definition_or_reference_ref(model, x)?;
    }
    if let Some(x) = &model.product_definition_occurrence_arena.items[id].quantity {
        check_measure_with_unit_ref(model, x)?;
    }
    Ok(())
}

fn cyclic_check_product_definition_shape(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_characterized_definition_ref(
        model,
        &model.product_definition_shape_arena.items[id].definition,
    )?;
    Ok(())
}

fn cyclic_check_seam_curve(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_curve_ref(model, &model.seam_curve_arena.items[id].curve_3d)?;
    for e0 in &model.seam_curve_arena.items[id].associated_geometry {
        check_pcurve_or_surface_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_surface_curve(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_curve_ref(model, &model.surface_curve_arena.items[id].curve_3d)?;
    for e0 in &model.surface_curve_arena.items[id].associated_geometry {
        check_pcurve_or_surface_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_tessellated_geometric_set(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    for e0 in &model.tessellated_geometric_set_arena.items[id].children {
        check_tessellated_item_ref(model, e0)?;
    }
    Ok(())
}

fn cyclic_check_trimmed_curve(model: &StepModel, id: usize) -> Result<(), AuthorError> {
    check_curve_ref(model, &model.trimmed_curve_arena.items[id].basis_curve)?;
    for e0 in &model.trimmed_curve_arena.items[id].trim_1 {
        check_trimming_select_ref(model, e0)?;
    }
    for e0 in &model.trimmed_curve_arena.items[id].trim_2 {
        check_trimming_select_ref(model, e0)?;
    }
    Ok(())
}

fn part_name(p: &UnitPart) -> &'static str {
    match p {
        UnitPart::Action { .. } => "ACTION",
        UnitPart::ActionMethod { .. } => "ACTION_METHOD",
        UnitPart::ActionMethodRelationship { .. } => "ACTION_METHOD_RELATIONSHIP",
        UnitPart::ActionRelationship { .. } => "ACTION_RELATIONSHIP",
        UnitPart::ActionRequestAssignment { .. } => "ACTION_REQUEST_ASSIGNMENT",
        UnitPart::ActionResource { .. } => "ACTION_RESOURCE",
        UnitPart::ActionResourceRequirement { .. } => "ACTION_RESOURCE_REQUIREMENT",
        UnitPart::Address { .. } => "ADDRESS",
        UnitPart::AdvancedBrepShapeRepresentation => "ADVANCED_BREP_SHAPE_REPRESENTATION",
        UnitPart::AdvancedFace => "ADVANCED_FACE",
        UnitPart::AnnotationCurveOccurrence => "ANNOTATION_CURVE_OCCURRENCE",
        UnitPart::AnnotationFillAreaOccurrence { .. } => "ANNOTATION_FILL_AREA_OCCURRENCE",
        UnitPart::AnnotationOccurrence => "ANNOTATION_OCCURRENCE",
        UnitPart::AnnotationOccurrenceAssociativity => "ANNOTATION_OCCURRENCE_ASSOCIATIVITY",
        UnitPart::AnnotationOccurrenceRelationship { .. } => "ANNOTATION_OCCURRENCE_RELATIONSHIP",
        UnitPart::AnnotationPlaceholderOccurrence { .. } => "ANNOTATION_PLACEHOLDER_OCCURRENCE",
        UnitPart::AnnotationPlaceholderOccurrenceWithLeaderLine { .. } => {
            "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE"
        }
        UnitPart::AnnotationPlane { .. } => "ANNOTATION_PLANE",
        UnitPart::AnnotationSymbol => "ANNOTATION_SYMBOL",
        UnitPart::AnnotationSymbolOccurrence => "ANNOTATION_SYMBOL_OCCURRENCE",
        UnitPart::AnnotationText => "ANNOTATION_TEXT",
        UnitPart::AnnotationTextCharacter { .. } => "ANNOTATION_TEXT_CHARACTER",
        UnitPart::AnnotationTextOccurrence => "ANNOTATION_TEXT_OCCURRENCE",
        UnitPart::ApplicationContextElement { .. } => "APPLICATION_CONTEXT_ELEMENT",
        UnitPart::AppliedApprovalAssignment { .. } => "APPLIED_APPROVAL_ASSIGNMENT",
        UnitPart::AppliedDateAndTimeAssignment { .. } => "APPLIED_DATE_AND_TIME_ASSIGNMENT",
        UnitPart::AppliedDocumentReference { .. } => "APPLIED_DOCUMENT_REFERENCE",
        UnitPart::AppliedExternalIdentificationAssignment { .. } => {
            "APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT"
        }
        UnitPart::AppliedGroupAssignment { .. } => "APPLIED_GROUP_ASSIGNMENT",
        UnitPart::AppliedPersonAndOrganizationAssignment { .. } => {
            "APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT"
        }
        UnitPart::AppliedPresentedItem { .. } => "APPLIED_PRESENTED_ITEM",
        UnitPart::AppliedSecurityClassificationAssignment { .. } => {
            "APPLIED_SECURITY_CLASSIFICATION_ASSIGNMENT"
        }
        UnitPart::ApprovalAssignment { .. } => "APPROVAL_ASSIGNMENT",
        UnitPart::AreaInSet { .. } => "AREA_IN_SET",
        UnitPart::AscribableStateRelationship { .. } => "ASCRIBABLE_STATE_RELATIONSHIP",
        UnitPart::AssemblyComponentUsage { .. } => "ASSEMBLY_COMPONENT_USAGE",
        UnitPart::BSplineCurve { .. } => "B_SPLINE_CURVE",
        UnitPart::BSplineCurveWithKnots { .. } => "B_SPLINE_CURVE_WITH_KNOTS",
        UnitPart::BSplineSurface { .. } => "B_SPLINE_SURFACE",
        UnitPart::BSplineSurfaceWithKnots { .. } => "B_SPLINE_SURFACE_WITH_KNOTS",
        UnitPart::BezierCurve => "BEZIER_CURVE",
        UnitPart::BezierSurface => "BEZIER_SURFACE",
        UnitPart::BoundedCurve => "BOUNDED_CURVE",
        UnitPart::BoundedPcurve => "BOUNDED_PCURVE",
        UnitPart::BoundedSurface => "BOUNDED_SURFACE",
        UnitPart::BoundedSurfaceCurve => "BOUNDED_SURFACE_CURVE",
        UnitPart::BrepWithVoids { .. } => "BREP_WITH_VOIDS",
        UnitPart::CameraImage => "CAMERA_IMAGE",
        UnitPart::CameraImage3dWithScale => "CAMERA_IMAGE_3D_WITH_SCALE",
        UnitPart::CameraModel => "CAMERA_MODEL",
        UnitPart::CameraModelD3 { .. } => "CAMERA_MODEL_D3",
        UnitPart::CameraModelD3MultiClipping { .. } => "CAMERA_MODEL_D3_MULTI_CLIPPING",
        UnitPart::CameraModelD3WithHlhsr { .. } => "CAMERA_MODEL_D3_WITH_HLHSR",
        UnitPart::CameraUsage => "CAMERA_USAGE",
        UnitPart::CcDesignApproval { .. } => "CC_DESIGN_APPROVAL",
        UnitPart::CcDesignDateAndTimeAssignment { .. } => "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT",
        UnitPart::CcDesignPersonAndOrganizationAssignment { .. } => {
            "CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT"
        }
        UnitPart::CcDesignSecurityClassification { .. } => "CC_DESIGN_SECURITY_CLASSIFICATION",
        UnitPart::ChangeRequest { .. } => "CHANGE_REQUEST",
        UnitPart::CharacterGlyphStyleOutline { .. } => "CHARACTER_GLYPH_STYLE_OUTLINE",
        UnitPart::CharacterGlyphStyleStroke { .. } => "CHARACTER_GLYPH_STYLE_STROKE",
        UnitPart::CharacterizedItemWithinRepresentation { .. } => {
            "CHARACTERIZED_ITEM_WITHIN_REPRESENTATION"
        }
        UnitPart::CharacterizedObject { .. } => "CHARACTERIZED_OBJECT",
        UnitPart::CharacterizedRepresentation => "CHARACTERIZED_REPRESENTATION",
        UnitPart::CircularRunoutTolerance => "CIRCULAR_RUNOUT_TOLERANCE",
        UnitPart::ClosedShell => "CLOSED_SHELL",
        UnitPart::Colour => "COLOUR",
        UnitPart::ColourRgb { .. } => "COLOUR_RGB",
        UnitPart::ColourSpecification { .. } => "COLOUR_SPECIFICATION",
        UnitPart::CommonDatum => "COMMON_DATUM",
        UnitPart::CompositeCurve { .. } => "COMPOSITE_CURVE",
        UnitPart::CompositeCurveSegment { .. } => "COMPOSITE_CURVE_SEGMENT",
        UnitPart::CompositeGroupShapeAspect => "COMPOSITE_GROUP_SHAPE_ASPECT",
        UnitPart::CompositeShapeAspect => "COMPOSITE_SHAPE_ASPECT",
        UnitPart::CompositeText { .. } => "COMPOSITE_TEXT",
        UnitPart::CompoundRepresentationItem { .. } => "COMPOUND_REPRESENTATION_ITEM",
        UnitPart::ConfigurationEffectivity { .. } => "CONFIGURATION_EFFECTIVITY",
        UnitPart::ConfigurationItem { .. } => "CONFIGURATION_ITEM",
        UnitPart::ConnectedFaceSet { .. } => "CONNECTED_FACE_SET",
        UnitPart::ConstructiveGeometryRepresentationRelationship => {
            "CONSTRUCTIVE_GEOMETRY_REPRESENTATION_RELATIONSHIP"
        }
        UnitPart::ContextDependentOverRidingStyledItem { .. } => {
            "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM"
        }
        UnitPart::ContextDependentUnit { .. } => "CONTEXT_DEPENDENT_UNIT",
        UnitPart::ConversionBasedUnit { .. } => "CONVERSION_BASED_UNIT",
        UnitPart::Curve => "CURVE",
        UnitPart::CurveStyle { .. } => "CURVE_STYLE",
        UnitPart::CurveStyleFont { .. } => "CURVE_STYLE_FONT",
        UnitPart::CurveStyleFontAndScaling { .. } => "CURVE_STYLE_FONT_AND_SCALING",
        UnitPart::CurveStyleFontPattern { .. } => "CURVE_STYLE_FONT_PATTERN",
        UnitPart::CylindricityTolerance => "CYLINDRICITY_TOLERANCE",
        UnitPart::Date { .. } => "DATE",
        UnitPart::DateAndTime { .. } => "DATE_AND_TIME",
        UnitPart::DateAndTimeAssignment { .. } => "DATE_AND_TIME_ASSIGNMENT",
        UnitPart::Datum { .. } => "DATUM",
        UnitPart::DatumFeature => "DATUM_FEATURE",
        UnitPart::DatumReference { .. } => "DATUM_REFERENCE",
        UnitPart::DatumSystem { .. } => "DATUM_SYSTEM",
        UnitPart::DatumTarget { .. } => "DATUM_TARGET",
        UnitPart::DefaultModelGeometricView => "DEFAULT_MODEL_GEOMETRIC_VIEW",
        UnitPart::DefinitionalRepresentation => "DEFINITIONAL_REPRESENTATION",
        UnitPart::DefinitionalRepresentationRelationship => {
            "DEFINITIONAL_REPRESENTATION_RELATIONSHIP"
        }
        UnitPart::DefinitionalRepresentationRelationshipWithSameContext => {
            "DEFINITIONAL_REPRESENTATION_RELATIONSHIP_WITH_SAME_CONTEXT"
        }
        UnitPart::DegenerateToroidalSurface { .. } => "DEGENERATE_TOROIDAL_SURFACE",
        UnitPart::DerivedUnit { .. } => "DERIVED_UNIT",
        UnitPart::DesignContext => "DESIGN_CONTEXT",
        UnitPart::DimensionalSize { .. } => "DIMENSIONAL_SIZE",
        UnitPart::Direction { .. } => "DIRECTION",
        UnitPart::Document { .. } => "DOCUMENT",
        UnitPart::DocumentFile => "DOCUMENT_FILE",
        UnitPart::DocumentProductAssociation { .. } => "DOCUMENT_PRODUCT_ASSOCIATION",
        UnitPart::DocumentProductEquivalence => "DOCUMENT_PRODUCT_EQUIVALENCE",
        UnitPart::DocumentReference { .. } => "DOCUMENT_REFERENCE",
        UnitPart::DraughtingAnnotationOccurrence => "DRAUGHTING_ANNOTATION_OCCURRENCE",
        UnitPart::DraughtingCallout { .. } => "DRAUGHTING_CALLOUT",
        UnitPart::DraughtingCalloutRelationship { .. } => "DRAUGHTING_CALLOUT_RELATIONSHIP",
        UnitPart::DraughtingModel => "DRAUGHTING_MODEL",
        UnitPart::DraughtingModelItemAssociation => "DRAUGHTING_MODEL_ITEM_ASSOCIATION",
        UnitPart::DraughtingModelItemAssociationWithPlaceholder { .. } => {
            "DRAUGHTING_MODEL_ITEM_ASSOCIATION_WITH_PLACEHOLDER"
        }
        UnitPart::DraughtingPreDefinedColour => "DRAUGHTING_PRE_DEFINED_COLOUR",
        UnitPart::DraughtingPreDefinedCurveFont => "DRAUGHTING_PRE_DEFINED_CURVE_FONT",
        UnitPart::DraughtingPreDefinedTextFont => "DRAUGHTING_PRE_DEFINED_TEXT_FONT",
        UnitPart::Edge { .. } => "EDGE",
        UnitPart::EdgeCurve { .. } => "EDGE_CURVE",
        UnitPart::EdgeLoop => "EDGE_LOOP",
        UnitPart::Effectivity { .. } => "EFFECTIVITY",
        UnitPart::ElementarySurface { .. } => "ELEMENTARY_SURFACE",
        UnitPart::Expression => "EXPRESSION",
        UnitPart::ExternalIdentificationAssignment { .. } => "EXTERNAL_IDENTIFICATION_ASSIGNMENT",
        UnitPart::ExternalSource { .. } => "EXTERNAL_SOURCE",
        UnitPart::ExternallyDefinedCharacterGlyph => "EXTERNALLY_DEFINED_CHARACTER_GLYPH",
        UnitPart::ExternallyDefinedCurveFont => "EXTERNALLY_DEFINED_CURVE_FONT",
        UnitPart::ExternallyDefinedHatchStyle => "EXTERNALLY_DEFINED_HATCH_STYLE",
        UnitPart::ExternallyDefinedItem { .. } => "EXTERNALLY_DEFINED_ITEM",
        UnitPart::ExternallyDefinedStyle => "EXTERNALLY_DEFINED_STYLE",
        UnitPart::ExternallyDefinedSymbol => "EXTERNALLY_DEFINED_SYMBOL",
        UnitPart::ExternallyDefinedTextFont => "EXTERNALLY_DEFINED_TEXT_FONT",
        UnitPart::ExternallyDefinedTile => "EXTERNALLY_DEFINED_TILE",
        UnitPart::ExternallyDefinedTileStyle => "EXTERNALLY_DEFINED_TILE_STYLE",
        UnitPart::Face { .. } => "FACE",
        UnitPart::FaceBound { .. } => "FACE_BOUND",
        UnitPart::FaceOuterBound => "FACE_OUTER_BOUND",
        UnitPart::FaceSurface { .. } => "FACE_SURFACE",
        UnitPart::FillAreaStyle { .. } => "FILL_AREA_STYLE",
        UnitPart::FillAreaStyleHatching { .. } => "FILL_AREA_STYLE_HATCHING",
        UnitPart::FillAreaStyleTileSymbolWithStyle { .. } => {
            "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE"
        }
        UnitPart::FillAreaStyleTiles { .. } => "FILL_AREA_STYLE_TILES",
        UnitPart::FlatnessTolerance => "FLATNESS_TOLERANCE",
        UnitPart::FoundedItem => "FOUNDED_ITEM",
        UnitPart::FunctionallyDefinedTransformation { .. } => "FUNCTIONALLY_DEFINED_TRANSFORMATION",
        UnitPart::GeneralDatumReference { .. } => "GENERAL_DATUM_REFERENCE",
        UnitPart::GeneralProperty { .. } => "GENERAL_PROPERTY",
        UnitPart::GenericExpression => "GENERIC_EXPRESSION",
        UnitPart::GenericLiteral => "GENERIC_LITERAL",
        UnitPart::GenericProductDefinitionReference { .. } => {
            "GENERIC_PRODUCT_DEFINITION_REFERENCE"
        }
        UnitPart::GeometricCurveSet => "GEOMETRIC_CURVE_SET",
        UnitPart::GeometricItemSpecificUsage => "GEOMETRIC_ITEM_SPECIFIC_USAGE",
        UnitPart::GeometricRepresentationContext { .. } => "GEOMETRIC_REPRESENTATION_CONTEXT",
        UnitPart::GeometricRepresentationItem => "GEOMETRIC_REPRESENTATION_ITEM",
        UnitPart::GeometricSet { .. } => "GEOMETRIC_SET",
        UnitPart::GeometricTolerance { .. } => "GEOMETRIC_TOLERANCE",
        UnitPart::GeometricToleranceWithDatumReference { .. } => {
            "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE"
        }
        UnitPart::GeometricToleranceWithDefinedAreaUnit { .. } => {
            "GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT"
        }
        UnitPart::GeometricToleranceWithDefinedUnit { .. } => {
            "GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT"
        }
        UnitPart::GeometricToleranceWithMaximumTolerance { .. } => {
            "GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE"
        }
        UnitPart::GeometricToleranceWithModifiers { .. } => "GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
        UnitPart::GeometricallyBoundedSurfaceShapeRepresentation => {
            "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION"
        }
        UnitPart::GeometricallyBoundedWireframeShapeRepresentation => {
            "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION"
        }
        UnitPart::GlobalUncertaintyAssignedContext { .. } => "GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT",
        UnitPart::GlobalUnitAssignedContext { .. } => "GLOBAL_UNIT_ASSIGNED_CONTEXT",
        UnitPart::Group { .. } => "GROUP",
        UnitPart::GroupAssignment { .. } => "GROUP_ASSIGNMENT",
        UnitPart::IdentificationAssignment { .. } => "IDENTIFICATION_ASSIGNMENT",
        UnitPart::IntLiteral => "INT_LITERAL",
        UnitPart::IntegerRepresentationItem => "INTEGER_REPRESENTATION_ITEM",
        UnitPart::IntersectionCurve => "INTERSECTION_CURVE",
        UnitPart::Invisibility { .. } => "INVISIBILITY",
        UnitPart::ItemDefinedTransformation { .. } => "ITEM_DEFINED_TRANSFORMATION",
        UnitPart::ItemIdentifiedRepresentationUsage { .. } => {
            "ITEM_IDENTIFIED_REPRESENTATION_USAGE"
        }
        UnitPart::LeaderCurve => "LEADER_CURVE",
        UnitPart::LeaderDirectedCallout => "LEADER_DIRECTED_CALLOUT",
        UnitPart::LeaderTerminator => "LEADER_TERMINATOR",
        UnitPart::LengthMeasureWithUnit => "LENGTH_MEASURE_WITH_UNIT",
        UnitPart::LengthUnit => "LENGTH_UNIT",
        UnitPart::LineProfileTolerance => "LINE_PROFILE_TOLERANCE",
        UnitPart::LiteralNumber { .. } => "LITERAL_NUMBER",
        UnitPart::Loop => "LOOP",
        UnitPart::ManifoldSolidBrep { .. } => "MANIFOLD_SOLID_BREP",
        UnitPart::ManifoldSurfaceShapeRepresentation => "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
        UnitPart::MappedItem { .. } => "MAPPED_ITEM",
        UnitPart::MassUnit => "MASS_UNIT",
        UnitPart::MeasureRepresentationItem => "MEASURE_REPRESENTATION_ITEM",
        UnitPart::MeasureWithUnit { .. } => "MEASURE_WITH_UNIT",
        UnitPart::MechanicalContext => "MECHANICAL_CONTEXT",
        UnitPart::MechanicalDesignAndDraughtingRelationship => {
            "MECHANICAL_DESIGN_AND_DRAUGHTING_RELATIONSHIP"
        }
        UnitPart::ModelGeometricView => "MODEL_GEOMETRIC_VIEW",
        UnitPart::ModifiedGeometricTolerance { .. } => "MODIFIED_GEOMETRIC_TOLERANCE",
        UnitPart::NamedUnit { .. } => "NAMED_UNIT",
        UnitPart::NextAssemblyUsageOccurrence => "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
        UnitPart::NumericExpression => "NUMERIC_EXPRESSION",
        UnitPart::OneDirectionRepeatFactor { .. } => "ONE_DIRECTION_REPEAT_FACTOR",
        UnitPart::OpenShell => "OPEN_SHELL",
        UnitPart::OrganizationalAddress { .. } => "ORGANIZATIONAL_ADDRESS",
        UnitPart::OrientedClosedShell { .. } => "ORIENTED_CLOSED_SHELL",
        UnitPart::OrientedEdge { .. } => "ORIENTED_EDGE",
        UnitPart::OverRidingStyledItem { .. } => "OVER_RIDING_STYLED_ITEM",
        UnitPart::ParallelismTolerance => "PARALLELISM_TOLERANCE",
        UnitPart::ParametricRepresentationContext => "PARAMETRIC_REPRESENTATION_CONTEXT",
        UnitPart::Path { .. } => "PATH",
        UnitPart::Pcurve { .. } => "PCURVE",
        UnitPart::PerpendicularityTolerance => "PERPENDICULARITY_TOLERANCE",
        UnitPart::PersonAndOrganizationAddress => "PERSON_AND_ORGANIZATION_ADDRESS",
        UnitPart::PersonAndOrganizationAssignment { .. } => "PERSON_AND_ORGANIZATION_ASSIGNMENT",
        UnitPart::PersonalAddress { .. } => "PERSONAL_ADDRESS",
        UnitPart::PlacedDatumTargetFeature => "PLACED_DATUM_TARGET_FEATURE",
        UnitPart::Placement { .. } => "PLACEMENT",
        UnitPart::PlanarBox { .. } => "PLANAR_BOX",
        UnitPart::PlanarExtent { .. } => "PLANAR_EXTENT",
        UnitPart::PlaneAngleMeasureWithUnit => "PLANE_ANGLE_MEASURE_WITH_UNIT",
        UnitPart::PlaneAngleUnit => "PLANE_ANGLE_UNIT",
        UnitPart::Point => "POINT",
        UnitPart::PointStyle { .. } => "POINT_STYLE",
        UnitPart::PolyLoop { .. } => "POLY_LOOP",
        UnitPart::PositionTolerance => "POSITION_TOLERANCE",
        UnitPart::PreDefinedCharacterGlyph => "PRE_DEFINED_CHARACTER_GLYPH",
        UnitPart::PreDefinedColour => "PRE_DEFINED_COLOUR",
        UnitPart::PreDefinedCurveFont => "PRE_DEFINED_CURVE_FONT",
        UnitPart::PreDefinedItem { .. } => "PRE_DEFINED_ITEM",
        UnitPart::PreDefinedMarker => "PRE_DEFINED_MARKER",
        UnitPart::PreDefinedPointMarkerSymbol => "PRE_DEFINED_POINT_MARKER_SYMBOL",
        UnitPart::PreDefinedPresentationStyle => "PRE_DEFINED_PRESENTATION_STYLE",
        UnitPart::PreDefinedSurfaceSideStyle => "PRE_DEFINED_SURFACE_SIDE_STYLE",
        UnitPart::PreDefinedSymbol => "PRE_DEFINED_SYMBOL",
        UnitPart::PreDefinedTerminatorSymbol => "PRE_DEFINED_TERMINATOR_SYMBOL",
        UnitPart::PreDefinedTextFont => "PRE_DEFINED_TEXT_FONT",
        UnitPart::PreDefinedTile => "PRE_DEFINED_TILE",
        UnitPart::PresentationArea => "PRESENTATION_AREA",
        UnitPart::PresentationRepresentation => "PRESENTATION_REPRESENTATION",
        UnitPart::PresentationSet => "PRESENTATION_SET",
        UnitPart::PresentationStyleAssignment { .. } => "PRESENTATION_STYLE_ASSIGNMENT",
        UnitPart::PresentationStyleByContext { .. } => "PRESENTATION_STYLE_BY_CONTEXT",
        UnitPart::PresentationView => "PRESENTATION_VIEW",
        UnitPart::PresentedItem => "PRESENTED_ITEM",
        UnitPart::Product { .. } => "PRODUCT",
        UnitPart::ProductCategory { .. } => "PRODUCT_CATEGORY",
        UnitPart::ProductConcept { .. } => "PRODUCT_CONCEPT",
        UnitPart::ProductConceptFeature { .. } => "PRODUCT_CONCEPT_FEATURE",
        UnitPart::ProductConceptFeatureCategory => "PRODUCT_CONCEPT_FEATURE_CATEGORY",
        UnitPart::ProductContext { .. } => "PRODUCT_CONTEXT",
        UnitPart::ProductDefinition { .. } => "PRODUCT_DEFINITION",
        UnitPart::ProductDefinitionContext { .. } => "PRODUCT_DEFINITION_CONTEXT",
        UnitPart::ProductDefinitionEffectivity { .. } => "PRODUCT_DEFINITION_EFFECTIVITY",
        UnitPart::ProductDefinitionFormation { .. } => "PRODUCT_DEFINITION_FORMATION",
        UnitPart::ProductDefinitionFormationWithSpecifiedSource { .. } => {
            "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE"
        }
        UnitPart::ProductDefinitionOccurrence { .. } => "PRODUCT_DEFINITION_OCCURRENCE",
        UnitPart::ProductDefinitionRelationship { .. } => "PRODUCT_DEFINITION_RELATIONSHIP",
        UnitPart::ProductDefinitionRelationshipRelationship { .. } => {
            "PRODUCT_DEFINITION_RELATIONSHIP_RELATIONSHIP"
        }
        UnitPart::ProductDefinitionShape => "PRODUCT_DEFINITION_SHAPE",
        UnitPart::ProductDefinitionUsage => "PRODUCT_DEFINITION_USAGE",
        UnitPart::ProductDefinitionWithAssociatedDocuments { .. } => {
            "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS"
        }
        UnitPart::ProductRelatedProductCategory { .. } => "PRODUCT_RELATED_PRODUCT_CATEGORY",
        UnitPart::ProjectedZoneDefinition { .. } => "PROJECTED_ZONE_DEFINITION",
        UnitPart::PropertyDefinition { .. } => "PROPERTY_DEFINITION",
        UnitPart::PropertyDefinitionRepresentation { .. } => "PROPERTY_DEFINITION_REPRESENTATION",
        UnitPart::QualifiedRepresentationItem { .. } => "QUALIFIED_REPRESENTATION_ITEM",
        UnitPart::QuasiUniformCurve => "QUASI_UNIFORM_CURVE",
        UnitPart::QuasiUniformSurface => "QUASI_UNIFORM_SURFACE",
        UnitPart::RatioMeasureWithUnit => "RATIO_MEASURE_WITH_UNIT",
        UnitPart::RatioUnit => "RATIO_UNIT",
        UnitPart::RationalBSplineCurve { .. } => "RATIONAL_B_SPLINE_CURVE",
        UnitPart::RationalBSplineSurface { .. } => "RATIONAL_B_SPLINE_SURFACE",
        UnitPart::RealLiteral => "REAL_LITERAL",
        UnitPart::RealRepresentationItem => "REAL_REPRESENTATION_ITEM",
        UnitPart::RepositionedTessellatedItem { .. } => "REPOSITIONED_TESSELLATED_ITEM",
        UnitPart::Representation { .. } => "REPRESENTATION",
        UnitPart::RepresentationContext { .. } => "REPRESENTATION_CONTEXT",
        UnitPart::RepresentationItem { .. } => "REPRESENTATION_ITEM",
        UnitPart::RepresentationMap { .. } => "REPRESENTATION_MAP",
        UnitPart::RepresentationReference { .. } => "REPRESENTATION_REFERENCE",
        UnitPart::RepresentationRelationship { .. } => "REPRESENTATION_RELATIONSHIP",
        UnitPart::RepresentationRelationshipWithTransformation { .. } => {
            "REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION"
        }
        UnitPart::RoundnessTolerance => "ROUNDNESS_TOLERANCE",
        UnitPart::SeamCurve => "SEAM_CURVE",
        UnitPart::SecurityClassificationAssignment { .. } => "SECURITY_CLASSIFICATION_ASSIGNMENT",
        UnitPart::ShapeAspect { .. } => "SHAPE_ASPECT",
        UnitPart::ShapeAspectRelationship { .. } => "SHAPE_ASPECT_RELATIONSHIP",
        UnitPart::ShapeDefinitionRepresentation => "SHAPE_DEFINITION_REPRESENTATION",
        UnitPart::ShapeDimensionRepresentation => "SHAPE_DIMENSION_REPRESENTATION",
        UnitPart::ShapeRepresentation => "SHAPE_REPRESENTATION",
        UnitPart::ShapeRepresentationRelationship => "SHAPE_REPRESENTATION_RELATIONSHIP",
        UnitPart::ShapeRepresentationWithParameters => "SHAPE_REPRESENTATION_WITH_PARAMETERS",
        UnitPart::ShellBasedSurfaceModel { .. } => "SHELL_BASED_SURFACE_MODEL",
        UnitPart::SiUnit { .. } => "SI_UNIT",
        UnitPart::SimpleGenericExpression => "SIMPLE_GENERIC_EXPRESSION",
        UnitPart::SimpleNumericExpression => "SIMPLE_NUMERIC_EXPRESSION",
        UnitPart::SolidAngleUnit => "SOLID_ANGLE_UNIT",
        UnitPart::SolidModel => "SOLID_MODEL",
        UnitPart::StartRequest { .. } => "START_REQUEST",
        UnitPart::StateObserved { .. } => "STATE_OBSERVED",
        UnitPart::StateType { .. } => "STATE_TYPE",
        UnitPart::StraightnessTolerance => "STRAIGHTNESS_TOLERANCE",
        UnitPart::StyledItem { .. } => "STYLED_ITEM",
        UnitPart::Surface => "SURFACE",
        UnitPart::SurfaceCurve { .. } => "SURFACE_CURVE",
        UnitPart::SurfaceProfileTolerance => "SURFACE_PROFILE_TOLERANCE",
        UnitPart::SurfaceSideStyle { .. } => "SURFACE_SIDE_STYLE",
        UnitPart::SurfaceStyleBoundary { .. } => "SURFACE_STYLE_BOUNDARY",
        UnitPart::SurfaceStyleControlGrid { .. } => "SURFACE_STYLE_CONTROL_GRID",
        UnitPart::SurfaceStyleFillArea { .. } => "SURFACE_STYLE_FILL_AREA",
        UnitPart::SurfaceStyleParameterLine { .. } => "SURFACE_STYLE_PARAMETER_LINE",
        UnitPart::SurfaceStyleReflectanceAmbient { .. } => "SURFACE_STYLE_REFLECTANCE_AMBIENT",
        UnitPart::SurfaceStyleRendering { .. } => "SURFACE_STYLE_RENDERING",
        UnitPart::SurfaceStyleRenderingWithProperties { .. } => {
            "SURFACE_STYLE_RENDERING_WITH_PROPERTIES"
        }
        UnitPart::SurfaceStyleSegmentationCurve { .. } => "SURFACE_STYLE_SEGMENTATION_CURVE",
        UnitPart::SurfaceStyleSilhouette { .. } => "SURFACE_STYLE_SILHOUETTE",
        UnitPart::SurfaceStyleUsage { .. } => "SURFACE_STYLE_USAGE",
        UnitPart::SymbolRepresentation => "SYMBOL_REPRESENTATION",
        UnitPart::SymbolStyle { .. } => "SYMBOL_STYLE",
        UnitPart::TerminatorSymbol { .. } => "TERMINATOR_SYMBOL",
        UnitPart::TessellatedGeometricSet { .. } => "TESSELLATED_GEOMETRIC_SET",
        UnitPart::TessellatedItem => "TESSELLATED_ITEM",
        UnitPart::TessellatedShapeRepresentation => "TESSELLATED_SHAPE_REPRESENTATION",
        UnitPart::TessellatedStructuredItem => "TESSELLATED_STRUCTURED_ITEM",
        UnitPart::TextLiteral { .. } => "TEXT_LITERAL",
        UnitPart::TextStyle { .. } => "TEXT_STYLE",
        UnitPart::TextStyleWithBoxCharacteristics { .. } => "TEXT_STYLE_WITH_BOX_CHARACTERISTICS",
        UnitPart::TextureStyleSpecification => "TEXTURE_STYLE_SPECIFICATION",
        UnitPart::TextureStyleTessellationSpecification => {
            "TEXTURE_STYLE_TESSELLATION_SPECIFICATION"
        }
        UnitPart::TimeUnit => "TIME_UNIT",
        UnitPart::ToleranceZone { .. } => "TOLERANCE_ZONE",
        UnitPart::ToleranceZoneDefinition { .. } => "TOLERANCE_ZONE_DEFINITION",
        UnitPart::ToleranceZoneWithDatum { .. } => "TOLERANCE_ZONE_WITH_DATUM",
        UnitPart::TopologicalRepresentationItem => "TOPOLOGICAL_REPRESENTATION_ITEM",
        UnitPart::ToroidalSurface { .. } => "TOROIDAL_SURFACE",
        UnitPart::TwoDirectionRepeatFactor { .. } => "TWO_DIRECTION_REPEAT_FACTOR",
        UnitPart::UnequallyDisposedGeometricTolerance { .. } => {
            "UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE"
        }
        UnitPart::UniformCurve => "UNIFORM_CURVE",
        UnitPart::UniformSurface => "UNIFORM_SURFACE",
        UnitPart::ValueRepresentationItem { .. } => "VALUE_REPRESENTATION_ITEM",
        UnitPart::Vector { .. } => "VECTOR",
        UnitPart::Vertex => "VERTEX",
        UnitPart::VertexPoint { .. } => "VERTEX_POINT",
        UnitPart::ViewVolume { .. } => "VIEW_VOLUME",
    }
}

/// `(part, AP242-legal, transitive supertypes)`, sorted by part name.
static PART_INFO: &[(&str, bool, &[&str])] = &[
    ("ACTION", true, &[]),
    ("ACTION_METHOD", true, &[]),
    ("ACTION_METHOD_RELATIONSHIP", true, &[]),
    ("ACTION_RELATIONSHIP", true, &[]),
    ("ACTION_REQUEST_ASSIGNMENT", true, &[]),
    ("ACTION_RESOURCE", true, &[]),
    ("ACTION_RESOURCE_REQUIREMENT", true, &[]),
    ("ADDRESS", true, &[]),
    (
        "ADVANCED_BREP_SHAPE_REPRESENTATION",
        true,
        &["REPRESENTATION", "SHAPE_REPRESENTATION"],
    ),
    (
        "ADVANCED_FACE",
        true,
        &[
            "FACE",
            "FACE_SURFACE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "TOPOLOGICAL_REPRESENTATION_ITEM",
        ],
    ),
    (
        "ANNOTATION_CURVE_OCCURRENCE",
        true,
        &[
            "ANNOTATION_OCCURRENCE",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
        ],
    ),
    (
        "ANNOTATION_FILL_AREA_OCCURRENCE",
        true,
        &[
            "ANNOTATION_OCCURRENCE",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
        ],
    ),
    (
        "ANNOTATION_OCCURRENCE",
        true,
        &["REPRESENTATION_ITEM", "STYLED_ITEM"],
    ),
    (
        "ANNOTATION_OCCURRENCE_ASSOCIATIVITY",
        true,
        &["ANNOTATION_OCCURRENCE_RELATIONSHIP"],
    ),
    ("ANNOTATION_OCCURRENCE_RELATIONSHIP", true, &[]),
    (
        "ANNOTATION_PLACEHOLDER_OCCURRENCE",
        true,
        &[
            "ANNOTATION_OCCURRENCE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
        ],
    ),
    (
        "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
        false,
        &[
            "ANNOTATION_OCCURRENCE",
            "ANNOTATION_PLACEHOLDER_OCCURRENCE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
        ],
    ),
    (
        "ANNOTATION_PLANE",
        true,
        &[
            "ANNOTATION_OCCURRENCE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
        ],
    ),
    (
        "ANNOTATION_SYMBOL",
        true,
        &["MAPPED_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "ANNOTATION_SYMBOL_OCCURRENCE",
        true,
        &[
            "ANNOTATION_OCCURRENCE",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
        ],
    ),
    (
        "ANNOTATION_TEXT",
        true,
        &["MAPPED_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "ANNOTATION_TEXT_CHARACTER",
        true,
        &["MAPPED_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "ANNOTATION_TEXT_OCCURRENCE",
        true,
        &[
            "ANNOTATION_OCCURRENCE",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
        ],
    ),
    ("APPLICATION_CONTEXT_ELEMENT", true, &[]),
    (
        "APPLIED_APPROVAL_ASSIGNMENT",
        true,
        &["APPROVAL_ASSIGNMENT"],
    ),
    (
        "APPLIED_DATE_AND_TIME_ASSIGNMENT",
        true,
        &["DATE_AND_TIME_ASSIGNMENT"],
    ),
    ("APPLIED_DOCUMENT_REFERENCE", true, &["DOCUMENT_REFERENCE"]),
    (
        "APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT",
        true,
        &[
            "EXTERNAL_IDENTIFICATION_ASSIGNMENT",
            "IDENTIFICATION_ASSIGNMENT",
        ],
    ),
    ("APPLIED_GROUP_ASSIGNMENT", true, &["GROUP_ASSIGNMENT"]),
    (
        "APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT",
        true,
        &["PERSON_AND_ORGANIZATION_ASSIGNMENT"],
    ),
    ("APPLIED_PRESENTED_ITEM", true, &["PRESENTED_ITEM"]),
    (
        "APPLIED_SECURITY_CLASSIFICATION_ASSIGNMENT",
        true,
        &["SECURITY_CLASSIFICATION_ASSIGNMENT"],
    ),
    ("APPROVAL_ASSIGNMENT", true, &[]),
    ("AREA_IN_SET", true, &[]),
    ("ASCRIBABLE_STATE_RELATIONSHIP", true, &[]),
    (
        "ASSEMBLY_COMPONENT_USAGE",
        true,
        &[
            "PRODUCT_DEFINITION_RELATIONSHIP",
            "PRODUCT_DEFINITION_USAGE",
        ],
    ),
    (
        "BEZIER_CURVE",
        true,
        &[
            "BOUNDED_CURVE",
            "B_SPLINE_CURVE",
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "BEZIER_SURFACE",
        true,
        &[
            "BOUNDED_SURFACE",
            "B_SPLINE_SURFACE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE",
        ],
    ),
    (
        "BOUNDED_CURVE",
        true,
        &[
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "BOUNDED_PCURVE",
        true,
        &[
            "BOUNDED_CURVE",
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "PCURVE",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "BOUNDED_SURFACE",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE",
        ],
    ),
    (
        "BOUNDED_SURFACE_CURVE",
        true,
        &[
            "BOUNDED_CURVE",
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE_CURVE",
        ],
    ),
    (
        "BREP_WITH_VOIDS",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "MANIFOLD_SOLID_BREP",
            "REPRESENTATION_ITEM",
            "SOLID_MODEL",
        ],
    ),
    (
        "B_SPLINE_CURVE",
        true,
        &[
            "BOUNDED_CURVE",
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "B_SPLINE_CURVE_WITH_KNOTS",
        true,
        &[
            "BOUNDED_CURVE",
            "B_SPLINE_CURVE",
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "B_SPLINE_SURFACE",
        true,
        &[
            "BOUNDED_SURFACE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE",
        ],
    ),
    (
        "B_SPLINE_SURFACE_WITH_KNOTS",
        true,
        &[
            "BOUNDED_SURFACE",
            "B_SPLINE_SURFACE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE",
        ],
    ),
    (
        "CAMERA_IMAGE",
        true,
        &["MAPPED_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "CAMERA_IMAGE_3D_WITH_SCALE",
        true,
        &["CAMERA_IMAGE", "MAPPED_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "CAMERA_MODEL",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "CAMERA_MODEL_D3",
        true,
        &[
            "CAMERA_MODEL",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "CAMERA_MODEL_D3_MULTI_CLIPPING",
        true,
        &[
            "CAMERA_MODEL",
            "CAMERA_MODEL_D3",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "CAMERA_MODEL_D3_WITH_HLHSR",
        true,
        &[
            "CAMERA_MODEL",
            "CAMERA_MODEL_D3",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    ("CAMERA_USAGE", true, &["REPRESENTATION_MAP"]),
    ("CC_DESIGN_APPROVAL", true, &["APPROVAL_ASSIGNMENT"]),
    (
        "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT",
        true,
        &["DATE_AND_TIME_ASSIGNMENT"],
    ),
    (
        "CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT",
        true,
        &["PERSON_AND_ORGANIZATION_ASSIGNMENT"],
    ),
    (
        "CC_DESIGN_SECURITY_CLASSIFICATION",
        true,
        &["SECURITY_CLASSIFICATION_ASSIGNMENT"],
    ),
    ("CHANGE_REQUEST", true, &["ACTION_REQUEST_ASSIGNMENT"]),
    (
        "CHARACTERIZED_ITEM_WITHIN_REPRESENTATION",
        true,
        &["CHARACTERIZED_OBJECT"],
    ),
    ("CHARACTERIZED_OBJECT", true, &[]),
    (
        "CHARACTERIZED_REPRESENTATION",
        true,
        &["CHARACTERIZED_OBJECT", "REPRESENTATION"],
    ),
    ("CHARACTER_GLYPH_STYLE_OUTLINE", true, &["FOUNDED_ITEM"]),
    ("CHARACTER_GLYPH_STYLE_STROKE", true, &["FOUNDED_ITEM"]),
    (
        "CIRCULAR_RUNOUT_TOLERANCE",
        true,
        &[
            "GEOMETRIC_TOLERANCE",
            "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
        ],
    ),
    (
        "CLOSED_SHELL",
        true,
        &[
            "CONNECTED_FACE_SET",
            "REPRESENTATION_ITEM",
            "TOPOLOGICAL_REPRESENTATION_ITEM",
        ],
    ),
    ("COLOUR", true, &[]),
    ("COLOUR_RGB", true, &["COLOUR", "COLOUR_SPECIFICATION"]),
    ("COLOUR_SPECIFICATION", true, &["COLOUR"]),
    (
        "COMMON_DATUM",
        true,
        &["COMPOSITE_SHAPE_ASPECT", "DATUM", "SHAPE_ASPECT"],
    ),
    (
        "COMPOSITE_CURVE",
        true,
        &[
            "BOUNDED_CURVE",
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    ("COMPOSITE_CURVE_SEGMENT", true, &["FOUNDED_ITEM"]),
    (
        "COMPOSITE_GROUP_SHAPE_ASPECT",
        true,
        &["COMPOSITE_SHAPE_ASPECT", "SHAPE_ASPECT"],
    ),
    ("COMPOSITE_SHAPE_ASPECT", true, &["SHAPE_ASPECT"]),
    (
        "COMPOSITE_TEXT",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "COMPOUND_REPRESENTATION_ITEM",
        true,
        &["REPRESENTATION_ITEM"],
    ),
    (
        "CONFIGURATION_EFFECTIVITY",
        true,
        &["EFFECTIVITY", "PRODUCT_DEFINITION_EFFECTIVITY"],
    ),
    ("CONFIGURATION_ITEM", true, &[]),
    (
        "CONNECTED_FACE_SET",
        true,
        &["REPRESENTATION_ITEM", "TOPOLOGICAL_REPRESENTATION_ITEM"],
    ),
    (
        "CONSTRUCTIVE_GEOMETRY_REPRESENTATION_RELATIONSHIP",
        true,
        &["REPRESENTATION_RELATIONSHIP"],
    ),
    (
        "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
        true,
        &[
            "OVER_RIDING_STYLED_ITEM",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
        ],
    ),
    ("CONTEXT_DEPENDENT_UNIT", true, &["NAMED_UNIT"]),
    ("CONVERSION_BASED_UNIT", true, &["NAMED_UNIT"]),
    (
        "CURVE",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    ("CURVE_STYLE", true, &["FOUNDED_ITEM"]),
    ("CURVE_STYLE_FONT", true, &["FOUNDED_ITEM"]),
    ("CURVE_STYLE_FONT_AND_SCALING", true, &["FOUNDED_ITEM"]),
    ("CURVE_STYLE_FONT_PATTERN", true, &["FOUNDED_ITEM"]),
    ("CYLINDRICITY_TOLERANCE", true, &["GEOMETRIC_TOLERANCE"]),
    ("DATE", true, &[]),
    ("DATE_AND_TIME", true, &[]),
    ("DATE_AND_TIME_ASSIGNMENT", true, &[]),
    ("DATUM", true, &["SHAPE_ASPECT"]),
    ("DATUM_FEATURE", true, &["SHAPE_ASPECT"]),
    ("DATUM_REFERENCE", true, &[]),
    ("DATUM_SYSTEM", true, &["SHAPE_ASPECT"]),
    ("DATUM_TARGET", true, &["SHAPE_ASPECT"]),
    (
        "DEFAULT_MODEL_GEOMETRIC_VIEW",
        true,
        &[
            "CHARACTERIZED_ITEM_WITHIN_REPRESENTATION",
            "CHARACTERIZED_OBJECT",
            "MODEL_GEOMETRIC_VIEW",
            "SHAPE_ASPECT",
        ],
    ),
    ("DEFINITIONAL_REPRESENTATION", true, &["REPRESENTATION"]),
    (
        "DEFINITIONAL_REPRESENTATION_RELATIONSHIP",
        true,
        &["REPRESENTATION_RELATIONSHIP"],
    ),
    (
        "DEFINITIONAL_REPRESENTATION_RELATIONSHIP_WITH_SAME_CONTEXT",
        true,
        &[
            "DEFINITIONAL_REPRESENTATION_RELATIONSHIP",
            "REPRESENTATION_RELATIONSHIP",
        ],
    ),
    (
        "DEGENERATE_TOROIDAL_SURFACE",
        true,
        &[
            "ELEMENTARY_SURFACE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE",
            "TOROIDAL_SURFACE",
        ],
    ),
    ("DERIVED_UNIT", true, &[]),
    (
        "DESIGN_CONTEXT",
        true,
        &["APPLICATION_CONTEXT_ELEMENT", "PRODUCT_DEFINITION_CONTEXT"],
    ),
    ("DIMENSIONAL_SIZE", true, &[]),
    (
        "DIRECTION",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    ("DOCUMENT", true, &[]),
    ("DOCUMENT_FILE", true, &["CHARACTERIZED_OBJECT", "DOCUMENT"]),
    ("DOCUMENT_PRODUCT_ASSOCIATION", true, &[]),
    (
        "DOCUMENT_PRODUCT_EQUIVALENCE",
        true,
        &["DOCUMENT_PRODUCT_ASSOCIATION"],
    ),
    ("DOCUMENT_REFERENCE", true, &[]),
    (
        "DRAUGHTING_ANNOTATION_OCCURRENCE",
        true,
        &[
            "ANNOTATION_OCCURRENCE",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
        ],
    ),
    (
        "DRAUGHTING_CALLOUT",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    ("DRAUGHTING_CALLOUT_RELATIONSHIP", true, &[]),
    ("DRAUGHTING_MODEL", true, &["REPRESENTATION"]),
    (
        "DRAUGHTING_MODEL_ITEM_ASSOCIATION",
        true,
        &["ITEM_IDENTIFIED_REPRESENTATION_USAGE"],
    ),
    (
        "DRAUGHTING_MODEL_ITEM_ASSOCIATION_WITH_PLACEHOLDER",
        true,
        &[
            "DRAUGHTING_MODEL_ITEM_ASSOCIATION",
            "ITEM_IDENTIFIED_REPRESENTATION_USAGE",
        ],
    ),
    (
        "DRAUGHTING_PRE_DEFINED_COLOUR",
        true,
        &["COLOUR", "PRE_DEFINED_COLOUR", "PRE_DEFINED_ITEM"],
    ),
    (
        "DRAUGHTING_PRE_DEFINED_CURVE_FONT",
        true,
        &["PRE_DEFINED_CURVE_FONT", "PRE_DEFINED_ITEM"],
    ),
    (
        "DRAUGHTING_PRE_DEFINED_TEXT_FONT",
        true,
        &["PRE_DEFINED_ITEM", "PRE_DEFINED_TEXT_FONT"],
    ),
    (
        "EDGE",
        true,
        &["REPRESENTATION_ITEM", "TOPOLOGICAL_REPRESENTATION_ITEM"],
    ),
    (
        "EDGE_CURVE",
        true,
        &[
            "EDGE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "TOPOLOGICAL_REPRESENTATION_ITEM",
        ],
    ),
    (
        "EDGE_LOOP",
        true,
        &[
            "LOOP",
            "PATH",
            "REPRESENTATION_ITEM",
            "TOPOLOGICAL_REPRESENTATION_ITEM",
        ],
    ),
    ("EFFECTIVITY", true, &[]),
    (
        "ELEMENTARY_SURFACE",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE",
        ],
    ),
    ("EXPRESSION", true, &["GENERIC_EXPRESSION"]),
    (
        "EXTERNALLY_DEFINED_CHARACTER_GLYPH",
        true,
        &["EXTERNALLY_DEFINED_ITEM"],
    ),
    (
        "EXTERNALLY_DEFINED_CURVE_FONT",
        true,
        &["EXTERNALLY_DEFINED_ITEM"],
    ),
    (
        "EXTERNALLY_DEFINED_HATCH_STYLE",
        true,
        &[
            "EXTERNALLY_DEFINED_ITEM",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    ("EXTERNALLY_DEFINED_ITEM", true, &[]),
    (
        "EXTERNALLY_DEFINED_STYLE",
        true,
        &["EXTERNALLY_DEFINED_ITEM", "FOUNDED_ITEM"],
    ),
    (
        "EXTERNALLY_DEFINED_SYMBOL",
        true,
        &["EXTERNALLY_DEFINED_ITEM"],
    ),
    (
        "EXTERNALLY_DEFINED_TEXT_FONT",
        true,
        &["EXTERNALLY_DEFINED_ITEM"],
    ),
    (
        "EXTERNALLY_DEFINED_TILE",
        true,
        &["EXTERNALLY_DEFINED_ITEM"],
    ),
    (
        "EXTERNALLY_DEFINED_TILE_STYLE",
        true,
        &[
            "EXTERNALLY_DEFINED_ITEM",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "EXTERNAL_IDENTIFICATION_ASSIGNMENT",
        true,
        &["IDENTIFICATION_ASSIGNMENT"],
    ),
    ("EXTERNAL_SOURCE", true, &[]),
    (
        "FACE",
        true,
        &["REPRESENTATION_ITEM", "TOPOLOGICAL_REPRESENTATION_ITEM"],
    ),
    (
        "FACE_BOUND",
        true,
        &["REPRESENTATION_ITEM", "TOPOLOGICAL_REPRESENTATION_ITEM"],
    ),
    (
        "FACE_OUTER_BOUND",
        true,
        &[
            "FACE_BOUND",
            "REPRESENTATION_ITEM",
            "TOPOLOGICAL_REPRESENTATION_ITEM",
        ],
    ),
    (
        "FACE_SURFACE",
        true,
        &[
            "FACE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "TOPOLOGICAL_REPRESENTATION_ITEM",
        ],
    ),
    ("FILL_AREA_STYLE", true, &["FOUNDED_ITEM"]),
    (
        "FILL_AREA_STYLE_HATCHING",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "FILL_AREA_STYLE_TILES",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    ("FLATNESS_TOLERANCE", true, &["GEOMETRIC_TOLERANCE"]),
    ("FOUNDED_ITEM", true, &[]),
    ("FUNCTIONALLY_DEFINED_TRANSFORMATION", true, &[]),
    ("GENERAL_DATUM_REFERENCE", true, &["SHAPE_ASPECT"]),
    ("GENERAL_PROPERTY", true, &[]),
    ("GENERIC_EXPRESSION", true, &[]),
    (
        "GENERIC_LITERAL",
        true,
        &["GENERIC_EXPRESSION", "SIMPLE_GENERIC_EXPRESSION"],
    ),
    ("GENERIC_PRODUCT_DEFINITION_REFERENCE", true, &[]),
    (
        "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
        true,
        &["REPRESENTATION", "SHAPE_REPRESENTATION"],
    ),
    (
        "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
        true,
        &["REPRESENTATION", "SHAPE_REPRESENTATION"],
    ),
    (
        "GEOMETRIC_CURVE_SET",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "GEOMETRIC_SET",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "GEOMETRIC_ITEM_SPECIFIC_USAGE",
        true,
        &["ITEM_IDENTIFIED_REPRESENTATION_USAGE"],
    ),
    (
        "GEOMETRIC_REPRESENTATION_CONTEXT",
        true,
        &["REPRESENTATION_CONTEXT"],
    ),
    (
        "GEOMETRIC_REPRESENTATION_ITEM",
        true,
        &["REPRESENTATION_ITEM"],
    ),
    (
        "GEOMETRIC_SET",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    ("GEOMETRIC_TOLERANCE", true, &[]),
    (
        "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
        true,
        &["GEOMETRIC_TOLERANCE"],
    ),
    (
        "GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT",
        true,
        &[
            "GEOMETRIC_TOLERANCE",
            "GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT",
        ],
    ),
    (
        "GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT",
        true,
        &["GEOMETRIC_TOLERANCE"],
    ),
    (
        "GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE",
        true,
        &["GEOMETRIC_TOLERANCE", "GEOMETRIC_TOLERANCE_WITH_MODIFIERS"],
    ),
    (
        "GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
        true,
        &["GEOMETRIC_TOLERANCE"],
    ),
    (
        "GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT",
        true,
        &["REPRESENTATION_CONTEXT"],
    ),
    (
        "GLOBAL_UNIT_ASSIGNED_CONTEXT",
        true,
        &["REPRESENTATION_CONTEXT"],
    ),
    ("GROUP", true, &[]),
    ("GROUP_ASSIGNMENT", true, &[]),
    ("IDENTIFICATION_ASSIGNMENT", true, &[]),
    (
        "INTEGER_REPRESENTATION_ITEM",
        true,
        &[
            "EXPRESSION",
            "GENERIC_EXPRESSION",
            "GENERIC_LITERAL",
            "INT_LITERAL",
            "LITERAL_NUMBER",
            "NUMERIC_EXPRESSION",
            "REPRESENTATION_ITEM",
            "SIMPLE_GENERIC_EXPRESSION",
            "SIMPLE_NUMERIC_EXPRESSION",
        ],
    ),
    (
        "INTERSECTION_CURVE",
        true,
        &[
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE_CURVE",
        ],
    ),
    (
        "INT_LITERAL",
        true,
        &[
            "EXPRESSION",
            "GENERIC_EXPRESSION",
            "GENERIC_LITERAL",
            "LITERAL_NUMBER",
            "NUMERIC_EXPRESSION",
            "SIMPLE_GENERIC_EXPRESSION",
            "SIMPLE_NUMERIC_EXPRESSION",
        ],
    ),
    ("INVISIBILITY", true, &[]),
    ("ITEM_DEFINED_TRANSFORMATION", true, &[]),
    ("ITEM_IDENTIFIED_REPRESENTATION_USAGE", true, &[]),
    (
        "LEADER_CURVE",
        true,
        &[
            "ANNOTATION_CURVE_OCCURRENCE",
            "ANNOTATION_OCCURRENCE",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
        ],
    ),
    (
        "LEADER_DIRECTED_CALLOUT",
        true,
        &[
            "DRAUGHTING_CALLOUT",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "LEADER_TERMINATOR",
        true,
        &[
            "ANNOTATION_OCCURRENCE",
            "ANNOTATION_SYMBOL_OCCURRENCE",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
            "TERMINATOR_SYMBOL",
        ],
    ),
    ("LENGTH_MEASURE_WITH_UNIT", true, &["MEASURE_WITH_UNIT"]),
    ("LENGTH_UNIT", true, &["NAMED_UNIT"]),
    ("LINE_PROFILE_TOLERANCE", true, &["GEOMETRIC_TOLERANCE"]),
    (
        "LITERAL_NUMBER",
        true,
        &[
            "EXPRESSION",
            "GENERIC_EXPRESSION",
            "GENERIC_LITERAL",
            "NUMERIC_EXPRESSION",
            "SIMPLE_GENERIC_EXPRESSION",
            "SIMPLE_NUMERIC_EXPRESSION",
        ],
    ),
    (
        "LOOP",
        true,
        &["REPRESENTATION_ITEM", "TOPOLOGICAL_REPRESENTATION_ITEM"],
    ),
    (
        "MANIFOLD_SOLID_BREP",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SOLID_MODEL",
        ],
    ),
    (
        "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
        true,
        &["REPRESENTATION", "SHAPE_REPRESENTATION"],
    ),
    ("MAPPED_ITEM", true, &["REPRESENTATION_ITEM"]),
    ("MASS_UNIT", true, &["NAMED_UNIT"]),
    (
        "MEASURE_REPRESENTATION_ITEM",
        true,
        &["MEASURE_WITH_UNIT", "REPRESENTATION_ITEM"],
    ),
    ("MEASURE_WITH_UNIT", true, &[]),
    (
        "MECHANICAL_CONTEXT",
        true,
        &["APPLICATION_CONTEXT_ELEMENT", "PRODUCT_CONTEXT"],
    ),
    (
        "MECHANICAL_DESIGN_AND_DRAUGHTING_RELATIONSHIP",
        true,
        &[
            "DEFINITIONAL_REPRESENTATION_RELATIONSHIP",
            "DEFINITIONAL_REPRESENTATION_RELATIONSHIP_WITH_SAME_CONTEXT",
            "REPRESENTATION_RELATIONSHIP",
        ],
    ),
    (
        "MODEL_GEOMETRIC_VIEW",
        true,
        &[
            "CHARACTERIZED_ITEM_WITHIN_REPRESENTATION",
            "CHARACTERIZED_OBJECT",
        ],
    ),
    (
        "MODIFIED_GEOMETRIC_TOLERANCE",
        true,
        &["GEOMETRIC_TOLERANCE"],
    ),
    ("NAMED_UNIT", true, &[]),
    (
        "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
        true,
        &[
            "ASSEMBLY_COMPONENT_USAGE",
            "PRODUCT_DEFINITION_RELATIONSHIP",
            "PRODUCT_DEFINITION_USAGE",
        ],
    ),
    (
        "NUMERIC_EXPRESSION",
        true,
        &["EXPRESSION", "GENERIC_EXPRESSION"],
    ),
    (
        "ONE_DIRECTION_REPEAT_FACTOR",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "OPEN_SHELL",
        true,
        &[
            "CONNECTED_FACE_SET",
            "REPRESENTATION_ITEM",
            "TOPOLOGICAL_REPRESENTATION_ITEM",
        ],
    ),
    ("ORGANIZATIONAL_ADDRESS", true, &["ADDRESS"]),
    (
        "ORIENTED_CLOSED_SHELL",
        true,
        &[
            "CLOSED_SHELL",
            "CONNECTED_FACE_SET",
            "REPRESENTATION_ITEM",
            "TOPOLOGICAL_REPRESENTATION_ITEM",
        ],
    ),
    (
        "ORIENTED_EDGE",
        true,
        &[
            "EDGE",
            "REPRESENTATION_ITEM",
            "TOPOLOGICAL_REPRESENTATION_ITEM",
        ],
    ),
    (
        "OVER_RIDING_STYLED_ITEM",
        true,
        &["REPRESENTATION_ITEM", "STYLED_ITEM"],
    ),
    (
        "PARALLELISM_TOLERANCE",
        true,
        &[
            "GEOMETRIC_TOLERANCE",
            "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
        ],
    ),
    (
        "PARAMETRIC_REPRESENTATION_CONTEXT",
        true,
        &["REPRESENTATION_CONTEXT"],
    ),
    (
        "PATH",
        true,
        &["REPRESENTATION_ITEM", "TOPOLOGICAL_REPRESENTATION_ITEM"],
    ),
    (
        "PCURVE",
        true,
        &[
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "PERPENDICULARITY_TOLERANCE",
        true,
        &[
            "GEOMETRIC_TOLERANCE",
            "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
        ],
    ),
    ("PERSONAL_ADDRESS", true, &["ADDRESS"]),
    (
        "PERSON_AND_ORGANIZATION_ADDRESS",
        true,
        &["ADDRESS", "ORGANIZATIONAL_ADDRESS", "PERSONAL_ADDRESS"],
    ),
    ("PERSON_AND_ORGANIZATION_ASSIGNMENT", true, &[]),
    (
        "PLACED_DATUM_TARGET_FEATURE",
        true,
        &["DATUM_TARGET", "SHAPE_ASPECT"],
    ),
    (
        "PLACEMENT",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "PLANAR_BOX",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "PLANAR_EXTENT",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "PLANAR_EXTENT",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "PLANE_ANGLE_MEASURE_WITH_UNIT",
        true,
        &["MEASURE_WITH_UNIT"],
    ),
    ("PLANE_ANGLE_UNIT", true, &["NAMED_UNIT"]),
    (
        "POINT",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    ("POINT_STYLE", true, &["FOUNDED_ITEM"]),
    (
        "POLY_LOOP",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "LOOP",
            "REPRESENTATION_ITEM",
            "TOPOLOGICAL_REPRESENTATION_ITEM",
        ],
    ),
    ("POSITION_TOLERANCE", true, &["GEOMETRIC_TOLERANCE"]),
    (
        "PRESENTATION_AREA",
        true,
        &["PRESENTATION_REPRESENTATION", "REPRESENTATION"],
    ),
    ("PRESENTATION_REPRESENTATION", true, &["REPRESENTATION"]),
    ("PRESENTATION_SET", true, &[]),
    ("PRESENTATION_STYLE_ASSIGNMENT", true, &["FOUNDED_ITEM"]),
    (
        "PRESENTATION_STYLE_BY_CONTEXT",
        true,
        &["FOUNDED_ITEM", "PRESENTATION_STYLE_ASSIGNMENT"],
    ),
    (
        "PRESENTATION_VIEW",
        true,
        &["PRESENTATION_REPRESENTATION", "REPRESENTATION"],
    ),
    ("PRESENTED_ITEM", true, &[]),
    ("PRE_DEFINED_CHARACTER_GLYPH", true, &["PRE_DEFINED_ITEM"]),
    ("PRE_DEFINED_COLOUR", true, &["COLOUR", "PRE_DEFINED_ITEM"]),
    ("PRE_DEFINED_CURVE_FONT", true, &["PRE_DEFINED_ITEM"]),
    ("PRE_DEFINED_ITEM", true, &[]),
    ("PRE_DEFINED_MARKER", true, &["PRE_DEFINED_ITEM"]),
    (
        "PRE_DEFINED_POINT_MARKER_SYMBOL",
        true,
        &[
            "PRE_DEFINED_ITEM",
            "PRE_DEFINED_MARKER",
            "PRE_DEFINED_SYMBOL",
        ],
    ),
    (
        "PRE_DEFINED_PRESENTATION_STYLE",
        false,
        &["FOUNDED_ITEM", "PRE_DEFINED_ITEM"],
    ),
    (
        "PRE_DEFINED_SURFACE_SIDE_STYLE",
        true,
        &["PRE_DEFINED_ITEM"],
    ),
    ("PRE_DEFINED_SYMBOL", true, &["PRE_DEFINED_ITEM"]),
    (
        "PRE_DEFINED_TERMINATOR_SYMBOL",
        true,
        &["PRE_DEFINED_ITEM", "PRE_DEFINED_SYMBOL"],
    ),
    ("PRE_DEFINED_TEXT_FONT", true, &["PRE_DEFINED_ITEM"]),
    ("PRE_DEFINED_TILE", true, &["PRE_DEFINED_ITEM"]),
    ("PRODUCT", true, &[]),
    ("PRODUCT_CATEGORY", true, &[]),
    ("PRODUCT_CONCEPT", true, &[]),
    ("PRODUCT_CONCEPT_FEATURE", true, &[]),
    ("PRODUCT_CONCEPT_FEATURE_CATEGORY", true, &["GROUP"]),
    ("PRODUCT_CONTEXT", true, &["APPLICATION_CONTEXT_ELEMENT"]),
    ("PRODUCT_DEFINITION", true, &[]),
    (
        "PRODUCT_DEFINITION_CONTEXT",
        true,
        &["APPLICATION_CONTEXT_ELEMENT"],
    ),
    ("PRODUCT_DEFINITION_EFFECTIVITY", true, &["EFFECTIVITY"]),
    ("PRODUCT_DEFINITION_FORMATION", true, &[]),
    (
        "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
        true,
        &["PRODUCT_DEFINITION_FORMATION"],
    ),
    ("PRODUCT_DEFINITION_OCCURRENCE", true, &[]),
    ("PRODUCT_DEFINITION_RELATIONSHIP", true, &[]),
    ("PRODUCT_DEFINITION_RELATIONSHIP_RELATIONSHIP", true, &[]),
    ("PRODUCT_DEFINITION_SHAPE", true, &["PROPERTY_DEFINITION"]),
    (
        "PRODUCT_DEFINITION_USAGE",
        true,
        &["PRODUCT_DEFINITION_RELATIONSHIP"],
    ),
    (
        "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
        true,
        &["PRODUCT_DEFINITION"],
    ),
    (
        "PRODUCT_RELATED_PRODUCT_CATEGORY",
        true,
        &["PRODUCT_CATEGORY"],
    ),
    (
        "PROJECTED_ZONE_DEFINITION",
        true,
        &["TOLERANCE_ZONE_DEFINITION"],
    ),
    ("PROPERTY_DEFINITION", true, &[]),
    ("PROPERTY_DEFINITION_REPRESENTATION", true, &[]),
    (
        "QUALIFIED_REPRESENTATION_ITEM",
        true,
        &["REPRESENTATION_ITEM"],
    ),
    (
        "QUASI_UNIFORM_CURVE",
        true,
        &[
            "BOUNDED_CURVE",
            "B_SPLINE_CURVE",
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "QUASI_UNIFORM_SURFACE",
        true,
        &[
            "BOUNDED_SURFACE",
            "B_SPLINE_SURFACE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE",
        ],
    ),
    (
        "RATIONAL_B_SPLINE_CURVE",
        true,
        &[
            "BOUNDED_CURVE",
            "B_SPLINE_CURVE",
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "RATIONAL_B_SPLINE_SURFACE",
        true,
        &[
            "BOUNDED_SURFACE",
            "B_SPLINE_SURFACE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE",
        ],
    ),
    ("RATIO_MEASURE_WITH_UNIT", true, &["MEASURE_WITH_UNIT"]),
    ("RATIO_UNIT", true, &["NAMED_UNIT"]),
    (
        "REAL_LITERAL",
        true,
        &[
            "EXPRESSION",
            "GENERIC_EXPRESSION",
            "GENERIC_LITERAL",
            "LITERAL_NUMBER",
            "NUMERIC_EXPRESSION",
            "SIMPLE_GENERIC_EXPRESSION",
            "SIMPLE_NUMERIC_EXPRESSION",
        ],
    ),
    (
        "REAL_REPRESENTATION_ITEM",
        true,
        &[
            "EXPRESSION",
            "GENERIC_EXPRESSION",
            "GENERIC_LITERAL",
            "LITERAL_NUMBER",
            "NUMERIC_EXPRESSION",
            "REAL_LITERAL",
            "REPRESENTATION_ITEM",
            "SIMPLE_GENERIC_EXPRESSION",
            "SIMPLE_NUMERIC_EXPRESSION",
        ],
    ),
    (
        "REPOSITIONED_TESSELLATED_ITEM",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "TESSELLATED_ITEM",
        ],
    ),
    ("REPRESENTATION", true, &[]),
    ("REPRESENTATION_CONTEXT", true, &[]),
    ("REPRESENTATION_ITEM", true, &[]),
    ("REPRESENTATION_MAP", true, &[]),
    ("REPRESENTATION_REFERENCE", true, &[]),
    ("REPRESENTATION_RELATIONSHIP", true, &[]),
    (
        "REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION",
        true,
        &["REPRESENTATION_RELATIONSHIP"],
    ),
    ("ROUNDNESS_TOLERANCE", true, &["GEOMETRIC_TOLERANCE"]),
    (
        "SEAM_CURVE",
        true,
        &[
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE_CURVE",
        ],
    ),
    ("SECURITY_CLASSIFICATION_ASSIGNMENT", true, &[]),
    ("SHAPE_ASPECT", true, &[]),
    ("SHAPE_ASPECT_RELATIONSHIP", true, &[]),
    (
        "SHAPE_DEFINITION_REPRESENTATION",
        true,
        &["PROPERTY_DEFINITION_REPRESENTATION"],
    ),
    (
        "SHAPE_DIMENSION_REPRESENTATION",
        true,
        &["REPRESENTATION", "SHAPE_REPRESENTATION"],
    ),
    ("SHAPE_REPRESENTATION", true, &["REPRESENTATION"]),
    (
        "SHAPE_REPRESENTATION_RELATIONSHIP",
        true,
        &["REPRESENTATION_RELATIONSHIP"],
    ),
    (
        "SHAPE_REPRESENTATION_WITH_PARAMETERS",
        true,
        &["REPRESENTATION", "SHAPE_REPRESENTATION"],
    ),
    (
        "SHELL_BASED_SURFACE_MODEL",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    ("SIMPLE_GENERIC_EXPRESSION", true, &["GENERIC_EXPRESSION"]),
    (
        "SIMPLE_NUMERIC_EXPRESSION",
        true,
        &[
            "EXPRESSION",
            "GENERIC_EXPRESSION",
            "NUMERIC_EXPRESSION",
            "SIMPLE_GENERIC_EXPRESSION",
        ],
    ),
    ("SI_UNIT", true, &["NAMED_UNIT"]),
    ("SOLID_ANGLE_UNIT", true, &["NAMED_UNIT"]),
    (
        "SOLID_MODEL",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    ("START_REQUEST", true, &["ACTION_REQUEST_ASSIGNMENT"]),
    ("STATE_OBSERVED", true, &[]),
    ("STATE_TYPE", true, &[]),
    ("STRAIGHTNESS_TOLERANCE", true, &["GEOMETRIC_TOLERANCE"]),
    ("STYLED_ITEM", true, &["REPRESENTATION_ITEM"]),
    (
        "SURFACE",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "SURFACE_CURVE",
        true,
        &[
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    ("SURFACE_PROFILE_TOLERANCE", true, &["GEOMETRIC_TOLERANCE"]),
    ("SURFACE_SIDE_STYLE", true, &["FOUNDED_ITEM"]),
    ("SURFACE_STYLE_BOUNDARY", true, &["FOUNDED_ITEM"]),
    ("SURFACE_STYLE_CONTROL_GRID", true, &["FOUNDED_ITEM"]),
    ("SURFACE_STYLE_FILL_AREA", true, &["FOUNDED_ITEM"]),
    ("SURFACE_STYLE_PARAMETER_LINE", true, &["FOUNDED_ITEM"]),
    ("SURFACE_STYLE_REFLECTANCE_AMBIENT", true, &[]),
    ("SURFACE_STYLE_RENDERING", true, &[]),
    (
        "SURFACE_STYLE_RENDERING_WITH_PROPERTIES",
        true,
        &["SURFACE_STYLE_RENDERING"],
    ),
    ("SURFACE_STYLE_SEGMENTATION_CURVE", true, &["FOUNDED_ITEM"]),
    ("SURFACE_STYLE_SILHOUETTE", true, &["FOUNDED_ITEM"]),
    ("SURFACE_STYLE_USAGE", true, &["FOUNDED_ITEM"]),
    ("SYMBOL_REPRESENTATION", true, &["REPRESENTATION"]),
    ("SYMBOL_STYLE", true, &["FOUNDED_ITEM"]),
    (
        "TERMINATOR_SYMBOL",
        true,
        &[
            "ANNOTATION_OCCURRENCE",
            "ANNOTATION_SYMBOL_OCCURRENCE",
            "REPRESENTATION_ITEM",
            "STYLED_ITEM",
        ],
    ),
    (
        "TESSELLATED_GEOMETRIC_SET",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "TESSELLATED_ITEM",
        ],
    ),
    (
        "TESSELLATED_ITEM",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "TESSELLATED_SHAPE_REPRESENTATION",
        true,
        &["REPRESENTATION", "SHAPE_REPRESENTATION"],
    ),
    (
        "TESSELLATED_STRUCTURED_ITEM",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "TESSELLATED_ITEM",
        ],
    ),
    ("TEXTURE_STYLE_SPECIFICATION", true, &["FOUNDED_ITEM"]),
    (
        "TEXTURE_STYLE_TESSELLATION_SPECIFICATION",
        true,
        &["FOUNDED_ITEM", "TEXTURE_STYLE_SPECIFICATION"],
    ),
    (
        "TEXT_LITERAL",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    ("TEXT_STYLE", true, &["FOUNDED_ITEM"]),
    (
        "TEXT_STYLE_WITH_BOX_CHARACTERISTICS",
        true,
        &["FOUNDED_ITEM", "TEXT_STYLE"],
    ),
    ("TIME_UNIT", true, &["NAMED_UNIT"]),
    ("TOLERANCE_ZONE", true, &["SHAPE_ASPECT"]),
    ("TOLERANCE_ZONE_DEFINITION", true, &[]),
    (
        "TOLERANCE_ZONE_WITH_DATUM",
        true,
        &["SHAPE_ASPECT", "TOLERANCE_ZONE"],
    ),
    (
        "TOPOLOGICAL_REPRESENTATION_ITEM",
        true,
        &["REPRESENTATION_ITEM"],
    ),
    (
        "TOROIDAL_SURFACE",
        true,
        &[
            "ELEMENTARY_SURFACE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE",
        ],
    ),
    (
        "TWO_DIRECTION_REPEAT_FACTOR",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "ONE_DIRECTION_REPEAT_FACTOR",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE",
        true,
        &["GEOMETRIC_TOLERANCE"],
    ),
    (
        "UNIFORM_CURVE",
        true,
        &[
            "BOUNDED_CURVE",
            "B_SPLINE_CURVE",
            "CURVE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
        ],
    ),
    (
        "UNIFORM_SURFACE",
        true,
        &[
            "BOUNDED_SURFACE",
            "B_SPLINE_SURFACE",
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "SURFACE",
        ],
    ),
    ("VALUE_REPRESENTATION_ITEM", true, &["REPRESENTATION_ITEM"]),
    (
        "VECTOR",
        true,
        &["GEOMETRIC_REPRESENTATION_ITEM", "REPRESENTATION_ITEM"],
    ),
    (
        "VERTEX",
        true,
        &["REPRESENTATION_ITEM", "TOPOLOGICAL_REPRESENTATION_ITEM"],
    ),
    (
        "VERTEX_POINT",
        true,
        &[
            "GEOMETRIC_REPRESENTATION_ITEM",
            "REPRESENTATION_ITEM",
            "TOPOLOGICAL_REPRESENTATION_ITEM",
            "VERTEX",
        ],
    ),
    ("VIEW_VOLUME", true, &["FOUNDED_ITEM"]),
];

/// ONEOF exclusivity groups: a part bag may intersect at most one
/// branch per group.
static ONEOF_GROUPS: &[&[&[&str]]] = &[
    &[
        &["ANNOTATION_CURVE_OCCURRENCE"],
        &["ANNOTATION_FILL_AREA_OCCURRENCE"],
        &["ANNOTATION_TEXT_OCCURRENCE"],
        &["ANNOTATION_SYMBOL_OCCURRENCE"],
    ],
    &[
        &["ANNOTATION_CURVE_OCCURRENCE"],
        &["ANNOTATION_FILL_AREA_OCCURRENCE"],
        &["ANNOTATION_PLANE"],
        &["ANNOTATION_SYMBOL_OCCURRENCE"],
        &["ANNOTATION_TEXT_OCCURRENCE"],
    ],
    &[&["PRODUCT_CONTEXT"], &["PRODUCT_DEFINITION_CONTEXT"]],
    &[
        &["UNIFORM_CURVE"],
        &["B_SPLINE_CURVE_WITH_KNOTS"],
        &["QUASI_UNIFORM_CURVE"],
        &["BEZIER_CURVE"],
    ],
    &[
        &["B_SPLINE_SURFACE_WITH_KNOTS"],
        &["UNIFORM_SURFACE"],
        &["QUASI_UNIFORM_SURFACE"],
        &["BEZIER_SURFACE"],
    ],
    &[
        &["B_SPLINE_CURVE"],
        &["BOUNDED_PCURVE"],
        &["BOUNDED_SURFACE_CURVE"],
        &["COMPOSITE_CURVE"],
    ],
    &[&["COMMON_DATUM"], &["COMPOSITE_GROUP_SHAPE_ASPECT"]],
    &[&["CLOSED_SHELL"], &["OPEN_SHELL"]],
    &[&["PCURVE"], &["SURFACE_CURVE"]],
    &[&["EDGE_CURVE"], &["ORIENTED_EDGE"]],
    &[
        &["CHARACTER_GLYPH_STYLE_OUTLINE"],
        &["CHARACTER_GLYPH_STYLE_STROKE"],
        &["COMPOSITE_CURVE_SEGMENT"],
        &["CURVE_STYLE"],
        &["CURVE_STYLE_FONT"],
        &["CURVE_STYLE_FONT_AND_SCALING"],
        &["CURVE_STYLE_FONT_PATTERN"],
        &["EXTERNALLY_DEFINED_STYLE"],
        &["FILL_AREA_STYLE"],
        &["POINT_STYLE"],
        &["PRESENTATION_STYLE_ASSIGNMENT"],
        &["SURFACE_SIDE_STYLE"],
        &["SURFACE_STYLE_BOUNDARY"],
        &["SURFACE_STYLE_CONTROL_GRID"],
        &["SURFACE_STYLE_FILL_AREA"],
        &["SURFACE_STYLE_PARAMETER_LINE"],
        &["SURFACE_STYLE_SEGMENTATION_CURVE"],
        &["SURFACE_STYLE_SILHOUETTE"],
        &["SURFACE_STYLE_USAGE"],
        &["SYMBOL_STYLE"],
        &["TEXT_STYLE"],
        &["VIEW_VOLUME"],
    ],
    &[
        &["CHARACTER_GLYPH_STYLE_OUTLINE"],
        &["CHARACTER_GLYPH_STYLE_STROKE"],
        &["CURVE_STYLE"],
        &["CURVE_STYLE_FONT"],
        &["CURVE_STYLE_FONT_AND_SCALING"],
        &["CURVE_STYLE_FONT_PATTERN"],
        &["EXTERNALLY_DEFINED_STYLE"],
        &["FILL_AREA_STYLE"],
        &["POINT_STYLE"],
        &["PRESENTATION_STYLE_ASSIGNMENT"],
        &["SURFACE_SIDE_STYLE"],
        &["SURFACE_STYLE_BOUNDARY"],
        &["SURFACE_STYLE_CONTROL_GRID"],
        &["SURFACE_STYLE_FILL_AREA"],
        &["SURFACE_STYLE_PARAMETER_LINE"],
        &["SURFACE_STYLE_SEGMENTATION_CURVE"],
        &["SURFACE_STYLE_SILHOUETTE"],
        &["SURFACE_STYLE_USAGE"],
        &["SYMBOL_STYLE"],
        &["TEXT_STYLE"],
    ],
    &[
        &["POINT"],
        &["DIRECTION"],
        &["VECTOR"],
        &["PLACEMENT"],
        &["CURVE"],
        &["SURFACE"],
        &["EDGE_CURVE"],
        &["FACE_SURFACE"],
        &["POLY_LOOP"],
        &["VERTEX_POINT"],
        &["SOLID_MODEL"],
        &["SHELL_BASED_SURFACE_MODEL"],
        &["GEOMETRIC_SET"],
        &["TESSELLATED_ITEM"],
    ],
    &[&["CURVE"], &["POINT"], &["TEXT_LITERAL"]],
    &[&["CAMERA_MODEL"], &["CURVE"], &["DIRECTION"]],
    &[
        &["CURVE"],
        &["EXTERNALLY_DEFINED_HATCH_STYLE"],
        &["EXTERNALLY_DEFINED_TILE_STYLE"],
        &["FILL_AREA_STYLE_HATCHING"],
        &["FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE"],
        &["FILL_AREA_STYLE_TILES"],
        &["ONE_DIRECTION_REPEAT_FACTOR"],
        &["POINT"],
        &["VECTOR"],
    ],
    &[&["CURVE"], &["PLANAR_EXTENT"]],
    &[
        &["GEOMETRIC_TOLERANCE_WITH_MODIFIERS"],
        &["MODIFIED_GEOMETRIC_TOLERANCE"],
    ],
    &[
        &["CYLINDRICITY_TOLERANCE"],
        &["FLATNESS_TOLERANCE"],
        &["LINE_PROFILE_TOLERANCE"],
        &["POSITION_TOLERANCE"],
        &["ROUNDNESS_TOLERANCE"],
        &["STRAIGHTNESS_TOLERANCE"],
        &["SURFACE_PROFILE_TOLERANCE"],
    ],
    &[
        &["CIRCULAR_RUNOUT_TOLERANCE"],
        &["PARALLELISM_TOLERANCE"],
        &["PERPENDICULARITY_TOLERANCE"],
    ],
    &[&["INT_LITERAL"], &["REAL_LITERAL"]],
    &[&["EDGE_LOOP"], &["POLY_LOOP"]],
    &[
        &["LENGTH_MEASURE_WITH_UNIT"],
        &["PLANE_ANGLE_MEASURE_WITH_UNIT"],
        &["RATIO_MEASURE_WITH_UNIT"],
    ],
    &[
        &["SI_UNIT"],
        &["CONVERSION_BASED_UNIT"],
        &["CONTEXT_DEPENDENT_UNIT"],
    ],
    &[
        &["LENGTH_UNIT"],
        &["MASS_UNIT"],
        &["TIME_UNIT"],
        &["PLANE_ANGLE_UNIT"],
        &["SOLID_ANGLE_UNIT"],
        &["RATIO_UNIT"],
    ],
    &[&["PRESENTATION_AREA"], &["PRESENTATION_VIEW"]],
    &[
        &["COMPOUND_REPRESENTATION_ITEM"],
        &["MAPPED_ITEM"],
        &["VALUE_REPRESENTATION_ITEM"],
    ],
    &[
        &["INTEGER_REPRESENTATION_ITEM"],
        &["REAL_REPRESENTATION_ITEM"],
    ],
    &[&["MAPPED_ITEM"], &["STYLED_ITEM"]],
    &[
        &["DATUM"],
        &["DATUM_FEATURE"],
        &["DATUM_TARGET"],
        &["DATUM_SYSTEM"],
        &["GENERAL_DATUM_REFERENCE"],
    ],
    &[&["ELEMENTARY_SURFACE"], &["BOUNDED_SURFACE"]],
    &[&["INTERSECTION_CURVE"], &["SEAM_CURVE"]],
    &[
        &["TESSELLATED_GEOMETRIC_SET"],
        &["TESSELLATED_STRUCTURED_ITEM"],
    ],
    &[
        &["VERTEX"],
        &["EDGE"],
        &["FACE_BOUND"],
        &["FACE"],
        &["CONNECTED_FACE_SET"],
        &["LOOP", "PATH"],
    ],
];

/// Name-set validity of a complex part bag: every part known and
/// AP242-legal, no duplicates, supertype chains complete (each part's
/// transitive supertypes all present — Part 21 external mapping), the set
/// connected through those chains (one inheritance graph, no disjoint
/// clusters), and no ONEOF group drawn from two branches. Reference fields
/// are checked separately by [`Ap242Author::add_complex`].
pub(crate) fn complex_rule(names: &[&'static str]) -> Result<(), AuthorError> {
    if names.is_empty() {
        return Err(AuthorError::InvalidComplex {
            reason: "empty part list",
        });
    }
    let mut ancestor_sets: Vec<&'static [&'static str]> = Vec::with_capacity(names.len());
    for n in names {
        let Ok(ix) = PART_INFO.binary_search_by_key(n, |e| e.0) else {
            return Err(AuthorError::NotAp242 { entity: n });
        };
        let (_, is_legal, ancestors) = PART_INFO[ix];
        if !is_legal {
            return Err(AuthorError::NotAp242 { entity: n });
        }
        ancestor_sets.push(ancestors);
    }
    let mut sorted = names.to_vec();
    sorted.sort_unstable();
    if sorted.windows(2).any(|w| w[0] == w[1]) {
        return Err(AuthorError::InvalidComplex {
            reason: "duplicate part",
        });
    }
    for ancestors in &ancestor_sets {
        for a in *ancestors {
            if sorted.binary_search(a).is_err() {
                return Err(AuthorError::InvalidComplex {
                    reason: "missing supertype part",
                });
            }
        }
    }
    // Connectivity: merge each part with its (all present) supertypes; more
    // than one component left means unrelated hierarchies were mixed.
    let mut comp: Vec<usize> = (0..names.len()).collect();
    for (i, ancestors) in ancestor_sets.iter().enumerate() {
        for a in *ancestors {
            let j = names.iter().position(|n| n == a).unwrap();
            let (ci, cj) = (comp[i], comp[j]);
            if ci != cj {
                for c in comp.iter_mut() {
                    if *c == cj {
                        *c = ci;
                    }
                }
            }
        }
    }
    if comp.iter().any(|&c| c != comp[0]) {
        return Err(AuthorError::InvalidComplex {
            reason: "disjoint parts",
        });
    }
    for group in ONEOF_GROUPS {
        let mut hit = 0;
        for branch in *group {
            if branch.iter().any(|b| names.contains(b)) {
                hit += 1;
                if hit >= 2 {
                    return Err(AuthorError::InvalidComplex {
                        reason: "oneof conflict",
                    });
                }
            }
        }
    }
    Ok(())
}

fn check_unit_part(model: &StepModel, p: &UnitPart) -> Result<(), AuthorError> {
    match p {
        UnitPart::Action { chosen_method, .. } => {
            check_action_method_ref(model, chosen_method)?;
        }
        UnitPart::ActionMethodRelationship {
            relating_method,
            related_method,
            ..
        } => {
            check_action_method_ref(model, relating_method)?;
            check_action_method_ref(model, related_method)?;
        }
        UnitPart::ActionRelationship {
            relating_action,
            related_action,
            ..
        } => {
            check_action_ref(model, relating_action)?;
            check_action_ref(model, related_action)?;
        }
        UnitPart::ActionRequestAssignment {
            assigned_action_request,
            ..
        } => {
            check_versioned_action_request_ref(model, assigned_action_request)?;
        }
        UnitPart::ActionResource { usage, kind, .. } => {
            {
                let x = usage;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "ACTION_RESOURCE",
                        attribute: "usage",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in usage {
                check_supported_item_ref(model, e0)?;
            }
            check_action_resource_type_ref(model, kind)?;
        }
        UnitPart::ActionResourceRequirement {
            kind, operations, ..
        } => {
            check_resource_requirement_type_ref(model, kind)?;
            {
                let x = operations;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "ACTION_RESOURCE_REQUIREMENT",
                        attribute: "operations",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in operations {
                check_characterized_action_definition_ref(model, e0)?;
            }
        }
        UnitPart::AnnotationFillAreaOccurrence {
            fill_style_target, ..
        } => {
            check_point_ref(model, fill_style_target)?;
        }
        UnitPart::AnnotationOccurrenceRelationship {
            relating_annotation_occurrence,
            related_annotation_occurrence,
            ..
        } => {
            check_annotation_occurrence_ref(model, relating_annotation_occurrence)?;
            check_annotation_occurrence_ref(model, related_annotation_occurrence)?;
        }
        UnitPart::AnnotationPlaceholderOccurrenceWithLeaderLine { leader_line, .. } => {
            {
                let x = leader_line;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
                        attribute: "leader_line",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in leader_line {
                check_annotation_placeholder_leader_line_ref(model, e0)?;
            }
        }
        UnitPart::AnnotationPlane { elements, .. } => {
            if let Some(x) = elements {
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "ANNOTATION_PLANE",
                        attribute: "elements",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            if let Some(x) = elements {
                for e0 in x {
                    check_annotation_plane_element_ref(model, e0)?;
                }
            }
        }
        UnitPart::ApplicationContextElement {
            frame_of_reference, ..
        } => {
            check_application_context_ref(model, frame_of_reference)?;
        }
        UnitPart::AppliedApprovalAssignment { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "APPLIED_APPROVAL_ASSIGNMENT",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_approval_item_ref(model, e0)?;
            }
        }
        UnitPart::AppliedDateAndTimeAssignment { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "APPLIED_DATE_AND_TIME_ASSIGNMENT",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_date_and_time_item_ref(model, e0)?;
            }
        }
        UnitPart::AppliedDocumentReference { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "APPLIED_DOCUMENT_REFERENCE",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_document_reference_item_ref(model, e0)?;
            }
        }
        UnitPart::AppliedExternalIdentificationAssignment { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_external_identification_item_ref(model, e0)?;
            }
        }
        UnitPart::AppliedGroupAssignment { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "APPLIED_GROUP_ASSIGNMENT",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_groupable_item_ref(model, e0)?;
            }
        }
        UnitPart::AppliedPersonAndOrganizationAssignment { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_person_and_organization_item_ref(model, e0)?;
            }
        }
        UnitPart::AppliedPresentedItem { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "APPLIED_PRESENTED_ITEM",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_presented_item_select_ref(model, e0)?;
            }
        }
        UnitPart::AppliedSecurityClassificationAssignment { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "APPLIED_SECURITY_CLASSIFICATION_ASSIGNMENT",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_security_classification_item_ref(model, e0)?;
            }
        }
        UnitPart::ApprovalAssignment {
            assigned_approval, ..
        } => {
            check_approval_ref(model, assigned_approval)?;
        }
        UnitPart::AreaInSet { area, in_set, .. } => {
            check_presentation_area_ref(model, area)?;
            check_presentation_set_ref(model, in_set)?;
        }
        UnitPart::AscribableStateRelationship {
            relating_ascribable_state,
            related_ascribable_state,
            ..
        } => {
            check_ascribable_state_ref(model, relating_ascribable_state)?;
            check_ascribable_state_ref(model, related_ascribable_state)?;
        }
        UnitPart::BSplineCurve {
            control_points_list,
            ..
        } => {
            {
                let x = control_points_list;
                if x.len() < 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "B_SPLINE_CURVE",
                        attribute: "control_points_list",
                        got: x.len(),
                        min: 2,
                        max: None,
                    });
                }
            }
            for e0 in control_points_list {
                check_cartesian_point_ref(model, e0)?;
            }
        }
        UnitPart::BSplineCurveWithKnots {
            knot_multiplicities,
            knots,
            ..
        } => {
            {
                let x = knot_multiplicities;
                if x.len() < 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "B_SPLINE_CURVE_WITH_KNOTS",
                        attribute: "knot_multiplicities",
                        got: x.len(),
                        min: 2,
                        max: None,
                    });
                }
            }
            {
                let x = knots;
                if x.len() < 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "B_SPLINE_CURVE_WITH_KNOTS",
                        attribute: "knots",
                        got: x.len(),
                        min: 2,
                        max: None,
                    });
                }
            }
        }
        UnitPart::BSplineSurface {
            control_points_list,
            ..
        } => {
            {
                let x = control_points_list;
                if x.len() < 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "B_SPLINE_SURFACE",
                        attribute: "control_points_list",
                        got: x.len(),
                        min: 2,
                        max: None,
                    });
                }
            }
            for e0 in control_points_list {
                for e1 in e0 {
                    check_cartesian_point_ref(model, e1)?;
                }
            }
        }
        UnitPart::BSplineSurfaceWithKnots {
            u_multiplicities,
            v_multiplicities,
            u_knots,
            v_knots,
            ..
        } => {
            {
                let x = u_multiplicities;
                if x.len() < 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                        attribute: "u_multiplicities",
                        got: x.len(),
                        min: 2,
                        max: None,
                    });
                }
            }
            {
                let x = v_multiplicities;
                if x.len() < 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                        attribute: "v_multiplicities",
                        got: x.len(),
                        min: 2,
                        max: None,
                    });
                }
            }
            {
                let x = u_knots;
                if x.len() < 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                        attribute: "u_knots",
                        got: x.len(),
                        min: 2,
                        max: None,
                    });
                }
            }
            {
                let x = v_knots;
                if x.len() < 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                        attribute: "v_knots",
                        got: x.len(),
                        min: 2,
                        max: None,
                    });
                }
            }
        }
        UnitPart::BrepWithVoids { voids, .. } => {
            {
                let x = voids;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "BREP_WITH_VOIDS",
                        attribute: "voids",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in voids {
                check_oriented_closed_shell_ref(model, e0)?;
            }
        }
        UnitPart::CameraModelD3 {
            view_reference_system,
            perspective_of_volume,
            ..
        } => {
            check_axis2_placement3d_ref(model, view_reference_system)?;
            check_view_volume_ref(model, perspective_of_volume)?;
        }
        UnitPart::CameraModelD3MultiClipping { shape_clipping, .. } => {
            {
                let x = shape_clipping;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                        attribute: "shape_clipping",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in shape_clipping {
                check_camera_model_d3_multi_clipping_intersection_select_ref(model, e0)?;
            }
        }
        UnitPart::CcDesignApproval { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "CC_DESIGN_APPROVAL",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_approved_item_ref(model, e0)?;
            }
        }
        UnitPart::CcDesignDateAndTimeAssignment { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_date_time_item_ref(model, e0)?;
            }
        }
        UnitPart::CcDesignPersonAndOrganizationAssignment { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_cc_person_organization_item_ref(model, e0)?;
            }
        }
        UnitPart::CcDesignSecurityClassification { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "CC_DESIGN_SECURITY_CLASSIFICATION",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_cc_classified_item_ref(model, e0)?;
            }
        }
        UnitPart::ChangeRequest { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "CHANGE_REQUEST",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_change_request_item_ref(model, e0)?;
            }
        }
        UnitPart::CharacterGlyphStyleOutline { outline_style, .. } => {
            check_curve_style_ref(model, outline_style)?;
        }
        UnitPart::CharacterGlyphStyleStroke { stroke_style, .. } => {
            check_curve_style_ref(model, stroke_style)?;
        }
        UnitPart::CharacterizedItemWithinRepresentation { item, rep, .. } => {
            check_representation_item_ref(model, item)?;
            check_representation_ref(model, rep)?;
        }
        UnitPart::CompositeCurve { segments, .. } => {
            {
                let x = segments;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "COMPOSITE_CURVE",
                        attribute: "segments",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in segments {
                check_composite_curve_segment_ref(model, e0)?;
            }
        }
        UnitPart::CompositeCurveSegment { parent_curve, .. } => {
            check_curve_ref(model, parent_curve)?;
        }
        UnitPart::CompositeText { collected_text, .. } => {
            {
                let x = collected_text;
                if x.len() < 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "COMPOSITE_TEXT",
                        attribute: "collected_text",
                        got: x.len(),
                        min: 2,
                        max: None,
                    });
                }
            }
            for e0 in collected_text {
                check_text_or_character_ref(model, e0)?;
            }
        }
        UnitPart::CompoundRepresentationItem { item_element, .. } => {
            check_compound_item_definition_ref(model, item_element)?;
        }
        UnitPart::ConfigurationEffectivity { configuration, .. } => {
            check_configuration_design_ref(model, configuration)?;
        }
        UnitPart::ConfigurationItem { item_concept, .. } => {
            check_product_concept_ref(model, item_concept)?;
        }
        UnitPart::ConnectedFaceSet { cfs_faces, .. } => {
            if let Some(x) = cfs_faces {
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "CONNECTED_FACE_SET",
                        attribute: "cfs_faces",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            if let Some(x) = cfs_faces {
                for e0 in x {
                    check_face_ref(model, e0)?;
                }
            }
        }
        UnitPart::ContextDependentOverRidingStyledItem { style_context, .. } => {
            {
                let x = style_context;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                        attribute: "style_context",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in style_context {
                check_style_context_select_ref(model, e0)?;
            }
        }
        UnitPart::ConversionBasedUnit {
            conversion_factor, ..
        } => {
            check_measure_with_unit_ref(model, conversion_factor)?;
        }
        UnitPart::CurveStyle {
            curve_font,
            curve_width,
            curve_colour,
            ..
        } => {
            if let Some(x) = curve_font {
                check_curve_font_or_scaled_curve_font_select_ref(model, x)?;
            }
            if let Some(x) = curve_width {
                check_size_select_ref(model, x)?;
            }
            if let Some(x) = curve_colour {
                check_colour_ref(model, x)?;
            }
        }
        UnitPart::CurveStyleFont { pattern_list, .. } => {
            {
                let x = pattern_list;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "CURVE_STYLE_FONT",
                        attribute: "pattern_list",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in pattern_list {
                check_curve_style_font_pattern_ref(model, e0)?;
            }
        }
        UnitPart::CurveStyleFontAndScaling { curve_font, .. } => {
            check_curve_style_font_select_ref(model, curve_font)?;
        }
        UnitPart::DateAndTime {
            date_component,
            time_component,
            ..
        } => {
            check_date_ref(model, date_component)?;
            check_local_time_ref(model, time_component)?;
        }
        UnitPart::DateAndTimeAssignment {
            assigned_date_and_time,
            role,
            ..
        } => {
            check_date_and_time_ref(model, assigned_date_and_time)?;
            check_date_time_role_ref(model, role)?;
        }
        UnitPart::DatumReference {
            referenced_datum, ..
        } => {
            check_datum_ref(model, referenced_datum)?;
        }
        UnitPart::DatumSystem { constituents, .. } => {
            {
                let x = constituents;
                if x.len() < 1 || x.len() > 3 {
                    return Err(AuthorError::Cardinality {
                        entity: "DATUM_SYSTEM",
                        attribute: "constituents",
                        got: x.len(),
                        min: 1,
                        max: Some(3),
                    });
                }
            }
            for e0 in constituents {
                check_datum_reference_compartment_ref(model, e0)?;
            }
        }
        UnitPart::DerivedUnit { elements, .. } => {
            {
                let x = elements;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "DERIVED_UNIT",
                        attribute: "elements",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in elements {
                check_derived_unit_element_ref(model, e0)?;
            }
        }
        UnitPart::DimensionalSize { applies_to, .. } => {
            check_shape_aspect_ref(model, applies_to)?;
        }
        UnitPart::Direction {
            direction_ratios, ..
        } => {
            let x = direction_ratios;
            if x.len() < 2 || x.len() > 3 {
                return Err(AuthorError::Cardinality {
                    entity: "DIRECTION",
                    attribute: "direction_ratios",
                    got: x.len(),
                    min: 2,
                    max: Some(3),
                });
            }
        }
        UnitPart::Document { kind, .. } => {
            check_document_type_ref(model, kind)?;
        }
        UnitPart::DocumentProductAssociation {
            relating_document,
            related_product,
            ..
        } => {
            check_document_ref(model, relating_document)?;
            check_product_or_formation_or_definition_ref(model, related_product)?;
        }
        UnitPart::DocumentReference {
            assigned_document, ..
        } => {
            check_document_ref(model, assigned_document)?;
        }
        UnitPart::DraughtingCallout { contents, .. } => {
            {
                let x = contents;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "DRAUGHTING_CALLOUT",
                        attribute: "contents",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in contents {
                check_draughting_callout_element_ref(model, e0)?;
            }
        }
        UnitPart::DraughtingCalloutRelationship {
            relating_draughting_callout,
            related_draughting_callout,
            ..
        } => {
            check_draughting_callout_ref(model, relating_draughting_callout)?;
            check_draughting_callout_ref(model, related_draughting_callout)?;
        }
        UnitPart::DraughtingModelItemAssociationWithPlaceholder {
            annotation_placeholder,
            ..
        } => {
            check_annotation_placeholder_occurrence_ref(model, annotation_placeholder)?;
        }
        UnitPart::Edge {
            edge_start,
            edge_end,
            ..
        } => {
            if let Some(x) = edge_start {
                check_vertex_ref(model, x)?;
            }
            if let Some(x) = edge_end {
                check_vertex_ref(model, x)?;
            }
        }
        UnitPart::EdgeCurve { edge_geometry, .. } => {
            check_curve_ref(model, edge_geometry)?;
        }
        UnitPart::ElementarySurface { position, .. } => {
            check_axis2_placement3d_ref(model, position)?;
        }
        UnitPart::ExternalIdentificationAssignment { source, .. } => {
            check_external_source_ref(model, source)?;
        }
        UnitPart::ExternallyDefinedItem { source, .. } => {
            check_external_source_ref(model, source)?;
        }
        UnitPart::Face { bounds, .. } => {
            {
                let x = bounds;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "FACE",
                        attribute: "bounds",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in bounds {
                check_face_bound_ref(model, e0)?;
            }
        }
        UnitPart::FaceBound { bound, .. } => {
            check_loop_ref(model, bound)?;
        }
        UnitPart::FaceSurface { face_geometry, .. } => {
            check_surface_ref(model, face_geometry)?;
        }
        UnitPart::FillAreaStyle { fill_styles, .. } => {
            {
                let x = fill_styles;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "FILL_AREA_STYLE",
                        attribute: "fill_styles",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in fill_styles {
                check_fill_style_select_ref(model, e0)?;
            }
        }
        UnitPart::FillAreaStyleHatching {
            hatch_line_appearance,
            start_of_next_hatch_line,
            point_of_reference_hatch_line,
            pattern_start,
            ..
        } => {
            check_curve_style_ref(model, hatch_line_appearance)?;
            check_one_direction_repeat_factor_ref(model, start_of_next_hatch_line)?;
            check_cartesian_point_ref(model, point_of_reference_hatch_line)?;
            check_cartesian_point_ref(model, pattern_start)?;
        }
        UnitPart::FillAreaStyleTileSymbolWithStyle { symbol, .. } => {
            check_annotation_symbol_occurrence_ref(model, symbol)?;
        }
        UnitPart::FillAreaStyleTiles {
            tiling_pattern,
            tiles,
            ..
        } => {
            check_two_direction_repeat_factor_ref(model, tiling_pattern)?;
            {
                let x = tiles;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "FILL_AREA_STYLE_TILES",
                        attribute: "tiles",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in tiles {
                check_fill_area_style_tile_shape_select_ref(model, e0)?;
            }
        }
        UnitPart::GeneralDatumReference {
            base, modifiers, ..
        } => {
            check_datum_or_common_datum_ref(model, base)?;
            if let Some(x) = modifiers {
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "GENERAL_DATUM_REFERENCE",
                        attribute: "modifiers",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            if let Some(x) = modifiers {
                for e0 in x {
                    check_datum_reference_modifier_ref(model, e0)?;
                }
            }
        }
        UnitPart::GenericProductDefinitionReference { source, .. } => {
            check_external_source_ref(model, source)?;
        }
        UnitPart::GeometricSet { elements, .. } => {
            {
                let x = elements;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "GEOMETRIC_SET",
                        attribute: "elements",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in elements {
                check_geometric_set_select_ref(model, e0)?;
            }
        }
        UnitPart::GeometricTolerance {
            magnitude,
            toleranced_shape_aspect,
            ..
        } => {
            if let Some(x) = magnitude {
                check_length_measure_with_unit_ref(model, x)?;
            }
            check_geometric_tolerance_target_ref(model, toleranced_shape_aspect)?;
        }
        UnitPart::GeometricToleranceWithDatumReference { datum_system, .. } => {
            {
                let x = datum_system;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
                        attribute: "datum_system",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in datum_system {
                check_datum_system_or_reference_ref(model, e0)?;
            }
        }
        UnitPart::GeometricToleranceWithDefinedAreaUnit {
            second_unit_size, ..
        } => {
            if let Some(x) = second_unit_size {
                check_length_or_plane_angle_measure_with_unit_select_ref(model, x)?;
            }
        }
        UnitPart::GeometricToleranceWithDefinedUnit { unit_size, .. } => {
            check_length_or_plane_angle_measure_with_unit_select_ref(model, unit_size)?;
        }
        UnitPart::GeometricToleranceWithMaximumTolerance {
            maximum_upper_tolerance,
            ..
        } => {
            check_length_measure_with_unit_ref(model, maximum_upper_tolerance)?;
        }
        UnitPart::GeometricToleranceWithModifiers { modifiers, .. } => {
            let x = modifiers;
            if x.len() < 1 {
                return Err(AuthorError::Cardinality {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
                    attribute: "modifiers",
                    got: x.len(),
                    min: 1,
                    max: None,
                });
            }
        }
        UnitPart::GlobalUncertaintyAssignedContext { uncertainty, .. } => {
            {
                let x = uncertainty;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT",
                        attribute: "uncertainty",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in uncertainty {
                check_uncertainty_measure_with_unit_ref(model, e0)?;
            }
        }
        UnitPart::GlobalUnitAssignedContext { units, .. } => {
            {
                let x = units;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "GLOBAL_UNIT_ASSIGNED_CONTEXT",
                        attribute: "units",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in units {
                check_unit_ref(model, e0)?;
            }
        }
        UnitPart::GroupAssignment { assigned_group, .. } => {
            check_group_ref(model, assigned_group)?;
        }
        UnitPart::IdentificationAssignment { role, .. } => {
            check_identification_role_ref(model, role)?;
        }
        UnitPart::Invisibility {
            invisible_items, ..
        } => {
            {
                let x = invisible_items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "INVISIBILITY",
                        attribute: "invisible_items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in invisible_items {
                check_invisible_item_ref(model, e0)?;
            }
        }
        UnitPart::ItemDefinedTransformation {
            transform_item_1,
            transform_item_2,
            ..
        } => {
            check_representation_item_ref(model, transform_item_1)?;
            check_representation_item_ref(model, transform_item_2)?;
        }
        UnitPart::ItemIdentifiedRepresentationUsage {
            definition,
            used_representation,
            identified_item,
            ..
        } => {
            check_item_identified_representation_usage_definition_ref(model, definition)?;
            check_representation_ref(model, used_representation)?;
            check_item_identified_representation_usage_select_ref(model, identified_item)?;
        }
        UnitPart::ManifoldSolidBrep { outer, .. } => {
            check_closed_shell_ref(model, outer)?;
        }
        UnitPart::MappedItem {
            mapping_source,
            mapping_target,
            ..
        } => {
            check_representation_map_ref(model, mapping_source)?;
            check_representation_item_ref(model, mapping_target)?;
        }
        UnitPart::MeasureWithUnit { unit_component, .. } => {
            check_unit_ref(model, unit_component)?;
        }
        UnitPart::NamedUnit { dimensions, .. } => {
            if let Some(x) = dimensions {
                check_dimensional_exponents_ref(model, x)?;
            }
        }
        UnitPart::OneDirectionRepeatFactor { repeat_factor, .. } => {
            check_vector_ref(model, repeat_factor)?;
        }
        UnitPart::OrganizationalAddress { organizations, .. } => {
            {
                let x = organizations;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "ORGANIZATIONAL_ADDRESS",
                        attribute: "organizations",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in organizations {
                check_organization_ref(model, e0)?;
            }
        }
        UnitPart::OrientedClosedShell {
            closed_shell_element,
            ..
        } => {
            check_closed_shell_ref(model, closed_shell_element)?;
        }
        UnitPart::OrientedEdge { edge_element, .. } => {
            check_edge_ref(model, edge_element)?;
        }
        UnitPart::OverRidingStyledItem {
            over_ridden_style, ..
        } => {
            check_styled_item_ref(model, over_ridden_style)?;
        }
        UnitPart::Path { edge_list, .. } => {
            {
                let x = edge_list;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "PATH",
                        attribute: "edge_list",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in edge_list {
                check_oriented_edge_ref(model, e0)?;
            }
        }
        UnitPart::Pcurve {
            basis_surface,
            reference_to_curve,
            ..
        } => {
            check_surface_ref(model, basis_surface)?;
            check_definitional_representation_ref(model, reference_to_curve)?;
        }
        UnitPart::PersonAndOrganizationAssignment {
            assigned_person_and_organization,
            role,
            ..
        } => {
            check_person_and_organization_ref(model, assigned_person_and_organization)?;
            check_person_and_organization_role_ref(model, role)?;
        }
        UnitPart::PersonalAddress { people, .. } => {
            {
                let x = people;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "PERSONAL_ADDRESS",
                        attribute: "people",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in people {
                check_person_ref(model, e0)?;
            }
        }
        UnitPart::Placement { location, .. } => {
            check_cartesian_point_ref(model, location)?;
        }
        UnitPart::PlanarBox { placement, .. } => {
            check_axis2_placement_ref(model, placement)?;
        }
        UnitPart::PointStyle {
            marker,
            marker_size,
            marker_colour,
            ..
        } => {
            if let Some(x) = marker {
                check_marker_select_ref(model, x)?;
            }
            if let Some(x) = marker_size {
                check_size_select_ref(model, x)?;
            }
            if let Some(x) = marker_colour {
                check_colour_ref(model, x)?;
            }
        }
        UnitPart::PolyLoop { polygon, .. } => {
            {
                let x = polygon;
                if x.len() < 3 {
                    return Err(AuthorError::Cardinality {
                        entity: "POLY_LOOP",
                        attribute: "polygon",
                        got: x.len(),
                        min: 3,
                        max: None,
                    });
                }
            }
            for e0 in polygon {
                check_cartesian_point_ref(model, e0)?;
            }
        }
        UnitPart::PresentationStyleAssignment { styles, .. } => {
            {
                let x = styles;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "PRESENTATION_STYLE_ASSIGNMENT",
                        attribute: "styles",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in styles {
                check_presentation_style_select_ref(model, e0)?;
            }
        }
        UnitPart::PresentationStyleByContext { style_context, .. } => {
            check_style_context_select_ref(model, style_context)?;
        }
        UnitPart::Product {
            frame_of_reference, ..
        } => {
            {
                let x = frame_of_reference;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "PRODUCT",
                        attribute: "frame_of_reference",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in frame_of_reference {
                check_product_context_ref(model, e0)?;
            }
        }
        UnitPart::ProductConcept { market_context, .. } => {
            check_product_concept_context_ref(model, market_context)?;
        }
        UnitPart::ProductDefinition {
            formation,
            frame_of_reference,
            ..
        } => {
            check_product_definition_formation_ref(model, formation)?;
            check_product_definition_context_ref(model, frame_of_reference)?;
        }
        UnitPart::ProductDefinitionEffectivity { usage, .. } => {
            check_product_definition_relationship_ref(model, usage)?;
        }
        UnitPart::ProductDefinitionFormation { of_product, .. } => {
            check_product_ref(model, of_product)?;
        }
        UnitPart::ProductDefinitionOccurrence {
            definition,
            quantity,
            ..
        } => {
            if let Some(x) = definition {
                check_product_definition_or_reference_ref(model, x)?;
            }
            if let Some(x) = quantity {
                check_measure_with_unit_ref(model, x)?;
            }
        }
        UnitPart::ProductDefinitionRelationship {
            relating_product_definition,
            related_product_definition,
            ..
        } => {
            check_product_definition_or_reference_ref(model, relating_product_definition)?;
            check_product_definition_or_reference_ref(model, related_product_definition)?;
        }
        UnitPart::ProductDefinitionRelationshipRelationship {
            relating, related, ..
        } => {
            check_product_definition_relationship_ref(model, relating)?;
            check_product_definition_relationship_ref(model, related)?;
        }
        UnitPart::ProductDefinitionWithAssociatedDocuments {
            documentation_ids, ..
        } => {
            {
                let x = documentation_ids;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                        attribute: "documentation_ids",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in documentation_ids {
                check_document_ref(model, e0)?;
            }
        }
        UnitPart::ProductRelatedProductCategory { products, .. } => {
            {
                let x = products;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "PRODUCT_RELATED_PRODUCT_CATEGORY",
                        attribute: "products",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in products {
                check_product_ref(model, e0)?;
            }
        }
        UnitPart::ProjectedZoneDefinition {
            projection_end,
            projected_length,
            ..
        } => {
            check_shape_aspect_ref(model, projection_end)?;
            check_length_measure_with_unit_ref(model, projected_length)?;
        }
        UnitPart::PropertyDefinition { definition, .. } => {
            check_characterized_definition_ref(model, definition)?;
        }
        UnitPart::PropertyDefinitionRepresentation {
            definition,
            used_representation,
            ..
        } => {
            check_represented_definition_ref(model, definition)?;
            check_representation_ref(model, used_representation)?;
        }
        UnitPart::QualifiedRepresentationItem { qualifiers, .. } => {
            {
                let x = qualifiers;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "QUALIFIED_REPRESENTATION_ITEM",
                        attribute: "qualifiers",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in qualifiers {
                check_value_qualifier_ref(model, e0)?;
            }
        }
        UnitPart::RationalBSplineCurve { weights_data, .. } => {
            let x = weights_data;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                    attribute: "weights_data",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        UnitPart::RationalBSplineSurface { weights_data, .. } => {
            let x = weights_data;
            if x.len() < 2 {
                return Err(AuthorError::Cardinality {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                    attribute: "weights_data",
                    got: x.len(),
                    min: 2,
                    max: None,
                });
            }
        }
        UnitPart::RepositionedTessellatedItem { location, .. } => {
            check_axis2_placement3d_ref(model, location)?;
        }
        UnitPart::Representation {
            items,
            context_of_items,
            ..
        } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "REPRESENTATION",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_representation_item_ref(model, e0)?;
            }
            check_representation_context_ref(model, context_of_items)?;
        }
        UnitPart::RepresentationMap {
            mapping_origin,
            mapped_representation,
            ..
        } => {
            check_representation_item_ref(model, mapping_origin)?;
            check_representation_ref(model, mapped_representation)?;
        }
        UnitPart::RepresentationReference {
            context_of_items, ..
        } => {
            check_representation_context_reference_ref(model, context_of_items)?;
        }
        UnitPart::RepresentationRelationship { rep_1, rep_2, .. } => {
            check_representation_or_representation_reference_ref(model, rep_1)?;
            check_representation_or_representation_reference_ref(model, rep_2)?;
        }
        UnitPart::RepresentationRelationshipWithTransformation {
            transformation_operator,
            ..
        } => {
            check_transformation_ref(model, transformation_operator)?;
        }
        UnitPart::SecurityClassificationAssignment {
            assigned_security_classification,
            ..
        } => {
            check_security_classification_ref(model, assigned_security_classification)?;
        }
        UnitPart::ShapeAspect { of_shape, .. } => {
            check_product_definition_shape_ref(model, of_shape)?;
        }
        UnitPart::ShapeAspectRelationship {
            relating_shape_aspect,
            related_shape_aspect,
            ..
        } => {
            check_shape_aspect_ref(model, relating_shape_aspect)?;
            check_shape_aspect_ref(model, related_shape_aspect)?;
        }
        UnitPart::ShellBasedSurfaceModel { sbsm_boundary, .. } => {
            {
                let x = sbsm_boundary;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "SHELL_BASED_SURFACE_MODEL",
                        attribute: "sbsm_boundary",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in sbsm_boundary {
                check_shell_ref(model, e0)?;
            }
        }
        UnitPart::StartRequest { items, .. } => {
            {
                let x = items;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "START_REQUEST",
                        attribute: "items",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in items {
                check_start_request_item_ref(model, e0)?;
            }
        }
        UnitPart::StyledItem { styles, item, .. } => {
            for e0 in styles {
                check_presentation_style_assignment_ref(model, e0)?;
            }
            check_styled_item_target_ref(model, item)?;
        }
        UnitPart::SurfaceCurve {
            curve_3d,
            associated_geometry,
            ..
        } => {
            check_curve_ref(model, curve_3d)?;
            {
                let x = associated_geometry;
                if x.len() < 1 || x.len() > 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "SURFACE_CURVE",
                        attribute: "associated_geometry",
                        got: x.len(),
                        min: 1,
                        max: Some(2),
                    });
                }
            }
            for e0 in associated_geometry {
                check_pcurve_or_surface_ref(model, e0)?;
            }
        }
        UnitPart::SurfaceSideStyle { styles, .. } => {
            {
                let x = styles;
                if x.len() < 1 || x.len() > 7 {
                    return Err(AuthorError::Cardinality {
                        entity: "SURFACE_SIDE_STYLE",
                        attribute: "styles",
                        got: x.len(),
                        min: 1,
                        max: Some(7),
                    });
                }
            }
            for e0 in styles {
                check_surface_style_element_select_ref(model, e0)?;
            }
        }
        UnitPart::SurfaceStyleBoundary {
            style_of_boundary, ..
        } => {
            check_curve_or_render_ref(model, style_of_boundary)?;
        }
        UnitPart::SurfaceStyleControlGrid {
            style_of_control_grid,
            ..
        } => {
            check_curve_or_render_ref(model, style_of_control_grid)?;
        }
        UnitPart::SurfaceStyleFillArea { fill_area, .. } => {
            check_fill_area_style_ref(model, fill_area)?;
        }
        UnitPart::SurfaceStyleParameterLine {
            style_of_parameter_lines,
            direction_counts,
            ..
        } => {
            check_curve_or_render_ref(model, style_of_parameter_lines)?;
            {
                let x = direction_counts;
                if x.len() < 1 || x.len() > 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "SURFACE_STYLE_PARAMETER_LINE",
                        attribute: "direction_counts",
                        got: x.len(),
                        min: 1,
                        max: Some(2),
                    });
                }
            }
        }
        UnitPart::SurfaceStyleRendering { surface_colour, .. } => {
            check_colour_ref(model, surface_colour)?;
        }
        UnitPart::SurfaceStyleRenderingWithProperties { properties, .. } => {
            {
                let x = properties;
                if x.len() < 1 || x.len() > 2 {
                    return Err(AuthorError::Cardinality {
                        entity: "SURFACE_STYLE_RENDERING_WITH_PROPERTIES",
                        attribute: "properties",
                        got: x.len(),
                        min: 1,
                        max: Some(2),
                    });
                }
            }
            for e0 in properties {
                check_rendering_properties_select_ref(model, e0)?;
            }
        }
        UnitPart::SurfaceStyleSegmentationCurve {
            style_of_segmentation_curve,
            ..
        } => {
            check_curve_or_render_ref(model, style_of_segmentation_curve)?;
        }
        UnitPart::SurfaceStyleSilhouette {
            style_of_silhouette,
            ..
        } => {
            check_curve_or_render_ref(model, style_of_silhouette)?;
        }
        UnitPart::SurfaceStyleUsage { style, .. } => {
            check_surface_side_style_select_ref(model, style)?;
        }
        UnitPart::SymbolStyle {
            style_of_symbol, ..
        } => {
            check_symbol_style_select_ref(model, style_of_symbol)?;
        }
        UnitPart::TerminatorSymbol {
            annotated_curve, ..
        } => {
            check_annotation_curve_occurrence_ref(model, annotated_curve)?;
        }
        UnitPart::TessellatedGeometricSet { children, .. } => {
            {
                let x = children;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "TESSELLATED_GEOMETRIC_SET",
                        attribute: "children",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in children {
                check_tessellated_item_ref(model, e0)?;
            }
        }
        UnitPart::TextLiteral {
            placement, font, ..
        } => {
            check_axis2_placement_ref(model, placement)?;
            check_font_select_ref(model, font)?;
        }
        UnitPart::TextStyle {
            character_appearance,
            ..
        } => {
            check_character_style_select_ref(model, character_appearance)?;
        }
        UnitPart::TextStyleWithBoxCharacteristics {
            characteristics, ..
        } => {
            let x = characteristics;
            if x.len() < 1 || x.len() > 4 {
                return Err(AuthorError::Cardinality {
                    entity: "TEXT_STYLE_WITH_BOX_CHARACTERISTICS",
                    attribute: "characteristics",
                    got: x.len(),
                    min: 1,
                    max: Some(4),
                });
            }
        }
        UnitPart::ToleranceZone {
            defining_tolerance,
            form,
            ..
        } => {
            {
                let x = defining_tolerance;
                if x.len() < 1 {
                    return Err(AuthorError::Cardinality {
                        entity: "TOLERANCE_ZONE",
                        attribute: "defining_tolerance",
                        got: x.len(),
                        min: 1,
                        max: None,
                    });
                }
            }
            for e0 in defining_tolerance {
                check_tolerance_zone_target_ref(model, e0)?;
            }
            check_tolerance_zone_form_ref(model, form)?;
        }
        UnitPart::ToleranceZoneDefinition {
            zone, boundaries, ..
        } => {
            check_tolerance_zone_ref(model, zone)?;
            for e0 in boundaries {
                check_shape_aspect_ref(model, e0)?;
            }
        }
        UnitPart::ToleranceZoneWithDatum {
            datum_reference, ..
        } => {
            check_datum_system_ref(model, datum_reference)?;
        }
        UnitPart::TwoDirectionRepeatFactor {
            second_repeat_factor,
            ..
        } => {
            check_vector_ref(model, second_repeat_factor)?;
        }
        UnitPart::UnequallyDisposedGeometricTolerance { displacement, .. } => {
            check_length_measure_with_unit_ref(model, displacement)?;
        }
        UnitPart::Vector { orientation, .. } => {
            check_direction_ref(model, orientation)?;
        }
        UnitPart::VertexPoint {
            vertex_geometry, ..
        } => {
            check_point_ref(model, vertex_geometry)?;
        }
        UnitPart::ViewVolume {
            projection_point,
            view_window,
            ..
        } => {
            check_cartesian_point_ref(model, projection_point)?;
            check_planar_box_ref(model, view_window)?;
        }
        _ => {}
    }
    Ok(())
}

fn check_action_ref(model: &StepModel, r: &ActionRef) -> Result<(), AuthorError> {
    match r {
        ActionRef::Action(i) => {
            if i.0 >= model.action_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ACTION" });
            }
        }
        ActionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_action_method_ref(model: &StepModel, r: &ActionMethodRef) -> Result<(), AuthorError> {
    match r {
        ActionMethodRef::ActionMethod(i) => {
            if i.0 >= model.action_method_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD",
                });
            }
        }
        ActionMethodRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_action_resource_ref(model: &StepModel, r: &ActionResourceRef) -> Result<(), AuthorError> {
    match r {
        ActionResourceRef::ActionResource(i) => {
            if i.0 >= model.action_resource_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_RESOURCE",
                });
            }
        }
        ActionResourceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_action_resource_type_ref(
    model: &StepModel,
    r: &ActionResourceTypeRef,
) -> Result<(), AuthorError> {
    match r {
        ActionResourceTypeRef::ActionResourceType(i) => {
            if i.0 >= model.action_resource_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_RESOURCE_TYPE",
                });
            }
        }
    }
    Ok(())
}
fn check_annotation_curve_occurrence_ref(
    model: &StepModel,
    r: &AnnotationCurveOccurrenceRef,
) -> Result<(), AuthorError> {
    match r {
        AnnotationCurveOccurrenceRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        AnnotationCurveOccurrenceRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        AnnotationCurveOccurrenceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_annotation_occurrence_ref(
    model: &StepModel,
    r: &AnnotationOccurrenceRef,
) -> Result<(), AuthorError> {
    match r {
        AnnotationOccurrenceRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        AnnotationOccurrenceRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        AnnotationOccurrenceRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        AnnotationOccurrenceRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        AnnotationOccurrenceRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        AnnotationOccurrenceRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        AnnotationOccurrenceRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        AnnotationOccurrenceRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        AnnotationOccurrenceRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        AnnotationOccurrenceRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        AnnotationOccurrenceRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        AnnotationOccurrenceRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        AnnotationOccurrenceRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        AnnotationOccurrenceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_annotation_placeholder_leader_line_ref(
    model: &StepModel,
    r: &AnnotationPlaceholderLeaderLineRef,
) -> Result<(), AuthorError> {
    match r {
        AnnotationPlaceholderLeaderLineRef::AnnotationPlaceholderLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE",
            });
        }
        AnnotationPlaceholderLeaderLineRef::AnnotationToAnnotationLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE",
            });
        }
        AnnotationPlaceholderLeaderLineRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
        AnnotationPlaceholderLeaderLineRef::AuxiliaryLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "AUXILIARY_LEADER_LINE",
            });
        }
    }
    Ok(())
}
fn check_annotation_placeholder_occurrence_ref(
    model: &StepModel,
    r: &AnnotationPlaceholderOccurrenceRef,
) -> Result<(), AuthorError> {
    match r {
        AnnotationPlaceholderOccurrenceRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        AnnotationPlaceholderOccurrenceRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        AnnotationPlaceholderOccurrenceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_annotation_plane_element_ref(
    model: &StepModel,
    r: &AnnotationPlaneElementRef,
) -> Result<(), AuthorError> {
    match r {
        AnnotationPlaneElementRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        AnnotationPlaneElementRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        AnnotationPlaneElementRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        AnnotationPlaneElementRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        AnnotationPlaneElementRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        AnnotationPlaneElementRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        AnnotationPlaneElementRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        AnnotationPlaneElementRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        AnnotationPlaneElementRef::ContextDependentOverRidingStyledItem(i) => {
            if i.0
                >= model
                    .context_dependent_over_riding_styled_item_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        AnnotationPlaneElementRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        AnnotationPlaneElementRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        AnnotationPlaneElementRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        AnnotationPlaneElementRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        AnnotationPlaneElementRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        AnnotationPlaneElementRef::OverRidingStyledItem(i) => {
            if i.0 >= model.over_riding_styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        AnnotationPlaneElementRef::StyledItem(i) => {
            if i.0 >= model.styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STYLED_ITEM",
                });
            }
        }
        AnnotationPlaneElementRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        AnnotationPlaneElementRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        AnnotationPlaneElementRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_annotation_representation_select_ref(
    model: &StepModel,
    r: &AnnotationRepresentationSelectRef,
) -> Result<(), AuthorError> {
    match r {
        AnnotationRepresentationSelectRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        AnnotationRepresentationSelectRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        AnnotationRepresentationSelectRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        AnnotationRepresentationSelectRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        AnnotationRepresentationSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_annotation_symbol_occurrence_ref(
    model: &StepModel,
    r: &AnnotationSymbolOccurrenceRef,
) -> Result<(), AuthorError> {
    match r {
        AnnotationSymbolOccurrenceRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        AnnotationSymbolOccurrenceRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        AnnotationSymbolOccurrenceRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        AnnotationSymbolOccurrenceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_annotation_symbol_occurrence_item_ref(
    model: &StepModel,
    r: &AnnotationSymbolOccurrenceItemRef,
) -> Result<(), AuthorError> {
    match r {
        AnnotationSymbolOccurrenceItemRef::AnnotationSymbol(i) => {
            if i.0 >= model.annotation_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL",
                });
            }
        }
        AnnotationSymbolOccurrenceItemRef::DefinedSymbol(i) => {
            if i.0 >= model.defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_SYMBOL",
                });
            }
        }
        AnnotationSymbolOccurrenceItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_annotation_text_occurrence_item_ref(
    model: &StepModel,
    r: &AnnotationTextOccurrenceItemRef,
) -> Result<(), AuthorError> {
    match r {
        AnnotationTextOccurrenceItemRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        AnnotationTextOccurrenceItemRef::AnnotationTextCharacter(i) => {
            if i.0 >= model.annotation_text_character_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_CHARACTER",
                });
            }
        }
        AnnotationTextOccurrenceItemRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        AnnotationTextOccurrenceItemRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        AnnotationTextOccurrenceItemRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        AnnotationTextOccurrenceItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_annotation_to_model_leader_line_ref(
    model: &StepModel,
    r: &AnnotationToModelLeaderLineRef,
) -> Result<(), AuthorError> {
    match r {
        AnnotationToModelLeaderLineRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
    }
    Ok(())
}
fn check_application_context_ref(
    model: &StepModel,
    r: &ApplicationContextRef,
) -> Result<(), AuthorError> {
    match r {
        ApplicationContextRef::ApplicationContext(i) => {
            if i.0 >= model.application_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLICATION_CONTEXT",
                });
            }
        }
    }
    Ok(())
}
fn check_approval_ref(model: &StepModel, r: &ApprovalRef) -> Result<(), AuthorError> {
    match r {
        ApprovalRef::Approval(i) => {
            if i.0 >= model.approval_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "APPROVAL" });
            }
        }
    }
    Ok(())
}
fn check_approval_item_ref(model: &StepModel, r: &ApprovalItemRef) -> Result<(), AuthorError> {
    match r {
        ApprovalItemRef::Action(i) => {
            if i.0 >= model.action_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ACTION" });
            }
        }
        ApprovalItemRef::ActionDirective(i) => {
            if i.0 >= model.action_directive_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_DIRECTIVE",
                });
            }
        }
        ApprovalItemRef::ActionMethod(i) => {
            if i.0 >= model.action_method_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD",
                });
            }
        }
        ApprovalItemRef::ActionMethodRelationship(i) => {
            if i.0 >= model.action_method_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD_RELATIONSHIP",
                });
            }
        }
        ApprovalItemRef::ActionProperty(i) => {
            if i.0 >= model.action_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_PROPERTY",
                });
            }
        }
        ApprovalItemRef::ActionRequestSolution(i) => {
            if i.0 >= model.action_request_solution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_REQUEST_SOLUTION",
                });
            }
        }
        ApprovalItemRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        ApprovalItemRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        ApprovalItemRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        ApprovalItemRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        ApprovalItemRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        ApprovalItemRef::AnnotationPlaceholderLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE",
            });
        }
        ApprovalItemRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        ApprovalItemRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        ApprovalItemRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        ApprovalItemRef::AnnotationSymbol(i) => {
            if i.0 >= model.annotation_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL",
                });
            }
        }
        ApprovalItemRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        ApprovalItemRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        ApprovalItemRef::AnnotationTextCharacter(i) => {
            if i.0 >= model.annotation_text_character_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_CHARACTER",
                });
            }
        }
        ApprovalItemRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        ApprovalItemRef::AnnotationToAnnotationLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE",
            });
        }
        ApprovalItemRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
        ApprovalItemRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        ApprovalItemRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        ApprovalItemRef::AppliedApprovalAssignment(i) => {
            if i.0 >= model.applied_approval_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_APPROVAL_ASSIGNMENT",
                });
            }
        }
        ApprovalItemRef::AppliedDateAndTimeAssignment(i) => {
            if i.0 >= model.applied_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        ApprovalItemRef::AppliedDocumentReference(i) => {
            if i.0 >= model.applied_document_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DOCUMENT_REFERENCE",
                });
            }
        }
        ApprovalItemRef::AppliedExternalIdentificationAssignment(i) => {
            if i.0
                >= model
                    .applied_external_identification_assignment_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT",
                });
            }
        }
        ApprovalItemRef::AppliedPersonAndOrganizationAssignment(i) => {
            if i.0
                >= model
                    .applied_person_and_organization_assignment_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT",
                });
            }
        }
        ApprovalItemRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        ApprovalItemRef::AuxiliaryLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "AUXILIARY_LEADER_LINE",
            });
        }
        ApprovalItemRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
        ApprovalItemRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        ApprovalItemRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
        ApprovalItemRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        ApprovalItemRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        ApprovalItemRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        ApprovalItemRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        ApprovalItemRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        ApprovalItemRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        ApprovalItemRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        ApprovalItemRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        ApprovalItemRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        ApprovalItemRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        ApprovalItemRef::BrepWithVoids(i) => {
            if i.0 >= model.brep_with_voids_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BREP_WITH_VOIDS",
                });
            }
        }
        ApprovalItemRef::CalendarDate(i) => {
            if i.0 >= model.calendar_date_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CALENDAR_DATE",
                });
            }
        }
        ApprovalItemRef::CameraImage(i) => {
            if i.0 >= model.camera_image_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE",
                });
            }
        }
        ApprovalItemRef::CameraImage3dWithScale(i) => {
            if i.0 >= model.camera_image3d_with_scale_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE_3D_WITH_SCALE",
                });
            }
        }
        ApprovalItemRef::CameraModel(i) => {
            if i.0 >= model.camera_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL",
                });
            }
        }
        ApprovalItemRef::CameraModelD3(i) => {
            if i.0 >= model.camera_model_d3_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3",
                });
            }
        }
        ApprovalItemRef::CameraModelD3MultiClipping(i) => {
            if i.0 >= model.camera_model_d3_multi_clipping_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                });
            }
        }
        ApprovalItemRef::CameraModelD3WithHlhsr(i) => {
            if i.0 >= model.camera_model_d3_with_hlhsr_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_WITH_HLHSR",
                });
            }
        }
        ApprovalItemRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        ApprovalItemRef::CcDesignDateAndTimeAssignment(i) => {
            if i.0 >= model.cc_design_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        ApprovalItemRef::Certification(i) => {
            if i.0 >= model.certification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CERTIFICATION",
                });
            }
        }
        ApprovalItemRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        ApprovalItemRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        ApprovalItemRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        ApprovalItemRef::ComplexTriangulatedSurfaceSet(i) => {
            if i.0 >= model.complex_triangulated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_SURFACE_SET",
                });
            }
        }
        ApprovalItemRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        ApprovalItemRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        ApprovalItemRef::CompoundRepresentationItem(i) => {
            if i.0 >= model.compound_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOUND_REPRESENTATION_ITEM",
                });
            }
        }
        ApprovalItemRef::ConfigurationDesign(i) => {
            if i.0 >= model.configuration_design_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_DESIGN",
                });
            }
        }
        ApprovalItemRef::ConfigurationEffectivity(i) => {
            if i.0 >= model.configuration_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_EFFECTIVITY",
                });
            }
        }
        ApprovalItemRef::ConfigurationItem(i) => {
            if i.0 >= model.configuration_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_ITEM",
                });
            }
        }
        ApprovalItemRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        ApprovalItemRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        ApprovalItemRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        ApprovalItemRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::ConstructiveGeometryRepresentationRelationship(i) => {
            if i.0
                >= model
                    .constructive_geometry_representation_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        ApprovalItemRef::ContextDependentOverRidingStyledItem(i) => {
            if i.0
                >= model
                    .context_dependent_over_riding_styled_item_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        ApprovalItemRef::Contract(i) => {
            if i.0 >= model.contract_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONTRACT" });
            }
        }
        ApprovalItemRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
        ApprovalItemRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        ApprovalItemRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        ApprovalItemRef::Date(i) => {
            if i.0 >= model.date_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATE" });
            }
        }
        ApprovalItemRef::DateAndTimeAssignment(i) => {
            if i.0 >= model.date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        ApprovalItemRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        ApprovalItemRef::DefinedSymbol(i) => {
            if i.0 >= model.defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_SYMBOL",
                });
            }
        }
        ApprovalItemRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::DefinitionalRepresentationRelationship(i) => {
            if i.0
                >= model
                    .definitional_representation_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        ApprovalItemRef::DefinitionalRepresentationRelationshipWithSameContext(i) => {
            if i.0
                >= model
                    .definitional_representation_relationship_with_same_context_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION_RELATIONSHIP_WITH_SAME_CONTEXT",
                });
            }
        }
        ApprovalItemRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        ApprovalItemRef::DescriptiveRepresentationItem(i) => {
            if i.0 >= model.descriptive_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESCRIPTIVE_REPRESENTATION_ITEM",
                });
            }
        }
        ApprovalItemRef::DesignContext(i) => {
            if i.0 >= model.design_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESIGN_CONTEXT",
                });
            }
        }
        ApprovalItemRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        ApprovalItemRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        ApprovalItemRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        ApprovalItemRef::Direction(i) => {
            if i.0 >= model.direction_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTION",
                });
            }
        }
        ApprovalItemRef::Document(i) => {
            if i.0 >= model.document_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DOCUMENT" });
            }
        }
        ApprovalItemRef::DocumentFile(i) => {
            if i.0 >= model.document_file_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_FILE",
                });
            }
        }
        ApprovalItemRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        ApprovalItemRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        ApprovalItemRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        ApprovalItemRef::Edge(i) => {
            if i.0 >= model.edge_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "EDGE" });
            }
        }
        ApprovalItemRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        ApprovalItemRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        ApprovalItemRef::Effectivity(i) => {
            if i.0 >= model.effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EFFECTIVITY",
                });
            }
        }
        ApprovalItemRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        ApprovalItemRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        ApprovalItemRef::ExternallyDefinedHatchStyle(i) => {
            if i.0 >= model.externally_defined_hatch_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_HATCH_STYLE",
                });
            }
        }
        ApprovalItemRef::ExternallyDefinedTileStyle(i) => {
            if i.0 >= model.externally_defined_tile_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE_STYLE",
                });
            }
        }
        ApprovalItemRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        ApprovalItemRef::FaceBound(i) => {
            if i.0 >= model.face_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_BOUND",
                });
            }
        }
        ApprovalItemRef::FaceOuterBound(i) => {
            if i.0 >= model.face_outer_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_OUTER_BOUND",
                });
            }
        }
        ApprovalItemRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        ApprovalItemRef::FeatureForDatumTargetRelationship(i) => {
            if i.0
                >= model
                    .feature_for_datum_target_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FEATURE_FOR_DATUM_TARGET_RELATIONSHIP",
                });
            }
        }
        ApprovalItemRef::FillAreaStyleHatching(i) => {
            if i.0 >= model.fill_area_style_hatching_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_HATCHING",
                });
            }
        }
        ApprovalItemRef::FillAreaStyleTileColouredRegion(i) => {
            if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION",
                });
            }
        }
        ApprovalItemRef::FillAreaStyleTileCurveWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_curve_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE",
                });
            }
        }
        ApprovalItemRef::FillAreaStyleTileSymbolWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_symbol_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
                });
            }
        }
        ApprovalItemRef::FillAreaStyleTiles(i) => {
            if i.0 >= model.fill_area_style_tiles_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILES",
                });
            }
        }
        ApprovalItemRef::GeneralProperty(i) => {
            if i.0 >= model.general_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_PROPERTY",
                });
            }
        }
        ApprovalItemRef::GeometricCurveSet(i) => {
            if i.0 >= model.geometric_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_CURVE_SET",
                });
            }
        }
        ApprovalItemRef::GeometricRepresentationItem(i) => {
            if i.0 >= model.geometric_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_ITEM",
                });
            }
        }
        ApprovalItemRef::GeometricSet(i) => {
            if i.0 >= model.geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_SET",
                });
            }
        }
        ApprovalItemRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::Group(i) => {
            if i.0 >= model.group_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "GROUP" });
            }
        }
        ApprovalItemRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        ApprovalItemRef::IntegerRepresentationItem(i) => {
            if i.0 >= model.integer_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTEGER_REPRESENTATION_ITEM",
                });
            }
        }
        ApprovalItemRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        ApprovalItemRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        ApprovalItemRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        ApprovalItemRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        ApprovalItemRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        ApprovalItemRef::Loop(i) => {
            if i.0 >= model.loop_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LOOP" });
            }
        }
        ApprovalItemRef::MakeFromUsageOption(i) => {
            if i.0 >= model.make_from_usage_option_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAKE_FROM_USAGE_OPTION",
                });
            }
        }
        ApprovalItemRef::ManifoldSolidBrep(i) => {
            if i.0 >= model.manifold_solid_brep_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SOLID_BREP",
                });
            }
        }
        ApprovalItemRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::MappedItem(i) => {
            if i.0 >= model.mapped_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAPPED_ITEM",
                });
            }
        }
        ApprovalItemRef::MeasureRepresentationItem(i) => {
            if i.0 >= model.measure_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_REPRESENTATION_ITEM",
                });
            }
        }
        ApprovalItemRef::MechanicalDesignAndDraughtingRelationship(i) => {
            if i.0
                >= model
                    .mechanical_design_and_draughting_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_AND_DRAUGHTING_RELATIONSHIP",
                });
            }
        }
        ApprovalItemRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::MechanicalDesignPresentationRepresentationWithDraughting(i) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        ApprovalItemRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        ApprovalItemRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        ApprovalItemRef::OneDirectionRepeatFactor(i) => {
            if i.0 >= model.one_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ONE_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        ApprovalItemRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        ApprovalItemRef::Organization(i) => {
            if i.0 >= model.organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION",
                });
            }
        }
        ApprovalItemRef::OrganizationRelationship(i) => {
            if i.0 >= model.organization_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION_RELATIONSHIP",
                });
            }
        }
        ApprovalItemRef::OrganizationalAddress(i) => {
            if i.0 >= model.organizational_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_ADDRESS",
                });
            }
        }
        ApprovalItemRef::OrganizationalProject(i) => {
            if i.0 >= model.organizational_project_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT",
                });
            }
        }
        ApprovalItemRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        ApprovalItemRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        ApprovalItemRef::OverRidingStyledItem(i) => {
            if i.0 >= model.over_riding_styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        ApprovalItemRef::Path(i) => {
            if i.0 >= model.path_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PATH" });
            }
        }
        ApprovalItemRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        ApprovalItemRef::PersonAndOrganization(i) => {
            if i.0 >= model.person_and_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION",
                });
            }
        }
        ApprovalItemRef::PersonAndOrganizationAddress(i) => {
            if i.0 >= model.person_and_organization_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION_ADDRESS",
                });
            }
        }
        ApprovalItemRef::Placement(i) => {
            if i.0 >= model.placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACEMENT",
                });
            }
        }
        ApprovalItemRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        ApprovalItemRef::PlanarExtent(i) => {
            if i.0 >= model.planar_extent_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_EXTENT",
                });
            }
        }
        ApprovalItemRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        ApprovalItemRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        ApprovalItemRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        ApprovalItemRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        ApprovalItemRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        ApprovalItemRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        ApprovalItemRef::Product(i) => {
            if i.0 >= model.product_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PRODUCT" });
            }
        }
        ApprovalItemRef::ProductConcept(i) => {
            if i.0 >= model.product_concept_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT",
                });
            }
        }
        ApprovalItemRef::ProductConceptFeature(i) => {
            if i.0 >= model.product_concept_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE",
                });
            }
        }
        ApprovalItemRef::ProductConceptFeatureCategory(i) => {
            if i.0 >= model.product_concept_feature_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE_CATEGORY",
                });
            }
        }
        ApprovalItemRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        ApprovalItemRef::ProductDefinitionContext(i) => {
            if i.0 >= model.product_definition_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_CONTEXT",
                });
            }
        }
        ApprovalItemRef::ProductDefinitionEffectivity(i) => {
            if i.0 >= model.product_definition_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_EFFECTIVITY",
                });
            }
        }
        ApprovalItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        ApprovalItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        ApprovalItemRef::ProductDefinitionRelationship(i) => {
            if i.0 >= model.product_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP",
                });
            }
        }
        ApprovalItemRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        ApprovalItemRef::ProductDefinitionSubstitute(i) => {
            if i.0 >= model.product_definition_substitute_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SUBSTITUTE",
                });
            }
        }
        ApprovalItemRef::ProductDefinitionUsage(i) => {
            if i.0 >= model.product_definition_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_USAGE",
                });
            }
        }
        ApprovalItemRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        ApprovalItemRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        ApprovalItemRef::PropertyDefinitionRepresentation(i) => {
            if i.0 >= model.property_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::QualifiedRepresentationItem(i) => {
            if i.0 >= model.qualified_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUALIFIED_REPRESENTATION_ITEM",
                });
            }
        }
        ApprovalItemRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        ApprovalItemRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        ApprovalItemRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        ApprovalItemRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        ApprovalItemRef::RealRepresentationItem(i) => {
            if i.0 >= model.real_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REAL_REPRESENTATION_ITEM",
                });
            }
        }
        ApprovalItemRef::RepositionedTessellatedItem(i) => {
            if i.0 >= model.repositioned_tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPOSITIONED_TESSELLATED_ITEM",
                });
            }
        }
        ApprovalItemRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::RepresentationItem(i) => {
            if i.0 >= model.representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_ITEM",
                });
            }
        }
        ApprovalItemRef::RepresentationRelationship(i) => {
            if i.0 >= model.representation_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        ApprovalItemRef::RepresentationRelationshipWithTransformation(i) => {
            if i.0
                >= model
                    .representation_relationship_with_transformation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION",
                });
            }
        }
        ApprovalItemRef::ResourceProperty(i) => {
            if i.0 >= model.resource_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RESOURCE_PROPERTY",
                });
            }
        }
        ApprovalItemRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        ApprovalItemRef::SecurityClassification(i) => {
            if i.0 >= model.security_classification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION",
                });
            }
        }
        ApprovalItemRef::ShapeAspectAssociativity(i) => {
            if i.0 >= model.shape_aspect_associativity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_ASSOCIATIVITY",
                });
            }
        }
        ApprovalItemRef::ShapeAspectDerivingRelationship(i) => {
            if i.0 >= model.shape_aspect_deriving_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_DERIVING_RELATIONSHIP",
                });
            }
        }
        ApprovalItemRef::ShapeAspectRelationship(i) => {
            if i.0 >= model.shape_aspect_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_RELATIONSHIP",
                });
            }
        }
        ApprovalItemRef::ShapeDefinitionRepresentation(i) => {
            if i.0 >= model.shape_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DEFINITION_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::ShapeRepresentationRelationship(i) => {
            if i.0 >= model.shape_representation_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        ApprovalItemRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        ApprovalItemRef::ShellBasedSurfaceModel(i) => {
            if i.0 >= model.shell_based_surface_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHELL_BASED_SURFACE_MODEL",
                });
            }
        }
        ApprovalItemRef::SolidModel(i) => {
            if i.0 >= model.solid_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_MODEL",
                });
            }
        }
        ApprovalItemRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        ApprovalItemRef::StyledItem(i) => {
            if i.0 >= model.styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STYLED_ITEM",
                });
            }
        }
        ApprovalItemRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        ApprovalItemRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        ApprovalItemRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        ApprovalItemRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        ApprovalItemRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        ApprovalItemRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::SymbolTarget(i) => {
            if i.0 >= model.symbol_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_TARGET",
                });
            }
        }
        ApprovalItemRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        ApprovalItemRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        ApprovalItemRef::TessellatedCurveSet(i) => {
            if i.0 >= model.tessellated_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_CURVE_SET",
                });
            }
        }
        ApprovalItemRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        ApprovalItemRef::TessellatedGeometricSet(i) => {
            if i.0 >= model.tessellated_geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                });
            }
        }
        ApprovalItemRef::TessellatedItem(i) => {
            if i.0 >= model.tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ITEM",
                });
            }
        }
        ApprovalItemRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        ApprovalItemRef::TessellatedShell(i) => {
            if i.0 >= model.tessellated_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHELL",
                });
            }
        }
        ApprovalItemRef::TessellatedSolid(i) => {
            if i.0 >= model.tessellated_solid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SOLID",
                });
            }
        }
        ApprovalItemRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        ApprovalItemRef::TessellatedSurfaceSet(i) => {
            if i.0 >= model.tessellated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SURFACE_SET",
                });
            }
        }
        ApprovalItemRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        ApprovalItemRef::TopologicalRepresentationItem(i) => {
            if i.0 >= model.topological_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOPOLOGICAL_REPRESENTATION_ITEM",
                });
            }
        }
        ApprovalItemRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        ApprovalItemRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        ApprovalItemRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        ApprovalItemRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        ApprovalItemRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        ApprovalItemRef::ValueRepresentationItem(i) => {
            if i.0 >= model.value_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VALUE_REPRESENTATION_ITEM",
                });
            }
        }
        ApprovalItemRef::Vector(i) => {
            if i.0 >= model.vector_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VECTOR" });
            }
        }
        ApprovalItemRef::VersionedActionRequest(i) => {
            if i.0 >= model.versioned_action_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERSIONED_ACTION_REQUEST",
                });
            }
        }
        ApprovalItemRef::Vertex(i) => {
            if i.0 >= model.vertex_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VERTEX" });
            }
        }
        ApprovalItemRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
        ApprovalItemRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        ApprovalItemRef::VertexShell(i) => {
            if i.0 >= model.vertex_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_SHELL",
                });
            }
        }
        ApprovalItemRef::WireShell(i) => {
            if i.0 >= model.wire_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "WIRE_SHELL",
                });
            }
        }
        ApprovalItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_approval_role_ref(model: &StepModel, r: &ApprovalRoleRef) -> Result<(), AuthorError> {
    match r {
        ApprovalRoleRef::ApprovalRole(i) => {
            if i.0 >= model.approval_role_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_ROLE",
                });
            }
        }
    }
    Ok(())
}
fn check_approval_status_ref(model: &StepModel, r: &ApprovalStatusRef) -> Result<(), AuthorError> {
    match r {
        ApprovalStatusRef::ApprovalStatus(i) => {
            if i.0 >= model.approval_status_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_STATUS",
                });
            }
        }
    }
    Ok(())
}
fn check_approved_item_ref(model: &StepModel, r: &ApprovedItemRef) -> Result<(), AuthorError> {
    match r {
        ApprovedItemRef::Certification(i) => {
            if i.0 >= model.certification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CERTIFICATION",
                });
            }
        }
        ApprovedItemRef::Change(i) => {
            if i.0 >= model.change_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CHANGE" });
            }
        }
        ApprovedItemRef::ChangeRequest(i) => {
            if i.0 >= model.change_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHANGE_REQUEST",
                });
            }
        }
        ApprovedItemRef::ConfigurationEffectivity(i) => {
            if i.0 >= model.configuration_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_EFFECTIVITY",
                });
            }
        }
        ApprovedItemRef::ConfigurationItem(i) => {
            if i.0 >= model.configuration_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_ITEM",
                });
            }
        }
        ApprovedItemRef::Contract(i) => {
            if i.0 >= model.contract_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONTRACT" });
            }
        }
        ApprovedItemRef::Product(i) => {
            if i.0 >= model.product_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PRODUCT" });
            }
        }
        ApprovedItemRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        ApprovedItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        ApprovedItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        ApprovedItemRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        ApprovedItemRef::SecurityClassification(i) => {
            if i.0 >= model.security_classification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION",
                });
            }
        }
        ApprovedItemRef::StartRequest(i) => {
            if i.0 >= model.start_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "START_REQUEST",
                });
            }
        }
        ApprovedItemRef::StartWork(i) => {
            if i.0 >= model.start_work_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "START_WORK",
                });
            }
        }
        ApprovedItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_ascribable_state_ref(
    model: &StepModel,
    r: &AscribableStateRef,
) -> Result<(), AuthorError> {
    match r {
        AscribableStateRef::AscribableState(i) => {
            if i.0 >= model.ascribable_state_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASCRIBABLE_STATE",
                });
            }
        }
    }
    Ok(())
}
fn check_axis1_placement_ref(model: &StepModel, r: &Axis1PlacementRef) -> Result<(), AuthorError> {
    match r {
        Axis1PlacementRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
    }
    Ok(())
}
fn check_axis2_placement_ref(model: &StepModel, r: &Axis2PlacementRef) -> Result<(), AuthorError> {
    match r {
        Axis2PlacementRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        Axis2PlacementRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
    }
    Ok(())
}
fn check_axis2_placement3d_ref(
    model: &StepModel,
    r: &Axis2Placement3dRef,
) -> Result<(), AuthorError> {
    match r {
        Axis2Placement3dRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
    }
    Ok(())
}
fn check_camera_model_d3_multi_clipping_intersection_select_ref(
    model: &StepModel,
    r: &CameraModelD3MultiClippingIntersectionSelectRef,
) -> Result<(), AuthorError> {
    match r {
        CameraModelD3MultiClippingIntersectionSelectRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
    }
    Ok(())
}
fn check_cartesian_point_ref(model: &StepModel, r: &CartesianPointRef) -> Result<(), AuthorError> {
    match r {
        CartesianPointRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        CartesianPointRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        CartesianPointRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
    }
    Ok(())
}
fn check_cc_classified_item_ref(
    model: &StepModel,
    r: &CcClassifiedItemRef,
) -> Result<(), AuthorError> {
    match r {
        CcClassifiedItemRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        CcClassifiedItemRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        CcClassifiedItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        CcClassifiedItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        CcClassifiedItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_cc_person_organization_item_ref(
    model: &StepModel,
    r: &CcPersonOrganizationItemRef,
) -> Result<(), AuthorError> {
    match r {
        CcPersonOrganizationItemRef::Change(i) => {
            if i.0 >= model.change_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CHANGE" });
            }
        }
        CcPersonOrganizationItemRef::ChangeRequest(i) => {
            if i.0 >= model.change_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHANGE_REQUEST",
                });
            }
        }
        CcPersonOrganizationItemRef::ConfigurationItem(i) => {
            if i.0 >= model.configuration_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_ITEM",
                });
            }
        }
        CcPersonOrganizationItemRef::Contract(i) => {
            if i.0 >= model.contract_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONTRACT" });
            }
        }
        CcPersonOrganizationItemRef::Product(i) => {
            if i.0 >= model.product_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PRODUCT" });
            }
        }
        CcPersonOrganizationItemRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        CcPersonOrganizationItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        CcPersonOrganizationItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        CcPersonOrganizationItemRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        CcPersonOrganizationItemRef::SecurityClassification(i) => {
            if i.0 >= model.security_classification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION",
                });
            }
        }
        CcPersonOrganizationItemRef::StartRequest(i) => {
            if i.0 >= model.start_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "START_REQUEST",
                });
            }
        }
        CcPersonOrganizationItemRef::StartWork(i) => {
            if i.0 >= model.start_work_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "START_WORK",
                });
            }
        }
        CcPersonOrganizationItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_certification_type_ref(
    model: &StepModel,
    r: &CertificationTypeRef,
) -> Result<(), AuthorError> {
    match r {
        CertificationTypeRef::CertificationType(i) => {
            if i.0 >= model.certification_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CERTIFICATION_TYPE",
                });
            }
        }
    }
    Ok(())
}
fn check_change_request_item_ref(
    model: &StepModel,
    r: &ChangeRequestItemRef,
) -> Result<(), AuthorError> {
    match r {
        ChangeRequestItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        ChangeRequestItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        ChangeRequestItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_character_style_select_ref(
    model: &StepModel,
    r: &CharacterStyleSelectRef,
) -> Result<(), AuthorError> {
    match r {
        CharacterStyleSelectRef::CharacterGlyphStyleOutline(i) => {
            if i.0 >= model.character_glyph_style_outline_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTER_GLYPH_STYLE_OUTLINE",
                });
            }
        }
        CharacterStyleSelectRef::CharacterGlyphStyleStroke(i) => {
            if i.0 >= model.character_glyph_style_stroke_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTER_GLYPH_STYLE_STROKE",
                });
            }
        }
        CharacterStyleSelectRef::TextStyleForDefinedFont(i) => {
            if i.0 >= model.text_style_for_defined_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_STYLE_FOR_DEFINED_FONT",
                });
            }
        }
        CharacterStyleSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_characterized_action_definition_ref(
    model: &StepModel,
    r: &CharacterizedActionDefinitionRef,
) -> Result<(), AuthorError> {
    match r {
        CharacterizedActionDefinitionRef::Action(i) => {
            if i.0 >= model.action_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ACTION" });
            }
        }
        CharacterizedActionDefinitionRef::ActionMethod(i) => {
            if i.0 >= model.action_method_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD",
                });
            }
        }
        CharacterizedActionDefinitionRef::ActionMethodRelationship(i) => {
            if i.0 >= model.action_method_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD_RELATIONSHIP",
                });
            }
        }
        CharacterizedActionDefinitionRef::ActionRelationship(i) => {
            if i.0 >= model.action_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_RELATIONSHIP",
                });
            }
        }
        CharacterizedActionDefinitionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_characterized_definition_ref(
    model: &StepModel,
    r: &CharacterizedDefinitionRef,
) -> Result<(), AuthorError> {
    match r {
        CharacterizedDefinitionRef::AllAroundShapeAspect(i) => {
            if i.0 >= model.all_around_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ALL_AROUND_SHAPE_ASPECT",
                });
            }
        }
        CharacterizedDefinitionRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        CharacterizedDefinitionRef::AngularSize(i) => {
            if i.0 >= model.angular_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_SIZE",
                });
            }
        }
        CharacterizedDefinitionRef::AngularityTolerance(i) => {
            if i.0 >= model.angularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULARITY_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        CharacterizedDefinitionRef::CentreOfSymmetry(i) => {
            if i.0 >= model.centre_of_symmetry_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CENTRE_OF_SYMMETRY",
                });
            }
        }
        CharacterizedDefinitionRef::CharacterizedItemWithinRepresentation(i) => {
            if i.0
                >= model
                    .characterized_item_within_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_ITEM_WITHIN_REPRESENTATION",
                });
            }
        }
        CharacterizedDefinitionRef::CharacterizedObject(i) => {
            if i.0 >= model.characterized_object_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_OBJECT",
                });
            }
        }
        CharacterizedDefinitionRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        CharacterizedDefinitionRef::CircularRunoutTolerance(i) => {
            if i.0 >= model.circular_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CIRCULAR_RUNOUT_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::CoaxialityTolerance(i) => {
            if i.0 >= model.coaxiality_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COAXIALITY_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        CharacterizedDefinitionRef::CompositeGroupShapeAspect(i) => {
            if i.0 >= model.composite_group_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_GROUP_SHAPE_ASPECT",
                });
            }
        }
        CharacterizedDefinitionRef::CompositeShapeAspect(i) => {
            if i.0 >= model.composite_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_SHAPE_ASPECT",
                });
            }
        }
        CharacterizedDefinitionRef::ConcentricityTolerance(i) => {
            if i.0 >= model.concentricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONCENTRICITY_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::ContinuousShapeAspect(i) => {
            if i.0 >= model.continuous_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTINUOUS_SHAPE_ASPECT",
                });
            }
        }
        CharacterizedDefinitionRef::CylindricityTolerance(i) => {
            if i.0 >= model.cylindricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICITY_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        CharacterizedDefinitionRef::DatumFeature(i) => {
            if i.0 >= model.datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_FEATURE",
                });
            }
        }
        CharacterizedDefinitionRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
        CharacterizedDefinitionRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        CharacterizedDefinitionRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        CharacterizedDefinitionRef::DatumTarget(i) => {
            if i.0 >= model.datum_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_TARGET",
                });
            }
        }
        CharacterizedDefinitionRef::DefaultModelGeometricView(i) => {
            if i.0 >= model.default_model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFAULT_MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        CharacterizedDefinitionRef::DerivedShapeAspect(i) => {
            if i.0 >= model.derived_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_SHAPE_ASPECT",
                });
            }
        }
        CharacterizedDefinitionRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        CharacterizedDefinitionRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        CharacterizedDefinitionRef::DimensionalSize(i) => {
            if i.0 >= model.dimensional_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE",
                });
            }
        }
        CharacterizedDefinitionRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        CharacterizedDefinitionRef::DimensionalSizeWithPath(i) => {
            if i.0 >= model.dimensional_size_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_PATH",
                });
            }
        }
        CharacterizedDefinitionRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        CharacterizedDefinitionRef::DocumentFile(i) => {
            if i.0 >= model.document_file_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_FILE",
                });
            }
        }
        CharacterizedDefinitionRef::DraughtingModelItemAssociation(i) => {
            if i.0 >= model.draughting_model_item_association_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL_ITEM_ASSOCIATION",
                });
            }
        }
        CharacterizedDefinitionRef::DraughtingModelItemAssociationWithPlaceholder(i) => {
            if i.0
                >= model
                    .draughting_model_item_association_with_placeholder_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL_ITEM_ASSOCIATION_WITH_PLACEHOLDER",
                });
            }
        }
        CharacterizedDefinitionRef::FeatureForDatumTargetRelationship(i) => {
            if i.0
                >= model
                    .feature_for_datum_target_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FEATURE_FOR_DATUM_TARGET_RELATIONSHIP",
                });
            }
        }
        CharacterizedDefinitionRef::FlatnessTolerance(i) => {
            if i.0 >= model.flatness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FLATNESS_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::GeneralDatumReference(i) => {
            if i.0 >= model.general_datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_DATUM_REFERENCE",
                });
            }
        }
        CharacterizedDefinitionRef::GeometricItemSpecificUsage(i) => {
            if i.0 >= model.geometric_item_specific_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_ITEM_SPECIFIC_USAGE",
                });
            }
        }
        CharacterizedDefinitionRef::GeometricTolerance(i) => {
            if i.0 >= model.geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::GeometricToleranceWithDatumReference(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_datum_reference_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
                });
            }
        }
        CharacterizedDefinitionRef::GeometricToleranceWithDefinedAreaUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_area_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT",
                });
            }
        }
        CharacterizedDefinitionRef::GeometricToleranceWithDefinedUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT",
                });
            }
        }
        CharacterizedDefinitionRef::GeometricToleranceWithMaximumTolerance(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_maximum_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::GeometricToleranceWithModifiers(i) => {
            if i.0 >= model.geometric_tolerance_with_modifiers_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
                });
            }
        }
        CharacterizedDefinitionRef::ItemIdentifiedRepresentationUsage(i) => {
            if i.0 >= model.item_identified_representation_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ITEM_IDENTIFIED_REPRESENTATION_USAGE",
                });
            }
        }
        CharacterizedDefinitionRef::LineProfileTolerance(i) => {
            if i.0 >= model.line_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LINE_PROFILE_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::MakeFromUsageOption(i) => {
            if i.0 >= model.make_from_usage_option_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAKE_FROM_USAGE_OPTION",
                });
            }
        }
        CharacterizedDefinitionRef::ModelGeometricView(i) => {
            if i.0 >= model.model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        CharacterizedDefinitionRef::ModifiedGeometricTolerance(i) => {
            if i.0 >= model.modified_geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MODIFIED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        CharacterizedDefinitionRef::ParallelismTolerance(i) => {
            if i.0 >= model.parallelism_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PARALLELISM_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::PerpendicularityTolerance(i) => {
            if i.0 >= model.perpendicularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERPENDICULARITY_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::PlacedDatumTargetFeature(i) => {
            if i.0 >= model.placed_datum_target_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACED_DATUM_TARGET_FEATURE",
                });
            }
        }
        CharacterizedDefinitionRef::PositionTolerance(i) => {
            if i.0 >= model.position_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POSITION_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        CharacterizedDefinitionRef::ProductDefinitionOccurrence(i) => {
            if i.0 >= model.product_definition_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_OCCURRENCE",
                });
            }
        }
        CharacterizedDefinitionRef::ProductDefinitionRelationship(i) => {
            if i.0 >= model.product_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP",
                });
            }
        }
        CharacterizedDefinitionRef::ProductDefinitionRelationshipRelationship(i) => {
            if i.0
                >= model
                    .product_definition_relationship_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP_RELATIONSHIP",
                });
            }
        }
        CharacterizedDefinitionRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        CharacterizedDefinitionRef::ProductDefinitionUsage(i) => {
            if i.0 >= model.product_definition_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_USAGE",
                });
            }
        }
        CharacterizedDefinitionRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        CharacterizedDefinitionRef::RoundnessTolerance(i) => {
            if i.0 >= model.roundness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ROUNDNESS_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::ShapeAspect(i) => {
            if i.0 >= model.shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT",
                });
            }
        }
        CharacterizedDefinitionRef::ShapeAspectAssociativity(i) => {
            if i.0 >= model.shape_aspect_associativity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_ASSOCIATIVITY",
                });
            }
        }
        CharacterizedDefinitionRef::ShapeAspectDerivingRelationship(i) => {
            if i.0 >= model.shape_aspect_deriving_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_DERIVING_RELATIONSHIP",
                });
            }
        }
        CharacterizedDefinitionRef::ShapeAspectRelationship(i) => {
            if i.0 >= model.shape_aspect_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_RELATIONSHIP",
                });
            }
        }
        CharacterizedDefinitionRef::StraightnessTolerance(i) => {
            if i.0 >= model.straightness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STRAIGHTNESS_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::SurfaceProfileTolerance(i) => {
            if i.0 >= model.surface_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_PROFILE_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::SymmetryTolerance(i) => {
            if i.0 >= model.symmetry_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMMETRY_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::ToleranceZone(i) => {
            if i.0 >= model.tolerance_zone_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE",
                });
            }
        }
        CharacterizedDefinitionRef::ToleranceZoneWithDatum(i) => {
            if i.0 >= model.tolerance_zone_with_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                });
            }
        }
        CharacterizedDefinitionRef::TotalRunoutTolerance(i) => {
            if i.0 >= model.total_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOTAL_RUNOUT_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::UnequallyDisposedGeometricTolerance(i) => {
            if i.0
                >= model
                    .unequally_disposed_geometric_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        CharacterizedDefinitionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_characterized_resource_definition_ref(
    model: &StepModel,
    r: &CharacterizedResourceDefinitionRef,
) -> Result<(), AuthorError> {
    match r {
        CharacterizedResourceDefinitionRef::ActionResource(i) => {
            if i.0 >= model.action_resource_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_RESOURCE",
                });
            }
        }
        CharacterizedResourceDefinitionRef::ActionResourceRelationship(i) => {
            if i.0 >= model.action_resource_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_RESOURCE_RELATIONSHIP",
                });
            }
        }
        CharacterizedResourceDefinitionRef::ActionResourceRequirement(i) => {
            if i.0 >= model.action_resource_requirement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_RESOURCE_REQUIREMENT",
                });
            }
        }
        CharacterizedResourceDefinitionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_closed_shell_ref(model: &StepModel, r: &ClosedShellRef) -> Result<(), AuthorError> {
    match r {
        ClosedShellRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        ClosedShellRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        ClosedShellRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_colour_ref(model: &StepModel, r: &ColourRef) -> Result<(), AuthorError> {
    match r {
        ColourRef::Colour(i) => {
            if i.0 >= model.colour_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COLOUR" });
            }
        }
        ColourRef::ColourRgb(i) => {
            if i.0 >= model.colour_rgb_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COLOUR_RGB",
                });
            }
        }
        ColourRef::ColourSpecification(i) => {
            if i.0 >= model.colour_specification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COLOUR_SPECIFICATION",
                });
            }
        }
        ColourRef::DraughtingPreDefinedColour(i) => {
            if i.0 >= model.draughting_pre_defined_colour_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_PRE_DEFINED_COLOUR",
                });
            }
        }
        ColourRef::PreDefinedColour(i) => {
            if i.0 >= model.pre_defined_colour_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_COLOUR",
                });
            }
        }
        ColourRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_composite_curve_segment_ref(
    model: &StepModel,
    r: &CompositeCurveSegmentRef,
) -> Result<(), AuthorError> {
    match r {
        CompositeCurveSegmentRef::CompositeCurveSegment(i) => {
            if i.0 >= model.composite_curve_segment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE_SEGMENT",
                });
            }
        }
        CompositeCurveSegmentRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_compound_item_definition_ref(
    model: &StepModel,
    r: &CompoundItemDefinitionRef,
) -> Result<(), AuthorError> {
    match r {
        CompoundItemDefinitionRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        CompoundItemDefinitionRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        CompoundItemDefinitionRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        CompoundItemDefinitionRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        CompoundItemDefinitionRef::AnnotationPlaceholderLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE",
            });
        }
        CompoundItemDefinitionRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        CompoundItemDefinitionRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        CompoundItemDefinitionRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        CompoundItemDefinitionRef::AnnotationSymbol(i) => {
            if i.0 >= model.annotation_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL",
                });
            }
        }
        CompoundItemDefinitionRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        CompoundItemDefinitionRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        CompoundItemDefinitionRef::AnnotationTextCharacter(i) => {
            if i.0 >= model.annotation_text_character_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_CHARACTER",
                });
            }
        }
        CompoundItemDefinitionRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        CompoundItemDefinitionRef::AnnotationToAnnotationLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE",
            });
        }
        CompoundItemDefinitionRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
        CompoundItemDefinitionRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        CompoundItemDefinitionRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        CompoundItemDefinitionRef::AuxiliaryLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "AUXILIARY_LEADER_LINE",
            });
        }
        CompoundItemDefinitionRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
        CompoundItemDefinitionRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        CompoundItemDefinitionRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
        CompoundItemDefinitionRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        CompoundItemDefinitionRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        CompoundItemDefinitionRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        CompoundItemDefinitionRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::BrepWithVoids(i) => {
            if i.0 >= model.brep_with_voids_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BREP_WITH_VOIDS",
                });
            }
        }
        CompoundItemDefinitionRef::CameraImage(i) => {
            if i.0 >= model.camera_image_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE",
                });
            }
        }
        CompoundItemDefinitionRef::CameraImage3dWithScale(i) => {
            if i.0 >= model.camera_image3d_with_scale_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE_3D_WITH_SCALE",
                });
            }
        }
        CompoundItemDefinitionRef::CameraModel(i) => {
            if i.0 >= model.camera_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL",
                });
            }
        }
        CompoundItemDefinitionRef::CameraModelD3(i) => {
            if i.0 >= model.camera_model_d3_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3",
                });
            }
        }
        CompoundItemDefinitionRef::CameraModelD3MultiClipping(i) => {
            if i.0 >= model.camera_model_d3_multi_clipping_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                });
            }
        }
        CompoundItemDefinitionRef::CameraModelD3WithHlhsr(i) => {
            if i.0 >= model.camera_model_d3_with_hlhsr_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_WITH_HLHSR",
                });
            }
        }
        CompoundItemDefinitionRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        CompoundItemDefinitionRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        CompoundItemDefinitionRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        CompoundItemDefinitionRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        CompoundItemDefinitionRef::ComplexTriangulatedSurfaceSet(i) => {
            if i.0 >= model.complex_triangulated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_SURFACE_SET",
                });
            }
        }
        CompoundItemDefinitionRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        CompoundItemDefinitionRef::CompoundRepresentationItem(i) => {
            if i.0 >= model.compound_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOUND_REPRESENTATION_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        CompoundItemDefinitionRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        CompoundItemDefinitionRef::ContextDependentOverRidingStyledItem(i) => {
            if i.0
                >= model
                    .context_dependent_over_riding_styled_item_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
        CompoundItemDefinitionRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        CompoundItemDefinitionRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        CompoundItemDefinitionRef::DefinedSymbol(i) => {
            if i.0 >= model.defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_SYMBOL",
                });
            }
        }
        CompoundItemDefinitionRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::DescriptiveRepresentationItem(i) => {
            if i.0 >= model.descriptive_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESCRIPTIVE_REPRESENTATION_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::Direction(i) => {
            if i.0 >= model.direction_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTION",
                });
            }
        }
        CompoundItemDefinitionRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        CompoundItemDefinitionRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        CompoundItemDefinitionRef::Edge(i) => {
            if i.0 >= model.edge_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "EDGE" });
            }
        }
        CompoundItemDefinitionRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        CompoundItemDefinitionRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        CompoundItemDefinitionRef::ExternallyDefinedHatchStyle(i) => {
            if i.0 >= model.externally_defined_hatch_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_HATCH_STYLE",
                });
            }
        }
        CompoundItemDefinitionRef::ExternallyDefinedTileStyle(i) => {
            if i.0 >= model.externally_defined_tile_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE_STYLE",
                });
            }
        }
        CompoundItemDefinitionRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        CompoundItemDefinitionRef::FaceBound(i) => {
            if i.0 >= model.face_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_BOUND",
                });
            }
        }
        CompoundItemDefinitionRef::FaceOuterBound(i) => {
            if i.0 >= model.face_outer_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_OUTER_BOUND",
                });
            }
        }
        CompoundItemDefinitionRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::FillAreaStyleHatching(i) => {
            if i.0 >= model.fill_area_style_hatching_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_HATCHING",
                });
            }
        }
        CompoundItemDefinitionRef::FillAreaStyleTileColouredRegion(i) => {
            if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION",
                });
            }
        }
        CompoundItemDefinitionRef::FillAreaStyleTileCurveWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_curve_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE",
                });
            }
        }
        CompoundItemDefinitionRef::FillAreaStyleTileSymbolWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_symbol_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
                });
            }
        }
        CompoundItemDefinitionRef::FillAreaStyleTiles(i) => {
            if i.0 >= model.fill_area_style_tiles_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILES",
                });
            }
        }
        CompoundItemDefinitionRef::GeometricCurveSet(i) => {
            if i.0 >= model.geometric_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_CURVE_SET",
                });
            }
        }
        CompoundItemDefinitionRef::GeometricRepresentationItem(i) => {
            if i.0 >= model.geometric_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::GeometricSet(i) => {
            if i.0 >= model.geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_SET",
                });
            }
        }
        CompoundItemDefinitionRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        CompoundItemDefinitionRef::IntegerRepresentationItem(i) => {
            if i.0 >= model.integer_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTEGER_REPRESENTATION_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        CompoundItemDefinitionRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        CompoundItemDefinitionRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        CompoundItemDefinitionRef::Loop(i) => {
            if i.0 >= model.loop_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LOOP" });
            }
        }
        CompoundItemDefinitionRef::ManifoldSolidBrep(i) => {
            if i.0 >= model.manifold_solid_brep_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SOLID_BREP",
                });
            }
        }
        CompoundItemDefinitionRef::MappedItem(i) => {
            if i.0 >= model.mapped_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAPPED_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::MeasureRepresentationItem(i) => {
            if i.0 >= model.measure_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_REPRESENTATION_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::OneDirectionRepeatFactor(i) => {
            if i.0 >= model.one_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ONE_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        CompoundItemDefinitionRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        CompoundItemDefinitionRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        CompoundItemDefinitionRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        CompoundItemDefinitionRef::OverRidingStyledItem(i) => {
            if i.0 >= model.over_riding_styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::Path(i) => {
            if i.0 >= model.path_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PATH" });
            }
        }
        CompoundItemDefinitionRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        CompoundItemDefinitionRef::Placement(i) => {
            if i.0 >= model.placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACEMENT",
                });
            }
        }
        CompoundItemDefinitionRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        CompoundItemDefinitionRef::PlanarExtent(i) => {
            if i.0 >= model.planar_extent_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_EXTENT",
                });
            }
        }
        CompoundItemDefinitionRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        CompoundItemDefinitionRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        CompoundItemDefinitionRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        CompoundItemDefinitionRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        CompoundItemDefinitionRef::QualifiedRepresentationItem(i) => {
            if i.0 >= model.qualified_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUALIFIED_REPRESENTATION_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::RealRepresentationItem(i) => {
            if i.0 >= model.real_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REAL_REPRESENTATION_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::RepositionedTessellatedItem(i) => {
            if i.0 >= model.repositioned_tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPOSITIONED_TESSELLATED_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::RepresentationItem(i) => {
            if i.0 >= model.representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::ShellBasedSurfaceModel(i) => {
            if i.0 >= model.shell_based_surface_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHELL_BASED_SURFACE_MODEL",
                });
            }
        }
        CompoundItemDefinitionRef::SolidModel(i) => {
            if i.0 >= model.solid_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_MODEL",
                });
            }
        }
        CompoundItemDefinitionRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::StyledItem(i) => {
            if i.0 >= model.styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STYLED_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        CompoundItemDefinitionRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        CompoundItemDefinitionRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        CompoundItemDefinitionRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::SymbolTarget(i) => {
            if i.0 >= model.symbol_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_TARGET",
                });
            }
        }
        CompoundItemDefinitionRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        CompoundItemDefinitionRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        CompoundItemDefinitionRef::TessellatedCurveSet(i) => {
            if i.0 >= model.tessellated_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_CURVE_SET",
                });
            }
        }
        CompoundItemDefinitionRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        CompoundItemDefinitionRef::TessellatedGeometricSet(i) => {
            if i.0 >= model.tessellated_geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                });
            }
        }
        CompoundItemDefinitionRef::TessellatedItem(i) => {
            if i.0 >= model.tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::TessellatedShell(i) => {
            if i.0 >= model.tessellated_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHELL",
                });
            }
        }
        CompoundItemDefinitionRef::TessellatedSolid(i) => {
            if i.0 >= model.tessellated_solid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SOLID",
                });
            }
        }
        CompoundItemDefinitionRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::TessellatedSurfaceSet(i) => {
            if i.0 >= model.tessellated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SURFACE_SET",
                });
            }
        }
        CompoundItemDefinitionRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        CompoundItemDefinitionRef::TopologicalRepresentationItem(i) => {
            if i.0 >= model.topological_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOPOLOGICAL_REPRESENTATION_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        CompoundItemDefinitionRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        CompoundItemDefinitionRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        CompoundItemDefinitionRef::ValueRepresentationItem(i) => {
            if i.0 >= model.value_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VALUE_REPRESENTATION_ITEM",
                });
            }
        }
        CompoundItemDefinitionRef::Vector(i) => {
            if i.0 >= model.vector_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VECTOR" });
            }
        }
        CompoundItemDefinitionRef::Vertex(i) => {
            if i.0 >= model.vertex_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VERTEX" });
            }
        }
        CompoundItemDefinitionRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
        CompoundItemDefinitionRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        CompoundItemDefinitionRef::VertexShell(i) => {
            if i.0 >= model.vertex_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_SHELL",
                });
            }
        }
        CompoundItemDefinitionRef::WireShell(i) => {
            if i.0 >= model.wire_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "WIRE_SHELL",
                });
            }
        }
        CompoundItemDefinitionRef::ListRepresentationItem(v) => {
            for e in v {
                check_representation_item_ref(model, e)?;
            }
        }
        CompoundItemDefinitionRef::SetRepresentationItem(v) => {
            for e in v {
                check_representation_item_ref(model, e)?;
            }
        }
        CompoundItemDefinitionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_configuration_design_ref(
    model: &StepModel,
    r: &ConfigurationDesignRef,
) -> Result<(), AuthorError> {
    match r {
        ConfigurationDesignRef::ConfigurationDesign(i) => {
            if i.0 >= model.configuration_design_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_DESIGN",
                });
            }
        }
    }
    Ok(())
}
fn check_configuration_design_item_ref(
    model: &StepModel,
    r: &ConfigurationDesignItemRef,
) -> Result<(), AuthorError> {
    match r {
        ConfigurationDesignItemRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        ConfigurationDesignItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        ConfigurationDesignItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        ConfigurationDesignItemRef::ProductDefinitionOccurrence(i) => {
            if i.0 >= model.product_definition_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_OCCURRENCE",
                });
            }
        }
        ConfigurationDesignItemRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        ConfigurationDesignItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_configuration_item_ref(
    model: &StepModel,
    r: &ConfigurationItemRef,
) -> Result<(), AuthorError> {
    match r {
        ConfigurationItemRef::ConfigurationItem(i) => {
            if i.0 >= model.configuration_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_ITEM",
                });
            }
        }
        ConfigurationItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_connected_face_set_ref(
    model: &StepModel,
    r: &ConnectedFaceSetRef,
) -> Result<(), AuthorError> {
    match r {
        ConnectedFaceSetRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        ConnectedFaceSetRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        ConnectedFaceSetRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        ConnectedFaceSetRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        ConnectedFaceSetRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_constructive_geometry_representation_or_shape_representation_ref(
    model: &StepModel,
    r: &ConstructiveGeometryRepresentationOrShapeRepresentationRef,
) -> Result<(), AuthorError> {
    match r {
        ConstructiveGeometryRepresentationOrShapeRepresentationRef::AdvancedBrepShapeRepresentation(i) => { if i.0 >= model.advanced_brep_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ADVANCED_BREP_SHAPE_REPRESENTATION" }); } }
        ConstructiveGeometryRepresentationOrShapeRepresentationRef::ConstructiveGeometryRepresentation(i) => { if i.0 >= model.constructive_geometry_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION" }); } }
        ConstructiveGeometryRepresentationOrShapeRepresentationRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => { if i.0 >= model.geometrically_bounded_surface_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION" }); } }
        ConstructiveGeometryRepresentationOrShapeRepresentationRef::GeometricallyBoundedWireframeShapeRepresentation(i) => { if i.0 >= model.geometrically_bounded_wireframe_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION" }); } }
        ConstructiveGeometryRepresentationOrShapeRepresentationRef::ManifoldSurfaceShapeRepresentation(i) => { if i.0 >= model.manifold_surface_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION" }); } }
        ConstructiveGeometryRepresentationOrShapeRepresentationRef::ShapeDimensionRepresentation(i) => { if i.0 >= model.shape_dimension_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SHAPE_DIMENSION_REPRESENTATION" }); } }
        ConstructiveGeometryRepresentationOrShapeRepresentationRef::ShapeRepresentation(i) => { if i.0 >= model.shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SHAPE_REPRESENTATION" }); } }
        ConstructiveGeometryRepresentationOrShapeRepresentationRef::ShapeRepresentationWithParameters(i) => { if i.0 >= model.shape_representation_with_parameters_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS" }); } }
        ConstructiveGeometryRepresentationOrShapeRepresentationRef::TessellatedShapeRepresentation(i) => { if i.0 >= model.tessellated_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_SHAPE_REPRESENTATION" }); } }
        ConstructiveGeometryRepresentationOrShapeRepresentationRef::Complex(i) => { if i.0 >= model.complex_unit_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "COMPLEX" }); } }
    }
    Ok(())
}
fn check_contract_type_ref(model: &StepModel, r: &ContractTypeRef) -> Result<(), AuthorError> {
    match r {
        ContractTypeRef::ContractType(i) => {
            if i.0 >= model.contract_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTRACT_TYPE",
                });
            }
        }
    }
    Ok(())
}
fn check_coordinated_universal_time_offset_ref(
    model: &StepModel,
    r: &CoordinatedUniversalTimeOffsetRef,
) -> Result<(), AuthorError> {
    match r {
        CoordinatedUniversalTimeOffsetRef::CoordinatedUniversalTimeOffset(i) => {
            if i.0 >= model.coordinated_universal_time_offset_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATED_UNIVERSAL_TIME_OFFSET",
                });
            }
        }
    }
    Ok(())
}
fn check_coordinates_list_ref(
    model: &StepModel,
    r: &CoordinatesListRef,
) -> Result<(), AuthorError> {
    match r {
        CoordinatesListRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
    }
    Ok(())
}
fn check_curve_ref(model: &StepModel, r: &CurveRef) -> Result<(), AuthorError> {
    match r {
        CurveRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        CurveRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        CurveRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        CurveRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        CurveRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        CurveRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        CurveRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        CurveRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        CurveRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        CurveRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        CurveRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        CurveRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        CurveRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        CurveRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        CurveRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        CurveRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        CurveRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        CurveRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        CurveRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        CurveRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        CurveRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        CurveRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        CurveRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_curve_font_or_scaled_curve_font_select_ref(
    model: &StepModel,
    r: &CurveFontOrScaledCurveFontSelectRef,
) -> Result<(), AuthorError> {
    match r {
        CurveFontOrScaledCurveFontSelectRef::CurveStyleFont(i) => {
            if i.0 >= model.curve_style_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CURVE_STYLE_FONT",
                });
            }
        }
        CurveFontOrScaledCurveFontSelectRef::CurveStyleFontAndScaling(i) => {
            if i.0 >= model.curve_style_font_and_scaling_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CURVE_STYLE_FONT_AND_SCALING",
                });
            }
        }
        CurveFontOrScaledCurveFontSelectRef::DraughtingPreDefinedCurveFont(i) => {
            if i.0 >= model.draughting_pre_defined_curve_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_PRE_DEFINED_CURVE_FONT",
                });
            }
        }
        CurveFontOrScaledCurveFontSelectRef::ExternallyDefinedCurveFont(i) => {
            if i.0 >= model.externally_defined_curve_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_CURVE_FONT",
                });
            }
        }
        CurveFontOrScaledCurveFontSelectRef::PreDefinedCurveFont(i) => {
            if i.0 >= model.pre_defined_curve_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_CURVE_FONT",
                });
            }
        }
        CurveFontOrScaledCurveFontSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_curve_or_annotation_curve_occurrence_ref(
    model: &StepModel,
    r: &CurveOrAnnotationCurveOccurrenceRef,
) -> Result<(), AuthorError> {
    match r {
        CurveOrAnnotationCurveOccurrenceRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        CurveOrAnnotationCurveOccurrenceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_curve_or_curve_set_ref(
    model: &StepModel,
    r: &CurveOrCurveSetRef,
) -> Result<(), AuthorError> {
    match r {
        CurveOrCurveSetRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        CurveOrCurveSetRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        CurveOrCurveSetRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        CurveOrCurveSetRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        CurveOrCurveSetRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        CurveOrCurveSetRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        CurveOrCurveSetRef::GeometricCurveSet(i) => {
            if i.0 >= model.geometric_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_CURVE_SET",
                });
            }
        }
        CurveOrCurveSetRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        CurveOrCurveSetRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        CurveOrCurveSetRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        CurveOrCurveSetRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        CurveOrCurveSetRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        CurveOrCurveSetRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_curve_or_render_ref(model: &StepModel, r: &CurveOrRenderRef) -> Result<(), AuthorError> {
    match r {
        CurveOrRenderRef::CurveStyle(i) => {
            if i.0 >= model.curve_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CURVE_STYLE",
                });
            }
        }
        CurveOrRenderRef::CurveStyleRendering(i) => {
            if i.0 >= model.curve_style_rendering_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CURVE_STYLE_RENDERING",
                });
            }
        }
        CurveOrRenderRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_curve_style_ref(model: &StepModel, r: &CurveStyleRef) -> Result<(), AuthorError> {
    match r {
        CurveStyleRef::CurveStyle(i) => {
            if i.0 >= model.curve_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CURVE_STYLE",
                });
            }
        }
        CurveStyleRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_curve_style_font_pattern_ref(
    model: &StepModel,
    r: &CurveStyleFontPatternRef,
) -> Result<(), AuthorError> {
    match r {
        CurveStyleFontPatternRef::CurveStyleFontPattern(i) => {
            if i.0 >= model.curve_style_font_pattern_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CURVE_STYLE_FONT_PATTERN",
                });
            }
        }
        CurveStyleFontPatternRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_curve_style_font_select_ref(
    model: &StepModel,
    r: &CurveStyleFontSelectRef,
) -> Result<(), AuthorError> {
    match r {
        CurveStyleFontSelectRef::CurveStyleFont(i) => {
            if i.0 >= model.curve_style_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CURVE_STYLE_FONT",
                });
            }
        }
        CurveStyleFontSelectRef::DraughtingPreDefinedCurveFont(i) => {
            if i.0 >= model.draughting_pre_defined_curve_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_PRE_DEFINED_CURVE_FONT",
                });
            }
        }
        CurveStyleFontSelectRef::ExternallyDefinedCurveFont(i) => {
            if i.0 >= model.externally_defined_curve_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_CURVE_FONT",
                });
            }
        }
        CurveStyleFontSelectRef::PreDefinedCurveFont(i) => {
            if i.0 >= model.pre_defined_curve_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_CURVE_FONT",
                });
            }
        }
        CurveStyleFontSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_date_ref(model: &StepModel, r: &DateRef) -> Result<(), AuthorError> {
    match r {
        DateRef::CalendarDate(i) => {
            if i.0 >= model.calendar_date_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CALENDAR_DATE",
                });
            }
        }
        DateRef::Date(i) => {
            if i.0 >= model.date_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATE" });
            }
        }
        DateRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_date_and_time_ref(model: &StepModel, r: &DateAndTimeRef) -> Result<(), AuthorError> {
    match r {
        DateAndTimeRef::DateAndTime(i) => {
            if i.0 >= model.date_and_time_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_AND_TIME",
                });
            }
        }
        DateAndTimeRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_date_and_time_item_ref(
    model: &StepModel,
    r: &DateAndTimeItemRef,
) -> Result<(), AuthorError> {
    match r {
        DateAndTimeItemRef::Action(i) => {
            if i.0 >= model.action_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ACTION" });
            }
        }
        DateAndTimeItemRef::ActionDirective(i) => {
            if i.0 >= model.action_directive_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_DIRECTIVE",
                });
            }
        }
        DateAndTimeItemRef::ActionMethod(i) => {
            if i.0 >= model.action_method_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD",
                });
            }
        }
        DateAndTimeItemRef::ActionProperty(i) => {
            if i.0 >= model.action_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_PROPERTY",
                });
            }
        }
        DateAndTimeItemRef::ActionRelationship(i) => {
            if i.0 >= model.action_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_RELATIONSHIP",
                });
            }
        }
        DateAndTimeItemRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::AppliedDateAndTimeAssignment(i) => {
            if i.0 >= model.applied_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        DateAndTimeItemRef::Approval(i) => {
            if i.0 >= model.approval_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "APPROVAL" });
            }
        }
        DateAndTimeItemRef::ApprovalPersonOrganization(i) => {
            if i.0 >= model.approval_person_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_PERSON_ORGANIZATION",
                });
            }
        }
        DateAndTimeItemRef::ApprovalStatus(i) => {
            if i.0 >= model.approval_status_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_STATUS",
                });
            }
        }
        DateAndTimeItemRef::AscribableState(i) => {
            if i.0 >= model.ascribable_state_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASCRIBABLE_STATE",
                });
            }
        }
        DateAndTimeItemRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        DateAndTimeItemRef::CcDesignDateAndTimeAssignment(i) => {
            if i.0 >= model.cc_design_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        DateAndTimeItemRef::Certification(i) => {
            if i.0 >= model.certification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CERTIFICATION",
                });
            }
        }
        DateAndTimeItemRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::ConfigurationDesign(i) => {
            if i.0 >= model.configuration_design_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_DESIGN",
                });
            }
        }
        DateAndTimeItemRef::ConfigurationEffectivity(i) => {
            if i.0 >= model.configuration_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_EFFECTIVITY",
                });
            }
        }
        DateAndTimeItemRef::ConfigurationItem(i) => {
            if i.0 >= model.configuration_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_ITEM",
                });
            }
        }
        DateAndTimeItemRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::Contract(i) => {
            if i.0 >= model.contract_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONTRACT" });
            }
        }
        DateAndTimeItemRef::DateAndTimeAssignment(i) => {
            if i.0 >= model.date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        DateAndTimeItemRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::DesignContext(i) => {
            if i.0 >= model.design_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESIGN_CONTEXT",
                });
            }
        }
        DateAndTimeItemRef::Document(i) => {
            if i.0 >= model.document_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DOCUMENT" });
            }
        }
        DateAndTimeItemRef::DocumentFile(i) => {
            if i.0 >= model.document_file_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_FILE",
                });
            }
        }
        DateAndTimeItemRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        DateAndTimeItemRef::Effectivity(i) => {
            if i.0 >= model.effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EFFECTIVITY",
                });
            }
        }
        DateAndTimeItemRef::GeneralProperty(i) => {
            if i.0 >= model.general_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_PROPERTY",
                });
            }
        }
        DateAndTimeItemRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::MakeFromUsageOption(i) => {
            if i.0 >= model.make_from_usage_option_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAKE_FROM_USAGE_OPTION",
                });
            }
        }
        DateAndTimeItemRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::MechanicalDesignPresentationRepresentationWithDraughting(i) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        DateAndTimeItemRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        DateAndTimeItemRef::OrganizationRelationship(i) => {
            if i.0 >= model.organization_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION_RELATIONSHIP",
                });
            }
        }
        DateAndTimeItemRef::OrganizationalAddress(i) => {
            if i.0 >= model.organizational_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_ADDRESS",
                });
            }
        }
        DateAndTimeItemRef::OrganizationalProject(i) => {
            if i.0 >= model.organizational_project_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT",
                });
            }
        }
        DateAndTimeItemRef::Person(i) => {
            if i.0 >= model.person_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PERSON" });
            }
        }
        DateAndTimeItemRef::PersonAndOrganization(i) => {
            if i.0 >= model.person_and_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION",
                });
            }
        }
        DateAndTimeItemRef::PersonAndOrganizationAddress(i) => {
            if i.0 >= model.person_and_organization_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION_ADDRESS",
                });
            }
        }
        DateAndTimeItemRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        DateAndTimeItemRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        DateAndTimeItemRef::Product(i) => {
            if i.0 >= model.product_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PRODUCT" });
            }
        }
        DateAndTimeItemRef::ProductConcept(i) => {
            if i.0 >= model.product_concept_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT",
                });
            }
        }
        DateAndTimeItemRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        DateAndTimeItemRef::ProductDefinitionContext(i) => {
            if i.0 >= model.product_definition_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_CONTEXT",
                });
            }
        }
        DateAndTimeItemRef::ProductDefinitionEffectivity(i) => {
            if i.0 >= model.product_definition_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_EFFECTIVITY",
                });
            }
        }
        DateAndTimeItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        DateAndTimeItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        DateAndTimeItemRef::ProductDefinitionRelationship(i) => {
            if i.0 >= model.product_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP",
                });
            }
        }
        DateAndTimeItemRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        DateAndTimeItemRef::ProductDefinitionUsage(i) => {
            if i.0 >= model.product_definition_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_USAGE",
                });
            }
        }
        DateAndTimeItemRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        DateAndTimeItemRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        DateAndTimeItemRef::PropertyDefinitionRepresentation(i) => {
            if i.0 >= model.property_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::ResourceProperty(i) => {
            if i.0 >= model.resource_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RESOURCE_PROPERTY",
                });
            }
        }
        DateAndTimeItemRef::SecurityClassification(i) => {
            if i.0 >= model.security_classification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION",
                });
            }
        }
        DateAndTimeItemRef::SecurityClassificationLevel(i) => {
            if i.0 >= model.security_classification_level_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION_LEVEL",
                });
            }
        }
        DateAndTimeItemRef::ShapeDefinitionRepresentation(i) => {
            if i.0 >= model.shape_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DEFINITION_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        DateAndTimeItemRef::StateObserved(i) => {
            if i.0 >= model.state_observed_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_OBSERVED",
                });
            }
        }
        DateAndTimeItemRef::StateType(i) => {
            if i.0 >= model.state_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_TYPE",
                });
            }
        }
        DateAndTimeItemRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        DateAndTimeItemRef::VersionedActionRequest(i) => {
            if i.0 >= model.versioned_action_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERSIONED_ACTION_REQUEST",
                });
            }
        }
        DateAndTimeItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_date_time_item_ref(model: &StepModel, r: &DateTimeItemRef) -> Result<(), AuthorError> {
    match r {
        DateTimeItemRef::ApprovalPersonOrganization(i) => {
            if i.0 >= model.approval_person_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_PERSON_ORGANIZATION",
                });
            }
        }
        DateTimeItemRef::Certification(i) => {
            if i.0 >= model.certification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CERTIFICATION",
                });
            }
        }
        DateTimeItemRef::Change(i) => {
            if i.0 >= model.change_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CHANGE" });
            }
        }
        DateTimeItemRef::ChangeRequest(i) => {
            if i.0 >= model.change_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHANGE_REQUEST",
                });
            }
        }
        DateTimeItemRef::Contract(i) => {
            if i.0 >= model.contract_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONTRACT" });
            }
        }
        DateTimeItemRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        DateTimeItemRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        DateTimeItemRef::SecurityClassification(i) => {
            if i.0 >= model.security_classification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION",
                });
            }
        }
        DateTimeItemRef::StartRequest(i) => {
            if i.0 >= model.start_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "START_REQUEST",
                });
            }
        }
        DateTimeItemRef::StartWork(i) => {
            if i.0 >= model.start_work_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "START_WORK",
                });
            }
        }
        DateTimeItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_date_time_role_ref(model: &StepModel, r: &DateTimeRoleRef) -> Result<(), AuthorError> {
    match r {
        DateTimeRoleRef::DateTimeRole(i) => {
            if i.0 >= model.date_time_role_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_TIME_ROLE",
                });
            }
        }
    }
    Ok(())
}
fn check_date_time_select_ref(model: &StepModel, r: &DateTimeSelectRef) -> Result<(), AuthorError> {
    match r {
        DateTimeSelectRef::CalendarDate(i) => {
            if i.0 >= model.calendar_date_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CALENDAR_DATE",
                });
            }
        }
        DateTimeSelectRef::Date(i) => {
            if i.0 >= model.date_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATE" });
            }
        }
        DateTimeSelectRef::DateAndTime(i) => {
            if i.0 >= model.date_and_time_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_AND_TIME",
                });
            }
        }
        DateTimeSelectRef::LocalTime(i) => {
            if i.0 >= model.local_time_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LOCAL_TIME",
                });
            }
        }
        DateTimeSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_datum_ref(model: &StepModel, r: &DatumRef) -> Result<(), AuthorError> {
    match r {
        DatumRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        DatumRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        DatumRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_datum_or_common_datum_ref(
    model: &StepModel,
    r: &DatumOrCommonDatumRef,
) -> Result<(), AuthorError> {
    match r {
        DatumOrCommonDatumRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        DatumOrCommonDatumRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        DatumOrCommonDatumRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        DatumOrCommonDatumRef::CommonDatumList(v) => {
            for e in v {
                check_datum_reference_element_ref(model, e)?;
            }
        }
        DatumOrCommonDatumRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_datum_reference_compartment_ref(
    model: &StepModel,
    r: &DatumReferenceCompartmentRef,
) -> Result<(), AuthorError> {
    match r {
        DatumReferenceCompartmentRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
    }
    Ok(())
}
fn check_datum_reference_element_ref(
    model: &StepModel,
    r: &DatumReferenceElementRef,
) -> Result<(), AuthorError> {
    match r {
        DatumReferenceElementRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
    }
    Ok(())
}
fn check_datum_reference_modifier_ref(
    model: &StepModel,
    r: &DatumReferenceModifierRef,
) -> Result<(), AuthorError> {
    match r {
        DatumReferenceModifierRef::DatumReferenceModifierWithValue(i) => {
            if i.0 >= model.datum_reference_modifier_with_value_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_MODIFIER_WITH_VALUE",
                });
            }
        }
        DatumReferenceModifierRef::SimpleDatumReferenceModifier(_) => {}
    }
    Ok(())
}
fn check_datum_system_ref(model: &StepModel, r: &DatumSystemRef) -> Result<(), AuthorError> {
    match r {
        DatumSystemRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        DatumSystemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_datum_system_or_reference_ref(
    model: &StepModel,
    r: &DatumSystemOrReferenceRef,
) -> Result<(), AuthorError> {
    match r {
        DatumSystemOrReferenceRef::DatumReference(i) => {
            if i.0 >= model.datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE",
                });
            }
        }
        DatumSystemOrReferenceRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        DatumSystemOrReferenceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_defined_glyph_select_ref(
    model: &StepModel,
    r: &DefinedGlyphSelectRef,
) -> Result<(), AuthorError> {
    match r {
        DefinedGlyphSelectRef::ExternallyDefinedCharacterGlyph(i) => {
            if i.0 >= model.externally_defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        DefinedGlyphSelectRef::PreDefinedCharacterGlyph(i) => {
            if i.0 >= model.pre_defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        DefinedGlyphSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_defined_symbol_select_ref(
    model: &StepModel,
    r: &DefinedSymbolSelectRef,
) -> Result<(), AuthorError> {
    match r {
        DefinedSymbolSelectRef::ExternallyDefinedSymbol(i) => {
            if i.0 >= model.externally_defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_SYMBOL",
                });
            }
        }
        DefinedSymbolSelectRef::PreDefinedPointMarkerSymbol(i) => {
            if i.0 >= model.pre_defined_point_marker_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_POINT_MARKER_SYMBOL",
                });
            }
        }
        DefinedSymbolSelectRef::PreDefinedSymbol(i) => {
            if i.0 >= model.pre_defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_SYMBOL",
                });
            }
        }
        DefinedSymbolSelectRef::PreDefinedTerminatorSymbol(i) => {
            if i.0 >= model.pre_defined_terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_TERMINATOR_SYMBOL",
                });
            }
        }
        DefinedSymbolSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_definitional_representation_ref(
    model: &StepModel,
    r: &DefinitionalRepresentationRef,
) -> Result<(), AuthorError> {
    match r {
        DefinitionalRepresentationRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        DefinitionalRepresentationRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_derived_property_select_ref(
    model: &StepModel,
    r: &DerivedPropertySelectRef,
) -> Result<(), AuthorError> {
    match r {
        DerivedPropertySelectRef::ActionProperty(i) => {
            if i.0 >= model.action_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_PROPERTY",
                });
            }
        }
        DerivedPropertySelectRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        DerivedPropertySelectRef::AngularSize(i) => {
            if i.0 >= model.angular_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_SIZE",
                });
            }
        }
        DerivedPropertySelectRef::AngularityTolerance(i) => {
            if i.0 >= model.angularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULARITY_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::CircularRunoutTolerance(i) => {
            if i.0 >= model.circular_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CIRCULAR_RUNOUT_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::CoaxialityTolerance(i) => {
            if i.0 >= model.coaxiality_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COAXIALITY_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::ConcentricityTolerance(i) => {
            if i.0 >= model.concentricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONCENTRICITY_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::CylindricityTolerance(i) => {
            if i.0 >= model.cylindricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICITY_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        DerivedPropertySelectRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        DerivedPropertySelectRef::DimensionalSize(i) => {
            if i.0 >= model.dimensional_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE",
                });
            }
        }
        DerivedPropertySelectRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        DerivedPropertySelectRef::DimensionalSizeWithPath(i) => {
            if i.0 >= model.dimensional_size_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_PATH",
                });
            }
        }
        DerivedPropertySelectRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        DerivedPropertySelectRef::FlatnessTolerance(i) => {
            if i.0 >= model.flatness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FLATNESS_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::GeometricTolerance(i) => {
            if i.0 >= model.geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::GeometricToleranceWithDatumReference(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_datum_reference_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
                });
            }
        }
        DerivedPropertySelectRef::GeometricToleranceWithDefinedAreaUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_area_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT",
                });
            }
        }
        DerivedPropertySelectRef::GeometricToleranceWithDefinedUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT",
                });
            }
        }
        DerivedPropertySelectRef::GeometricToleranceWithMaximumTolerance(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_maximum_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::GeometricToleranceWithModifiers(i) => {
            if i.0 >= model.geometric_tolerance_with_modifiers_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
                });
            }
        }
        DerivedPropertySelectRef::LineProfileTolerance(i) => {
            if i.0 >= model.line_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LINE_PROFILE_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::ModifiedGeometricTolerance(i) => {
            if i.0 >= model.modified_geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MODIFIED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::ParallelismTolerance(i) => {
            if i.0 >= model.parallelism_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PARALLELISM_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::PerpendicularityTolerance(i) => {
            if i.0 >= model.perpendicularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERPENDICULARITY_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::PositionTolerance(i) => {
            if i.0 >= model.position_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POSITION_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        DerivedPropertySelectRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        DerivedPropertySelectRef::ResourceProperty(i) => {
            if i.0 >= model.resource_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RESOURCE_PROPERTY",
                });
            }
        }
        DerivedPropertySelectRef::RoundnessTolerance(i) => {
            if i.0 >= model.roundness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ROUNDNESS_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::StraightnessTolerance(i) => {
            if i.0 >= model.straightness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STRAIGHTNESS_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::SurfaceProfileTolerance(i) => {
            if i.0 >= model.surface_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_PROFILE_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::SymmetryTolerance(i) => {
            if i.0 >= model.symmetry_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMMETRY_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::TotalRunoutTolerance(i) => {
            if i.0 >= model.total_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOTAL_RUNOUT_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::UnequallyDisposedGeometricTolerance(i) => {
            if i.0
                >= model
                    .unequally_disposed_geometric_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        DerivedPropertySelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_derived_unit_element_ref(
    model: &StepModel,
    r: &DerivedUnitElementRef,
) -> Result<(), AuthorError> {
    match r {
        DerivedUnitElementRef::DerivedUnitElement(i) => {
            if i.0 >= model.derived_unit_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_UNIT_ELEMENT",
                });
            }
        }
    }
    Ok(())
}
fn check_des_apll_point_select_ref(
    model: &StepModel,
    r: &DesApllPointSelectRef,
) -> Result<(), AuthorError> {
    match r {
        DesApllPointSelectRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        DesApllPointSelectRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
    }
    Ok(())
}
fn check_description_attribute_select_ref(
    model: &StepModel,
    r: &DescriptionAttributeSelectRef,
) -> Result<(), AuthorError> {
    match r {
        DescriptionAttributeSelectRef::ActionRequestSolution(i) => {
            if i.0 >= model.action_request_solution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_REQUEST_SOLUTION",
                });
            }
        }
        DescriptionAttributeSelectRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::ApplicationContext(i) => {
            if i.0 >= model.application_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLICATION_CONTEXT",
                });
            }
        }
        DescriptionAttributeSelectRef::ApprovalRole(i) => {
            if i.0 >= model.approval_role_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_ROLE",
                });
            }
        }
        DescriptionAttributeSelectRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::ConfigurationDesign(i) => {
            if i.0 >= model.configuration_design_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_DESIGN",
                });
            }
        }
        DescriptionAttributeSelectRef::ConfigurationEffectivity(i) => {
            if i.0 >= model.configuration_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_EFFECTIVITY",
                });
            }
        }
        DescriptionAttributeSelectRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::ContextDependentShapeRepresentation(i) => {
            if i.0
                >= model
                    .context_dependent_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_SHAPE_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::DateRole(i) => {
            if i.0 >= model.date_role_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_ROLE",
                });
            }
        }
        DescriptionAttributeSelectRef::DateTimeRole(i) => {
            if i.0 >= model.date_time_role_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_TIME_ROLE",
                });
            }
        }
        DescriptionAttributeSelectRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        DescriptionAttributeSelectRef::Effectivity(i) => {
            if i.0 >= model.effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EFFECTIVITY",
                });
            }
        }
        DescriptionAttributeSelectRef::ExternalSource(i) => {
            if i.0 >= model.external_source_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNAL_SOURCE",
                });
            }
        }
        DescriptionAttributeSelectRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::MechanicalDesignPresentationRepresentationWithDraughting(
            i,
        ) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        DescriptionAttributeSelectRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::OrganizationRole(i) => {
            if i.0 >= model.organization_role_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION_ROLE",
                });
            }
        }
        DescriptionAttributeSelectRef::OrganizationalProject(i) => {
            if i.0 >= model.organizational_project_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT",
                });
            }
        }
        DescriptionAttributeSelectRef::PersonAndOrganization(i) => {
            if i.0 >= model.person_and_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION",
                });
            }
        }
        DescriptionAttributeSelectRef::PersonAndOrganizationRole(i) => {
            if i.0 >= model.person_and_organization_role_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION_ROLE",
                });
            }
        }
        DescriptionAttributeSelectRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        DescriptionAttributeSelectRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        DescriptionAttributeSelectRef::ProductDefinitionEffectivity(i) => {
            if i.0 >= model.product_definition_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_EFFECTIVITY",
                });
            }
        }
        DescriptionAttributeSelectRef::PropertyDefinitionRepresentation(i) => {
            if i.0 >= model.property_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::ShapeDefinitionRepresentation(i) => {
            if i.0 >= model.shape_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DEFINITION_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        DescriptionAttributeSelectRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        DescriptionAttributeSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_dimensional_characteristic_ref(
    model: &StepModel,
    r: &DimensionalCharacteristicRef,
) -> Result<(), AuthorError> {
    match r {
        DimensionalCharacteristicRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        DimensionalCharacteristicRef::AngularSize(i) => {
            if i.0 >= model.angular_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_SIZE",
                });
            }
        }
        DimensionalCharacteristicRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        DimensionalCharacteristicRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        DimensionalCharacteristicRef::DimensionalSize(i) => {
            if i.0 >= model.dimensional_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE",
                });
            }
        }
        DimensionalCharacteristicRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        DimensionalCharacteristicRef::DimensionalSizeWithPath(i) => {
            if i.0 >= model.dimensional_size_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_PATH",
                });
            }
        }
        DimensionalCharacteristicRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        DimensionalCharacteristicRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_dimensional_exponents_ref(
    model: &StepModel,
    r: &DimensionalExponentsRef,
) -> Result<(), AuthorError> {
    match r {
        DimensionalExponentsRef::DimensionalExponents(i) => {
            if i.0 >= model.dimensional_exponents_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_EXPONENTS",
                });
            }
        }
    }
    Ok(())
}
fn check_direction_ref(model: &StepModel, r: &DirectionRef) -> Result<(), AuthorError> {
    match r {
        DirectionRef::Direction(i) => {
            if i.0 >= model.direction_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTION",
                });
            }
        }
        DirectionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_document_ref(model: &StepModel, r: &DocumentRef) -> Result<(), AuthorError> {
    match r {
        DocumentRef::Document(i) => {
            if i.0 >= model.document_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DOCUMENT" });
            }
        }
        DocumentRef::DocumentFile(i) => {
            if i.0 >= model.document_file_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_FILE",
                });
            }
        }
        DocumentRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_document_reference_item_ref(
    model: &StepModel,
    r: &DocumentReferenceItemRef,
) -> Result<(), AuthorError> {
    match r {
        DocumentReferenceItemRef::ActionDirective(i) => {
            if i.0 >= model.action_directive_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_DIRECTIVE",
                });
            }
        }
        DocumentReferenceItemRef::ActionMethod(i) => {
            if i.0 >= model.action_method_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD",
                });
            }
        }
        DocumentReferenceItemRef::ActionMethodRelationship(i) => {
            if i.0 >= model.action_method_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::ActionProperty(i) => {
            if i.0 >= model.action_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_PROPERTY",
                });
            }
        }
        DocumentReferenceItemRef::ActionRelationship(i) => {
            if i.0 >= model.action_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        DocumentReferenceItemRef::AllAroundShapeAspect(i) => {
            if i.0 >= model.all_around_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ALL_AROUND_SHAPE_ASPECT",
                });
            }
        }
        DocumentReferenceItemRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        DocumentReferenceItemRef::AngularSize(i) => {
            if i.0 >= model.angular_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_SIZE",
                });
            }
        }
        DocumentReferenceItemRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        DocumentReferenceItemRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        DocumentReferenceItemRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        DocumentReferenceItemRef::AnnotationPlaceholderLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE",
            });
        }
        DocumentReferenceItemRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        DocumentReferenceItemRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        DocumentReferenceItemRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        DocumentReferenceItemRef::AnnotationSymbol(i) => {
            if i.0 >= model.annotation_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL",
                });
            }
        }
        DocumentReferenceItemRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        DocumentReferenceItemRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        DocumentReferenceItemRef::AnnotationTextCharacter(i) => {
            if i.0 >= model.annotation_text_character_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_CHARACTER",
                });
            }
        }
        DocumentReferenceItemRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        DocumentReferenceItemRef::AnnotationToAnnotationLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE",
            });
        }
        DocumentReferenceItemRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
        DocumentReferenceItemRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        DocumentReferenceItemRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        DocumentReferenceItemRef::AppliedDateAndTimeAssignment(i) => {
            if i.0 >= model.applied_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        DocumentReferenceItemRef::AppliedDocumentReference(i) => {
            if i.0 >= model.applied_document_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DOCUMENT_REFERENCE",
                });
            }
        }
        DocumentReferenceItemRef::AppliedExternalIdentificationAssignment(i) => {
            if i.0
                >= model
                    .applied_external_identification_assignment_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT",
                });
            }
        }
        DocumentReferenceItemRef::Approval(i) => {
            if i.0 >= model.approval_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "APPROVAL" });
            }
        }
        DocumentReferenceItemRef::ApprovalPersonOrganization(i) => {
            if i.0 >= model.approval_person_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_PERSON_ORGANIZATION",
                });
            }
        }
        DocumentReferenceItemRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        DocumentReferenceItemRef::AuxiliaryLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "AUXILIARY_LEADER_LINE",
            });
        }
        DocumentReferenceItemRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
        DocumentReferenceItemRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        DocumentReferenceItemRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
        DocumentReferenceItemRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        DocumentReferenceItemRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        DocumentReferenceItemRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        DocumentReferenceItemRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::BrepWithVoids(i) => {
            if i.0 >= model.brep_with_voids_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BREP_WITH_VOIDS",
                });
            }
        }
        DocumentReferenceItemRef::CameraImage(i) => {
            if i.0 >= model.camera_image_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE",
                });
            }
        }
        DocumentReferenceItemRef::CameraImage3dWithScale(i) => {
            if i.0 >= model.camera_image3d_with_scale_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE_3D_WITH_SCALE",
                });
            }
        }
        DocumentReferenceItemRef::CameraModel(i) => {
            if i.0 >= model.camera_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL",
                });
            }
        }
        DocumentReferenceItemRef::CameraModelD3(i) => {
            if i.0 >= model.camera_model_d3_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3",
                });
            }
        }
        DocumentReferenceItemRef::CameraModelD3MultiClipping(i) => {
            if i.0 >= model.camera_model_d3_multi_clipping_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                });
            }
        }
        DocumentReferenceItemRef::CameraModelD3WithHlhsr(i) => {
            if i.0 >= model.camera_model_d3_with_hlhsr_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_WITH_HLHSR",
                });
            }
        }
        DocumentReferenceItemRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        DocumentReferenceItemRef::CcDesignDateAndTimeAssignment(i) => {
            if i.0 >= model.cc_design_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        DocumentReferenceItemRef::CentreOfSymmetry(i) => {
            if i.0 >= model.centre_of_symmetry_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CENTRE_OF_SYMMETRY",
                });
            }
        }
        DocumentReferenceItemRef::Certification(i) => {
            if i.0 >= model.certification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CERTIFICATION",
                });
            }
        }
        DocumentReferenceItemRef::CharacterizedItemWithinRepresentation(i) => {
            if i.0
                >= model
                    .characterized_item_within_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_ITEM_WITHIN_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::CharacterizedObject(i) => {
            if i.0 >= model.characterized_object_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_OBJECT",
                });
            }
        }
        DocumentReferenceItemRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        DocumentReferenceItemRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        DocumentReferenceItemRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        DocumentReferenceItemRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        DocumentReferenceItemRef::ComplexTriangulatedSurfaceSet(i) => {
            if i.0 >= model.complex_triangulated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_SURFACE_SET",
                });
            }
        }
        DocumentReferenceItemRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::CompositeGroupShapeAspect(i) => {
            if i.0 >= model.composite_group_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_GROUP_SHAPE_ASPECT",
                });
            }
        }
        DocumentReferenceItemRef::CompositeShapeAspect(i) => {
            if i.0 >= model.composite_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_SHAPE_ASPECT",
                });
            }
        }
        DocumentReferenceItemRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        DocumentReferenceItemRef::CompoundRepresentationItem(i) => {
            if i.0 >= model.compound_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOUND_REPRESENTATION_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::ConfigurationDesign(i) => {
            if i.0 >= model.configuration_design_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_DESIGN",
                });
            }
        }
        DocumentReferenceItemRef::ConfigurationEffectivity(i) => {
            if i.0 >= model.configuration_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_EFFECTIVITY",
                });
            }
        }
        DocumentReferenceItemRef::ConfigurationItem(i) => {
            if i.0 >= model.configuration_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        DocumentReferenceItemRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        DocumentReferenceItemRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::ConstructiveGeometryRepresentationRelationship(i) => {
            if i.0
                >= model
                    .constructive_geometry_representation_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::ContextDependentOverRidingStyledItem(i) => {
            if i.0
                >= model
                    .context_dependent_over_riding_styled_item_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::ContinuousShapeAspect(i) => {
            if i.0 >= model.continuous_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTINUOUS_SHAPE_ASPECT",
                });
            }
        }
        DocumentReferenceItemRef::Contract(i) => {
            if i.0 >= model.contract_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONTRACT" });
            }
        }
        DocumentReferenceItemRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
        DocumentReferenceItemRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        DocumentReferenceItemRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::DateAndTimeAssignment(i) => {
            if i.0 >= model.date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        DocumentReferenceItemRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        DocumentReferenceItemRef::DatumFeature(i) => {
            if i.0 >= model.datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_FEATURE",
                });
            }
        }
        DocumentReferenceItemRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
        DocumentReferenceItemRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        DocumentReferenceItemRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        DocumentReferenceItemRef::DatumTarget(i) => {
            if i.0 >= model.datum_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_TARGET",
                });
            }
        }
        DocumentReferenceItemRef::DefaultModelGeometricView(i) => {
            if i.0 >= model.default_model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFAULT_MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        DocumentReferenceItemRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        DocumentReferenceItemRef::DefinedSymbol(i) => {
            if i.0 >= model.defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_SYMBOL",
                });
            }
        }
        DocumentReferenceItemRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::DefinitionalRepresentationRelationship(i) => {
            if i.0
                >= model
                    .definitional_representation_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::DefinitionalRepresentationRelationshipWithSameContext(i) => {
            if i.0
                >= model
                    .definitional_representation_relationship_with_same_context_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION_RELATIONSHIP_WITH_SAME_CONTEXT",
                });
            }
        }
        DocumentReferenceItemRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::DerivedShapeAspect(i) => {
            if i.0 >= model.derived_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_SHAPE_ASPECT",
                });
            }
        }
        DocumentReferenceItemRef::DescriptiveRepresentationItem(i) => {
            if i.0 >= model.descriptive_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESCRIPTIVE_REPRESENTATION_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::DesignContext(i) => {
            if i.0 >= model.design_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESIGN_CONTEXT",
                });
            }
        }
        DocumentReferenceItemRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        DocumentReferenceItemRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        DocumentReferenceItemRef::DimensionalSize(i) => {
            if i.0 >= model.dimensional_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE",
                });
            }
        }
        DocumentReferenceItemRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        DocumentReferenceItemRef::DimensionalSizeWithPath(i) => {
            if i.0 >= model.dimensional_size_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_PATH",
                });
            }
        }
        DocumentReferenceItemRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        DocumentReferenceItemRef::Direction(i) => {
            if i.0 >= model.direction_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTION",
                });
            }
        }
        DocumentReferenceItemRef::DocumentFile(i) => {
            if i.0 >= model.document_file_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_FILE",
                });
            }
        }
        DocumentReferenceItemRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        DocumentReferenceItemRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        DocumentReferenceItemRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        DocumentReferenceItemRef::Edge(i) => {
            if i.0 >= model.edge_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "EDGE" });
            }
        }
        DocumentReferenceItemRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        DocumentReferenceItemRef::Effectivity(i) => {
            if i.0 >= model.effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EFFECTIVITY",
                });
            }
        }
        DocumentReferenceItemRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        DocumentReferenceItemRef::ExternallyDefinedCharacterGlyph(i) => {
            if i.0 >= model.externally_defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        DocumentReferenceItemRef::ExternallyDefinedCurveFont(i) => {
            if i.0 >= model.externally_defined_curve_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_CURVE_FONT",
                });
            }
        }
        DocumentReferenceItemRef::ExternallyDefinedHatchStyle(i) => {
            if i.0 >= model.externally_defined_hatch_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_HATCH_STYLE",
                });
            }
        }
        DocumentReferenceItemRef::ExternallyDefinedItem(i) => {
            if i.0 >= model.externally_defined_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::ExternallyDefinedStyle(i) => {
            if i.0 >= model.externally_defined_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_STYLE",
                });
            }
        }
        DocumentReferenceItemRef::ExternallyDefinedSymbol(i) => {
            if i.0 >= model.externally_defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_SYMBOL",
                });
            }
        }
        DocumentReferenceItemRef::ExternallyDefinedTextFont(i) => {
            if i.0 >= model.externally_defined_text_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TEXT_FONT",
                });
            }
        }
        DocumentReferenceItemRef::ExternallyDefinedTile(i) => {
            if i.0 >= model.externally_defined_tile_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE",
                });
            }
        }
        DocumentReferenceItemRef::ExternallyDefinedTileStyle(i) => {
            if i.0 >= model.externally_defined_tile_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE_STYLE",
                });
            }
        }
        DocumentReferenceItemRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        DocumentReferenceItemRef::FaceBound(i) => {
            if i.0 >= model.face_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_BOUND",
                });
            }
        }
        DocumentReferenceItemRef::FaceOuterBound(i) => {
            if i.0 >= model.face_outer_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_OUTER_BOUND",
                });
            }
        }
        DocumentReferenceItemRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::FeatureForDatumTargetRelationship(i) => {
            if i.0
                >= model
                    .feature_for_datum_target_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FEATURE_FOR_DATUM_TARGET_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::FillAreaStyleHatching(i) => {
            if i.0 >= model.fill_area_style_hatching_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_HATCHING",
                });
            }
        }
        DocumentReferenceItemRef::FillAreaStyleTileColouredRegion(i) => {
            if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION",
                });
            }
        }
        DocumentReferenceItemRef::FillAreaStyleTileCurveWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_curve_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE",
                });
            }
        }
        DocumentReferenceItemRef::FillAreaStyleTileSymbolWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_symbol_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
                });
            }
        }
        DocumentReferenceItemRef::FillAreaStyleTiles(i) => {
            if i.0 >= model.fill_area_style_tiles_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILES",
                });
            }
        }
        DocumentReferenceItemRef::GeneralDatumReference(i) => {
            if i.0 >= model.general_datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_DATUM_REFERENCE",
                });
            }
        }
        DocumentReferenceItemRef::GeneralProperty(i) => {
            if i.0 >= model.general_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_PROPERTY",
                });
            }
        }
        DocumentReferenceItemRef::GeometricCurveSet(i) => {
            if i.0 >= model.geometric_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_CURVE_SET",
                });
            }
        }
        DocumentReferenceItemRef::GeometricRepresentationItem(i) => {
            if i.0 >= model.geometric_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::GeometricSet(i) => {
            if i.0 >= model.geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_SET",
                });
            }
        }
        DocumentReferenceItemRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::Group(i) => {
            if i.0 >= model.group_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "GROUP" });
            }
        }
        DocumentReferenceItemRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        DocumentReferenceItemRef::IntegerRepresentationItem(i) => {
            if i.0 >= model.integer_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTEGER_REPRESENTATION_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        DocumentReferenceItemRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        DocumentReferenceItemRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        DocumentReferenceItemRef::Loop(i) => {
            if i.0 >= model.loop_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LOOP" });
            }
        }
        DocumentReferenceItemRef::MakeFromUsageOption(i) => {
            if i.0 >= model.make_from_usage_option_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAKE_FROM_USAGE_OPTION",
                });
            }
        }
        DocumentReferenceItemRef::ManifoldSolidBrep(i) => {
            if i.0 >= model.manifold_solid_brep_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SOLID_BREP",
                });
            }
        }
        DocumentReferenceItemRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::MappedItem(i) => {
            if i.0 >= model.mapped_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAPPED_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::MeasureRepresentationItem(i) => {
            if i.0 >= model.measure_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_REPRESENTATION_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::MechanicalDesignAndDraughtingRelationship(i) => {
            if i.0
                >= model
                    .mechanical_design_and_draughting_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_AND_DRAUGHTING_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::MechanicalDesignPresentationRepresentationWithDraughting(i) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        DocumentReferenceItemRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::ModelGeometricView(i) => {
            if i.0 >= model.model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        DocumentReferenceItemRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        DocumentReferenceItemRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::OneDirectionRepeatFactor(i) => {
            if i.0 >= model.one_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ONE_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        DocumentReferenceItemRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        DocumentReferenceItemRef::Organization(i) => {
            if i.0 >= model.organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION",
                });
            }
        }
        DocumentReferenceItemRef::OrganizationRelationship(i) => {
            if i.0 >= model.organization_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::OrganizationalAddress(i) => {
            if i.0 >= model.organizational_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_ADDRESS",
                });
            }
        }
        DocumentReferenceItemRef::OrganizationalProject(i) => {
            if i.0 >= model.organizational_project_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT",
                });
            }
        }
        DocumentReferenceItemRef::OrganizationalProjectRelationship(i) => {
            if i.0 >= model.organizational_project_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        DocumentReferenceItemRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        DocumentReferenceItemRef::OverRidingStyledItem(i) => {
            if i.0 >= model.over_riding_styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::Path(i) => {
            if i.0 >= model.path_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PATH" });
            }
        }
        DocumentReferenceItemRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        DocumentReferenceItemRef::Person(i) => {
            if i.0 >= model.person_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PERSON" });
            }
        }
        DocumentReferenceItemRef::PersonAndOrganization(i) => {
            if i.0 >= model.person_and_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION",
                });
            }
        }
        DocumentReferenceItemRef::PersonAndOrganizationAddress(i) => {
            if i.0 >= model.person_and_organization_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION_ADDRESS",
                });
            }
        }
        DocumentReferenceItemRef::PlacedDatumTargetFeature(i) => {
            if i.0 >= model.placed_datum_target_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACED_DATUM_TARGET_FEATURE",
                });
            }
        }
        DocumentReferenceItemRef::Placement(i) => {
            if i.0 >= model.placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACEMENT",
                });
            }
        }
        DocumentReferenceItemRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        DocumentReferenceItemRef::PlanarExtent(i) => {
            if i.0 >= model.planar_extent_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_EXTENT",
                });
            }
        }
        DocumentReferenceItemRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        DocumentReferenceItemRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        DocumentReferenceItemRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        DocumentReferenceItemRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        DocumentReferenceItemRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        DocumentReferenceItemRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        DocumentReferenceItemRef::Product(i) => {
            if i.0 >= model.product_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PRODUCT" });
            }
        }
        DocumentReferenceItemRef::ProductCategory(i) => {
            if i.0 >= model.product_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CATEGORY",
                });
            }
        }
        DocumentReferenceItemRef::ProductConcept(i) => {
            if i.0 >= model.product_concept_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT",
                });
            }
        }
        DocumentReferenceItemRef::ProductConceptFeatureCategory(i) => {
            if i.0 >= model.product_concept_feature_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE_CATEGORY",
                });
            }
        }
        DocumentReferenceItemRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        DocumentReferenceItemRef::ProductDefinitionContext(i) => {
            if i.0 >= model.product_definition_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_CONTEXT",
                });
            }
        }
        DocumentReferenceItemRef::ProductDefinitionEffectivity(i) => {
            if i.0 >= model.product_definition_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_EFFECTIVITY",
                });
            }
        }
        DocumentReferenceItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        DocumentReferenceItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        DocumentReferenceItemRef::ProductDefinitionRelationship(i) => {
            if i.0 >= model.product_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        DocumentReferenceItemRef::ProductDefinitionUsage(i) => {
            if i.0 >= model.product_definition_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_USAGE",
                });
            }
        }
        DocumentReferenceItemRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        DocumentReferenceItemRef::ProductRelatedProductCategory(i) => {
            if i.0 >= model.product_related_product_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_RELATED_PRODUCT_CATEGORY",
                });
            }
        }
        DocumentReferenceItemRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        DocumentReferenceItemRef::PropertyDefinitionRepresentation(i) => {
            if i.0 >= model.property_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::QualifiedRepresentationItem(i) => {
            if i.0 >= model.qualified_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUALIFIED_REPRESENTATION_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::RealRepresentationItem(i) => {
            if i.0 >= model.real_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REAL_REPRESENTATION_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::RepositionedTessellatedItem(i) => {
            if i.0 >= model.repositioned_tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPOSITIONED_TESSELLATED_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::RepresentationItem(i) => {
            if i.0 >= model.representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::RepresentationRelationship(i) => {
            if i.0 >= model.representation_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::RepresentationRelationshipWithTransformation(i) => {
            if i.0
                >= model
                    .representation_relationship_with_transformation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION",
                });
            }
        }
        DocumentReferenceItemRef::ResourceRequirementType(i) => {
            if i.0 >= model.resource_requirement_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RESOURCE_REQUIREMENT_TYPE",
                });
            }
        }
        DocumentReferenceItemRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::SecurityClassification(i) => {
            if i.0 >= model.security_classification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION",
                });
            }
        }
        DocumentReferenceItemRef::ShapeAspect(i) => {
            if i.0 >= model.shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT",
                });
            }
        }
        DocumentReferenceItemRef::ShapeAspectAssociativity(i) => {
            if i.0 >= model.shape_aspect_associativity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_ASSOCIATIVITY",
                });
            }
        }
        DocumentReferenceItemRef::ShapeAspectDerivingRelationship(i) => {
            if i.0 >= model.shape_aspect_deriving_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_DERIVING_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::ShapeAspectRelationship(i) => {
            if i.0 >= model.shape_aspect_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::ShapeDefinitionRepresentation(i) => {
            if i.0 >= model.shape_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DEFINITION_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::ShapeRepresentationRelationship(i) => {
            if i.0 >= model.shape_representation_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        DocumentReferenceItemRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        DocumentReferenceItemRef::ShellBasedSurfaceModel(i) => {
            if i.0 >= model.shell_based_surface_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHELL_BASED_SURFACE_MODEL",
                });
            }
        }
        DocumentReferenceItemRef::SolidModel(i) => {
            if i.0 >= model.solid_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_MODEL",
                });
            }
        }
        DocumentReferenceItemRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::StateObserved(i) => {
            if i.0 >= model.state_observed_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_OBSERVED",
                });
            }
        }
        DocumentReferenceItemRef::StateType(i) => {
            if i.0 >= model.state_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_TYPE",
                });
            }
        }
        DocumentReferenceItemRef::StyledItem(i) => {
            if i.0 >= model.styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STYLED_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        DocumentReferenceItemRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        DocumentReferenceItemRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        DocumentReferenceItemRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::SymbolTarget(i) => {
            if i.0 >= model.symbol_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_TARGET",
                });
            }
        }
        DocumentReferenceItemRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        DocumentReferenceItemRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        DocumentReferenceItemRef::TessellatedCurveSet(i) => {
            if i.0 >= model.tessellated_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_CURVE_SET",
                });
            }
        }
        DocumentReferenceItemRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        DocumentReferenceItemRef::TessellatedGeometricSet(i) => {
            if i.0 >= model.tessellated_geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                });
            }
        }
        DocumentReferenceItemRef::TessellatedItem(i) => {
            if i.0 >= model.tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        DocumentReferenceItemRef::TessellatedShell(i) => {
            if i.0 >= model.tessellated_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHELL",
                });
            }
        }
        DocumentReferenceItemRef::TessellatedSolid(i) => {
            if i.0 >= model.tessellated_solid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SOLID",
                });
            }
        }
        DocumentReferenceItemRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::TessellatedSurfaceSet(i) => {
            if i.0 >= model.tessellated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SURFACE_SET",
                });
            }
        }
        DocumentReferenceItemRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        DocumentReferenceItemRef::ToleranceZone(i) => {
            if i.0 >= model.tolerance_zone_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE",
                });
            }
        }
        DocumentReferenceItemRef::ToleranceZoneWithDatum(i) => {
            if i.0 >= model.tolerance_zone_with_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                });
            }
        }
        DocumentReferenceItemRef::TopologicalRepresentationItem(i) => {
            if i.0 >= model.topological_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOPOLOGICAL_REPRESENTATION_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        DocumentReferenceItemRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        DocumentReferenceItemRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        DocumentReferenceItemRef::ValueRepresentationItem(i) => {
            if i.0 >= model.value_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VALUE_REPRESENTATION_ITEM",
                });
            }
        }
        DocumentReferenceItemRef::Vector(i) => {
            if i.0 >= model.vector_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VECTOR" });
            }
        }
        DocumentReferenceItemRef::VersionedActionRequest(i) => {
            if i.0 >= model.versioned_action_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERSIONED_ACTION_REQUEST",
                });
            }
        }
        DocumentReferenceItemRef::Vertex(i) => {
            if i.0 >= model.vertex_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VERTEX" });
            }
        }
        DocumentReferenceItemRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
        DocumentReferenceItemRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        DocumentReferenceItemRef::VertexShell(i) => {
            if i.0 >= model.vertex_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_SHELL",
                });
            }
        }
        DocumentReferenceItemRef::WireShell(i) => {
            if i.0 >= model.wire_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "WIRE_SHELL",
                });
            }
        }
        DocumentReferenceItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_document_type_ref(model: &StepModel, r: &DocumentTypeRef) -> Result<(), AuthorError> {
    match r {
        DocumentTypeRef::DocumentType(i) => {
            if i.0 >= model.document_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_TYPE",
                });
            }
        }
    }
    Ok(())
}
fn check_draughting_callout_ref(
    model: &StepModel,
    r: &DraughtingCalloutRef,
) -> Result<(), AuthorError> {
    match r {
        DraughtingCalloutRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        DraughtingCalloutRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        DraughtingCalloutRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_draughting_callout_element_ref(
    model: &StepModel,
    r: &DraughtingCalloutElementRef,
) -> Result<(), AuthorError> {
    match r {
        DraughtingCalloutElementRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        DraughtingCalloutElementRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        DraughtingCalloutElementRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        DraughtingCalloutElementRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        DraughtingCalloutElementRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        DraughtingCalloutElementRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        DraughtingCalloutElementRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        DraughtingCalloutElementRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        DraughtingCalloutElementRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        DraughtingCalloutElementRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        DraughtingCalloutElementRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_draughting_model_item_association_select_ref(
    model: &StepModel,
    r: &DraughtingModelItemAssociationSelectRef,
) -> Result<(), AuthorError> {
    match r {
        DraughtingModelItemAssociationSelectRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::AnnotationPlaceholderOccurrenceWithLeaderLine(
            _,
        ) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        DraughtingModelItemAssociationSelectRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        DraughtingModelItemAssociationSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_draughting_model_item_definition_ref(
    model: &StepModel,
    r: &DraughtingModelItemDefinitionRef,
) -> Result<(), AuthorError> {
    match r {
        DraughtingModelItemDefinitionRef::AllAroundShapeAspect(i) => {
            if i.0 >= model.all_around_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ALL_AROUND_SHAPE_ASPECT",
                });
            }
        }
        DraughtingModelItemDefinitionRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        DraughtingModelItemDefinitionRef::AngularSize(i) => {
            if i.0 >= model.angular_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_SIZE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::AngularityTolerance(i) => {
            if i.0 >= model.angularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULARITY_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::CentreOfSymmetry(i) => {
            if i.0 >= model.centre_of_symmetry_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CENTRE_OF_SYMMETRY",
                });
            }
        }
        DraughtingModelItemDefinitionRef::CircularRunoutTolerance(i) => {
            if i.0 >= model.circular_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CIRCULAR_RUNOUT_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::CoaxialityTolerance(i) => {
            if i.0 >= model.coaxiality_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COAXIALITY_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        DraughtingModelItemDefinitionRef::CompositeGroupShapeAspect(i) => {
            if i.0 >= model.composite_group_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_GROUP_SHAPE_ASPECT",
                });
            }
        }
        DraughtingModelItemDefinitionRef::CompositeShapeAspect(i) => {
            if i.0 >= model.composite_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_SHAPE_ASPECT",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ConcentricityTolerance(i) => {
            if i.0 >= model.concentricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONCENTRICITY_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ContinuousShapeAspect(i) => {
            if i.0 >= model.continuous_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTINUOUS_SHAPE_ASPECT",
                });
            }
        }
        DraughtingModelItemDefinitionRef::CylindricityTolerance(i) => {
            if i.0 >= model.cylindricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICITY_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        DraughtingModelItemDefinitionRef::DatumFeature(i) => {
            if i.0 >= model.datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_FEATURE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DatumTarget(i) => {
            if i.0 >= model.datum_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_TARGET",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DefaultModelGeometricView(i) => {
            if i.0 >= model.default_model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFAULT_MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DerivedShapeAspect(i) => {
            if i.0 >= model.derived_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_SHAPE_ASPECT",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DimensionalSize(i) => {
            if i.0 >= model.dimensional_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DimensionalSizeWithPath(i) => {
            if i.0 >= model.dimensional_size_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_PATH",
                });
            }
        }
        DraughtingModelItemDefinitionRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        DraughtingModelItemDefinitionRef::FeatureForDatumTargetRelationship(i) => {
            if i.0
                >= model
                    .feature_for_datum_target_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FEATURE_FOR_DATUM_TARGET_RELATIONSHIP",
                });
            }
        }
        DraughtingModelItemDefinitionRef::FlatnessTolerance(i) => {
            if i.0 >= model.flatness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FLATNESS_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::GeneralDatumReference(i) => {
            if i.0 >= model.general_datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_DATUM_REFERENCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::GeometricTolerance(i) => {
            if i.0 >= model.geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::GeometricToleranceWithDatumReference(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_datum_reference_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::GeometricToleranceWithDefinedAreaUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_area_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT",
                });
            }
        }
        DraughtingModelItemDefinitionRef::GeometricToleranceWithDefinedUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT",
                });
            }
        }
        DraughtingModelItemDefinitionRef::GeometricToleranceWithMaximumTolerance(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_maximum_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::GeometricToleranceWithModifiers(i) => {
            if i.0 >= model.geometric_tolerance_with_modifiers_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
                });
            }
        }
        DraughtingModelItemDefinitionRef::LineProfileTolerance(i) => {
            if i.0 >= model.line_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LINE_PROFILE_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::MakeFromUsageOption(i) => {
            if i.0 >= model.make_from_usage_option_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAKE_FROM_USAGE_OPTION",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ModifiedGeometricTolerance(i) => {
            if i.0 >= model.modified_geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MODIFIED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ParallelismTolerance(i) => {
            if i.0 >= model.parallelism_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PARALLELISM_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::PerpendicularityTolerance(i) => {
            if i.0 >= model.perpendicularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERPENDICULARITY_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::PlacedDatumTargetFeature(i) => {
            if i.0 >= model.placed_datum_target_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACED_DATUM_TARGET_FEATURE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::PositionTolerance(i) => {
            if i.0 >= model.position_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POSITION_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ProductDefinitionRelationship(i) => {
            if i.0 >= model.product_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ProductDefinitionUsage(i) => {
            if i.0 >= model.product_definition_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_USAGE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        DraughtingModelItemDefinitionRef::RoundnessTolerance(i) => {
            if i.0 >= model.roundness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ROUNDNESS_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ShapeAspect(i) => {
            if i.0 >= model.shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ShapeAspectAssociativity(i) => {
            if i.0 >= model.shape_aspect_associativity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_ASSOCIATIVITY",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ShapeAspectDerivingRelationship(i) => {
            if i.0 >= model.shape_aspect_deriving_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_DERIVING_RELATIONSHIP",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ShapeAspectRelationship(i) => {
            if i.0 >= model.shape_aspect_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_RELATIONSHIP",
                });
            }
        }
        DraughtingModelItemDefinitionRef::StraightnessTolerance(i) => {
            if i.0 >= model.straightness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STRAIGHTNESS_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::SurfaceProfileTolerance(i) => {
            if i.0 >= model.surface_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_PROFILE_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::SymmetryTolerance(i) => {
            if i.0 >= model.symmetry_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMMETRY_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ToleranceZone(i) => {
            if i.0 >= model.tolerance_zone_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::ToleranceZoneWithDatum(i) => {
            if i.0 >= model.tolerance_zone_with_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                });
            }
        }
        DraughtingModelItemDefinitionRef::TotalRunoutTolerance(i) => {
            if i.0 >= model.total_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOTAL_RUNOUT_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::UnequallyDisposedGeometricTolerance(i) => {
            if i.0
                >= model
                    .unequally_disposed_geometric_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        DraughtingModelItemDefinitionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_edge_ref(model: &StepModel, r: &EdgeRef) -> Result<(), AuthorError> {
    match r {
        EdgeRef::Edge(i) => {
            if i.0 >= model.edge_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "EDGE" });
            }
        }
        EdgeRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        EdgeRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        EdgeRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_external_identification_item_ref(
    model: &StepModel,
    r: &ExternalIdentificationItemRef,
) -> Result<(), AuthorError> {
    match r {
        ExternalIdentificationItemRef::ActionDirective(i) => {
            if i.0 >= model.action_directive_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_DIRECTIVE",
                });
            }
        }
        ExternalIdentificationItemRef::ActionMethod(i) => {
            if i.0 >= model.action_method_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD",
                });
            }
        }
        ExternalIdentificationItemRef::ActionMethodRelationship(i) => {
            if i.0 >= model.action_method_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD_RELATIONSHIP",
                });
            }
        }
        ExternalIdentificationItemRef::ActionRelationship(i) => {
            if i.0 >= model.action_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_RELATIONSHIP",
                });
            }
        }
        ExternalIdentificationItemRef::Address(i) => {
            if i.0 >= model.address_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ADDRESS" });
            }
        }
        ExternalIdentificationItemRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        ExternalIdentificationItemRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        ExternalIdentificationItemRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        ExternalIdentificationItemRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        ExternalIdentificationItemRef::AnnotationPlaceholderLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE",
            });
        }
        ExternalIdentificationItemRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        ExternalIdentificationItemRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        ExternalIdentificationItemRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        ExternalIdentificationItemRef::AnnotationSymbol(i) => {
            if i.0 >= model.annotation_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL",
                });
            }
        }
        ExternalIdentificationItemRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        ExternalIdentificationItemRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        ExternalIdentificationItemRef::AnnotationTextCharacter(i) => {
            if i.0 >= model.annotation_text_character_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_CHARACTER",
                });
            }
        }
        ExternalIdentificationItemRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        ExternalIdentificationItemRef::AnnotationToAnnotationLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE",
            });
        }
        ExternalIdentificationItemRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
        ExternalIdentificationItemRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        ExternalIdentificationItemRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        ExternalIdentificationItemRef::AppliedDateAndTimeAssignment(i) => {
            if i.0 >= model.applied_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        ExternalIdentificationItemRef::AppliedExternalIdentificationAssignment(i) => {
            if i.0
                >= model
                    .applied_external_identification_assignment_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT",
                });
            }
        }
        ExternalIdentificationItemRef::Approval(i) => {
            if i.0 >= model.approval_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "APPROVAL" });
            }
        }
        ExternalIdentificationItemRef::ApprovalPersonOrganization(i) => {
            if i.0 >= model.approval_person_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_PERSON_ORGANIZATION",
                });
            }
        }
        ExternalIdentificationItemRef::ApprovalStatus(i) => {
            if i.0 >= model.approval_status_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_STATUS",
                });
            }
        }
        ExternalIdentificationItemRef::AreaUnit(i) => {
            if i.0 >= model.area_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AREA_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        ExternalIdentificationItemRef::AuxiliaryLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "AUXILIARY_LEADER_LINE",
            });
        }
        ExternalIdentificationItemRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
        ExternalIdentificationItemRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        ExternalIdentificationItemRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
        ExternalIdentificationItemRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        ExternalIdentificationItemRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        ExternalIdentificationItemRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        ExternalIdentificationItemRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::BrepWithVoids(i) => {
            if i.0 >= model.brep_with_voids_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BREP_WITH_VOIDS",
                });
            }
        }
        ExternalIdentificationItemRef::CameraImage(i) => {
            if i.0 >= model.camera_image_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE",
                });
            }
        }
        ExternalIdentificationItemRef::CameraImage3dWithScale(i) => {
            if i.0 >= model.camera_image3d_with_scale_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE_3D_WITH_SCALE",
                });
            }
        }
        ExternalIdentificationItemRef::CameraModel(i) => {
            if i.0 >= model.camera_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL",
                });
            }
        }
        ExternalIdentificationItemRef::CameraModelD3(i) => {
            if i.0 >= model.camera_model_d3_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3",
                });
            }
        }
        ExternalIdentificationItemRef::CameraModelD3MultiClipping(i) => {
            if i.0 >= model.camera_model_d3_multi_clipping_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                });
            }
        }
        ExternalIdentificationItemRef::CameraModelD3WithHlhsr(i) => {
            if i.0 >= model.camera_model_d3_with_hlhsr_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_WITH_HLHSR",
                });
            }
        }
        ExternalIdentificationItemRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        ExternalIdentificationItemRef::CcDesignDateAndTimeAssignment(i) => {
            if i.0 >= model.cc_design_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        ExternalIdentificationItemRef::Certification(i) => {
            if i.0 >= model.certification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CERTIFICATION",
                });
            }
        }
        ExternalIdentificationItemRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        ExternalIdentificationItemRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        ExternalIdentificationItemRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        ExternalIdentificationItemRef::ComplexTriangulatedSurfaceSet(i) => {
            if i.0 >= model.complex_triangulated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_SURFACE_SET",
                });
            }
        }
        ExternalIdentificationItemRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        ExternalIdentificationItemRef::CompoundRepresentationItem(i) => {
            if i.0 >= model.compound_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOUND_REPRESENTATION_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::ConfigurationEffectivity(i) => {
            if i.0 >= model.configuration_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_EFFECTIVITY",
                });
            }
        }
        ExternalIdentificationItemRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        ExternalIdentificationItemRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        ExternalIdentificationItemRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::ContextDependentOverRidingStyledItem(i) => {
            if i.0
                >= model
                    .context_dependent_over_riding_styled_item_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::ContextDependentUnit(i) => {
            if i.0 >= model.context_dependent_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::Contract(i) => {
            if i.0 >= model.contract_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONTRACT" });
            }
        }
        ExternalIdentificationItemRef::ConversionBasedUnit(i) => {
            if i.0 >= model.conversion_based_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONVERSION_BASED_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
        ExternalIdentificationItemRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        ExternalIdentificationItemRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::DateAndTimeAssignment(i) => {
            if i.0 >= model.date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        ExternalIdentificationItemRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        ExternalIdentificationItemRef::DefinedSymbol(i) => {
            if i.0 >= model.defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_SYMBOL",
                });
            }
        }
        ExternalIdentificationItemRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::DerivedUnit(i) => {
            if i.0 >= model.derived_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::DescriptiveRepresentationItem(i) => {
            if i.0 >= model.descriptive_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESCRIPTIVE_REPRESENTATION_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::DesignContext(i) => {
            if i.0 >= model.design_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESIGN_CONTEXT",
                });
            }
        }
        ExternalIdentificationItemRef::Direction(i) => {
            if i.0 >= model.direction_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTION",
                });
            }
        }
        ExternalIdentificationItemRef::DocumentFile(i) => {
            if i.0 >= model.document_file_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_FILE",
                });
            }
        }
        ExternalIdentificationItemRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        ExternalIdentificationItemRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        ExternalIdentificationItemRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        ExternalIdentificationItemRef::Edge(i) => {
            if i.0 >= model.edge_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "EDGE" });
            }
        }
        ExternalIdentificationItemRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        ExternalIdentificationItemRef::Effectivity(i) => {
            if i.0 >= model.effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EFFECTIVITY",
                });
            }
        }
        ExternalIdentificationItemRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        ExternalIdentificationItemRef::ExternalSource(i) => {
            if i.0 >= model.external_source_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNAL_SOURCE",
                });
            }
        }
        ExternalIdentificationItemRef::ExternallyDefinedHatchStyle(i) => {
            if i.0 >= model.externally_defined_hatch_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_HATCH_STYLE",
                });
            }
        }
        ExternalIdentificationItemRef::ExternallyDefinedTileStyle(i) => {
            if i.0 >= model.externally_defined_tile_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE_STYLE",
                });
            }
        }
        ExternalIdentificationItemRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        ExternalIdentificationItemRef::FaceBound(i) => {
            if i.0 >= model.face_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_BOUND",
                });
            }
        }
        ExternalIdentificationItemRef::FaceOuterBound(i) => {
            if i.0 >= model.face_outer_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_OUTER_BOUND",
                });
            }
        }
        ExternalIdentificationItemRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::FillAreaStyleHatching(i) => {
            if i.0 >= model.fill_area_style_hatching_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_HATCHING",
                });
            }
        }
        ExternalIdentificationItemRef::FillAreaStyleTileColouredRegion(i) => {
            if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION",
                });
            }
        }
        ExternalIdentificationItemRef::FillAreaStyleTileCurveWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_curve_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE",
                });
            }
        }
        ExternalIdentificationItemRef::FillAreaStyleTileSymbolWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_symbol_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
                });
            }
        }
        ExternalIdentificationItemRef::FillAreaStyleTiles(i) => {
            if i.0 >= model.fill_area_style_tiles_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILES",
                });
            }
        }
        ExternalIdentificationItemRef::GeneralProperty(i) => {
            if i.0 >= model.general_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_PROPERTY",
                });
            }
        }
        ExternalIdentificationItemRef::GenericProductDefinitionReference(i) => {
            if i.0 >= model.generic_product_definition_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERIC_PRODUCT_DEFINITION_REFERENCE",
                });
            }
        }
        ExternalIdentificationItemRef::GeometricCurveSet(i) => {
            if i.0 >= model.geometric_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_CURVE_SET",
                });
            }
        }
        ExternalIdentificationItemRef::GeometricRepresentationItem(i) => {
            if i.0 >= model.geometric_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::GeometricSet(i) => {
            if i.0 >= model.geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_SET",
                });
            }
        }
        ExternalIdentificationItemRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::Group(i) => {
            if i.0 >= model.group_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "GROUP" });
            }
        }
        ExternalIdentificationItemRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        ExternalIdentificationItemRef::IntegerRepresentationItem(i) => {
            if i.0 >= model.integer_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTEGER_REPRESENTATION_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        ExternalIdentificationItemRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        ExternalIdentificationItemRef::LengthUnit(i) => {
            if i.0 >= model.length_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LENGTH_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        ExternalIdentificationItemRef::Loop(i) => {
            if i.0 >= model.loop_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LOOP" });
            }
        }
        ExternalIdentificationItemRef::ManifoldSolidBrep(i) => {
            if i.0 >= model.manifold_solid_brep_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SOLID_BREP",
                });
            }
        }
        ExternalIdentificationItemRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::MappedItem(i) => {
            if i.0 >= model.mapped_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAPPED_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::MassUnit(i) => {
            if i.0 >= model.mass_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MASS_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::MeasureRepresentationItem(i) => {
            if i.0 >= model.measure_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_REPRESENTATION_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::MechanicalDesignPresentationRepresentationWithDraughting(
            i,
        ) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        ExternalIdentificationItemRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::NamedUnit(i) => {
            if i.0 >= model.named_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NAMED_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        ExternalIdentificationItemRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::OneDirectionRepeatFactor(i) => {
            if i.0 >= model.one_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ONE_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        ExternalIdentificationItemRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        ExternalIdentificationItemRef::Organization(i) => {
            if i.0 >= model.organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION",
                });
            }
        }
        ExternalIdentificationItemRef::OrganizationalAddress(i) => {
            if i.0 >= model.organizational_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_ADDRESS",
                });
            }
        }
        ExternalIdentificationItemRef::OrganizationalProject(i) => {
            if i.0 >= model.organizational_project_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT",
                });
            }
        }
        ExternalIdentificationItemRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        ExternalIdentificationItemRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        ExternalIdentificationItemRef::OverRidingStyledItem(i) => {
            if i.0 >= model.over_riding_styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::Path(i) => {
            if i.0 >= model.path_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PATH" });
            }
        }
        ExternalIdentificationItemRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        ExternalIdentificationItemRef::Person(i) => {
            if i.0 >= model.person_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PERSON" });
            }
        }
        ExternalIdentificationItemRef::PersonAndOrganization(i) => {
            if i.0 >= model.person_and_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION",
                });
            }
        }
        ExternalIdentificationItemRef::PersonAndOrganizationAddress(i) => {
            if i.0 >= model.person_and_organization_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION_ADDRESS",
                });
            }
        }
        ExternalIdentificationItemRef::PersonalAddress(i) => {
            if i.0 >= model.personal_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSONAL_ADDRESS",
                });
            }
        }
        ExternalIdentificationItemRef::Placement(i) => {
            if i.0 >= model.placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACEMENT",
                });
            }
        }
        ExternalIdentificationItemRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        ExternalIdentificationItemRef::PlanarExtent(i) => {
            if i.0 >= model.planar_extent_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_EXTENT",
                });
            }
        }
        ExternalIdentificationItemRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        ExternalIdentificationItemRef::PlaneAngleUnit(i) => {
            if i.0 >= model.plane_angle_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANE_ANGLE_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        ExternalIdentificationItemRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        ExternalIdentificationItemRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        ExternalIdentificationItemRef::PrecisionQualifier(i) => {
            if i.0 >= model.precision_qualifier_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRECISION_QUALIFIER",
                });
            }
        }
        ExternalIdentificationItemRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        ExternalIdentificationItemRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        ExternalIdentificationItemRef::Product(i) => {
            if i.0 >= model.product_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PRODUCT" });
            }
        }
        ExternalIdentificationItemRef::ProductConcept(i) => {
            if i.0 >= model.product_concept_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT",
                });
            }
        }
        ExternalIdentificationItemRef::ProductConceptContext(i) => {
            if i.0 >= model.product_concept_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_CONTEXT",
                });
            }
        }
        ExternalIdentificationItemRef::ProductConceptFeatureCategory(i) => {
            if i.0 >= model.product_concept_feature_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE_CATEGORY",
                });
            }
        }
        ExternalIdentificationItemRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        ExternalIdentificationItemRef::ProductDefinitionContext(i) => {
            if i.0 >= model.product_definition_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_CONTEXT",
                });
            }
        }
        ExternalIdentificationItemRef::ProductDefinitionEffectivity(i) => {
            if i.0 >= model.product_definition_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_EFFECTIVITY",
                });
            }
        }
        ExternalIdentificationItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        ExternalIdentificationItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        ExternalIdentificationItemRef::ProductDefinitionOccurrence(i) => {
            if i.0 >= model.product_definition_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_OCCURRENCE",
                });
            }
        }
        ExternalIdentificationItemRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        ExternalIdentificationItemRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        ExternalIdentificationItemRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        ExternalIdentificationItemRef::QualifiedRepresentationItem(i) => {
            if i.0 >= model.qualified_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUALIFIED_REPRESENTATION_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::RatioUnit(i) => {
            if i.0 >= model.ratio_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIO_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::RealRepresentationItem(i) => {
            if i.0 >= model.real_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REAL_REPRESENTATION_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::RepositionedTessellatedItem(i) => {
            if i.0 >= model.repositioned_tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPOSITIONED_TESSELLATED_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::RepresentationItem(i) => {
            if i.0 >= model.representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::SecurityClassification(i) => {
            if i.0 >= model.security_classification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION",
                });
            }
        }
        ExternalIdentificationItemRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        ExternalIdentificationItemRef::ShellBasedSurfaceModel(i) => {
            if i.0 >= model.shell_based_surface_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHELL_BASED_SURFACE_MODEL",
                });
            }
        }
        ExternalIdentificationItemRef::SiUnit(i) => {
            if i.0 >= model.si_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SI_UNIT" });
            }
        }
        ExternalIdentificationItemRef::SolidAngleUnit(i) => {
            if i.0 >= model.solid_angle_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_ANGLE_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::SolidModel(i) => {
            if i.0 >= model.solid_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_MODEL",
                });
            }
        }
        ExternalIdentificationItemRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::StateObserved(i) => {
            if i.0 >= model.state_observed_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_OBSERVED",
                });
            }
        }
        ExternalIdentificationItemRef::StateType(i) => {
            if i.0 >= model.state_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_TYPE",
                });
            }
        }
        ExternalIdentificationItemRef::StyledItem(i) => {
            if i.0 >= model.styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STYLED_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        ExternalIdentificationItemRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        ExternalIdentificationItemRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        ExternalIdentificationItemRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::SymbolTarget(i) => {
            if i.0 >= model.symbol_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_TARGET",
                });
            }
        }
        ExternalIdentificationItemRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        ExternalIdentificationItemRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        ExternalIdentificationItemRef::TessellatedCurveSet(i) => {
            if i.0 >= model.tessellated_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_CURVE_SET",
                });
            }
        }
        ExternalIdentificationItemRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        ExternalIdentificationItemRef::TessellatedGeometricSet(i) => {
            if i.0 >= model.tessellated_geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                });
            }
        }
        ExternalIdentificationItemRef::TessellatedItem(i) => {
            if i.0 >= model.tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        ExternalIdentificationItemRef::TessellatedShell(i) => {
            if i.0 >= model.tessellated_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHELL",
                });
            }
        }
        ExternalIdentificationItemRef::TessellatedSolid(i) => {
            if i.0 >= model.tessellated_solid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SOLID",
                });
            }
        }
        ExternalIdentificationItemRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::TessellatedSurfaceSet(i) => {
            if i.0 >= model.tessellated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SURFACE_SET",
                });
            }
        }
        ExternalIdentificationItemRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        ExternalIdentificationItemRef::TimeUnit(i) => {
            if i.0 >= model.time_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TIME_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::TopologicalRepresentationItem(i) => {
            if i.0 >= model.topological_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOPOLOGICAL_REPRESENTATION_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        ExternalIdentificationItemRef::TypeQualifier(i) => {
            if i.0 >= model.type_qualifier_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TYPE_QUALIFIER",
                });
            }
        }
        ExternalIdentificationItemRef::UncertaintyQualifier(i) => {
            if i.0 >= model.uncertainty_qualifier_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNCERTAINTY_QUALIFIER",
                });
            }
        }
        ExternalIdentificationItemRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        ExternalIdentificationItemRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        ExternalIdentificationItemRef::ValueRepresentationItem(i) => {
            if i.0 >= model.value_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VALUE_REPRESENTATION_ITEM",
                });
            }
        }
        ExternalIdentificationItemRef::Vector(i) => {
            if i.0 >= model.vector_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VECTOR" });
            }
        }
        ExternalIdentificationItemRef::VersionedActionRequest(i) => {
            if i.0 >= model.versioned_action_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERSIONED_ACTION_REQUEST",
                });
            }
        }
        ExternalIdentificationItemRef::Vertex(i) => {
            if i.0 >= model.vertex_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VERTEX" });
            }
        }
        ExternalIdentificationItemRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
        ExternalIdentificationItemRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        ExternalIdentificationItemRef::VertexShell(i) => {
            if i.0 >= model.vertex_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_SHELL",
                });
            }
        }
        ExternalIdentificationItemRef::VolumeUnit(i) => {
            if i.0 >= model.volume_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VOLUME_UNIT",
                });
            }
        }
        ExternalIdentificationItemRef::WireShell(i) => {
            if i.0 >= model.wire_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "WIRE_SHELL",
                });
            }
        }
        ExternalIdentificationItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_external_source_ref(model: &StepModel, r: &ExternalSourceRef) -> Result<(), AuthorError> {
    match r {
        ExternalSourceRef::ExternalSource(i) => {
            if i.0 >= model.external_source_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNAL_SOURCE",
                });
            }
        }
        ExternalSourceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_face_ref(model: &StepModel, r: &FaceRef) -> Result<(), AuthorError> {
    match r {
        FaceRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        FaceRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        FaceRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        FaceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_face_bound_ref(model: &StepModel, r: &FaceBoundRef) -> Result<(), AuthorError> {
    match r {
        FaceBoundRef::FaceBound(i) => {
            if i.0 >= model.face_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_BOUND",
                });
            }
        }
        FaceBoundRef::FaceOuterBound(i) => {
            if i.0 >= model.face_outer_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_OUTER_BOUND",
                });
            }
        }
        FaceBoundRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_face_or_surface_ref(model: &StepModel, r: &FaceOrSurfaceRef) -> Result<(), AuthorError> {
    match r {
        FaceOrSurfaceRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        FaceOrSurfaceRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        FaceOrSurfaceRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        FaceOrSurfaceRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        FaceOrSurfaceRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        FaceOrSurfaceRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        FaceOrSurfaceRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        FaceOrSurfaceRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        FaceOrSurfaceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_face_surface_ref(model: &StepModel, r: &FaceSurfaceRef) -> Result<(), AuthorError> {
    match r {
        FaceSurfaceRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        FaceSurfaceRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        FaceSurfaceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_fill_area_style_ref(model: &StepModel, r: &FillAreaStyleRef) -> Result<(), AuthorError> {
    match r {
        FillAreaStyleRef::FillAreaStyle(i) => {
            if i.0 >= model.fill_area_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE",
                });
            }
        }
        FillAreaStyleRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_fill_area_style_tile_shape_select_ref(
    model: &StepModel,
    r: &FillAreaStyleTileShapeSelectRef,
) -> Result<(), AuthorError> {
    match r {
        FillAreaStyleTileShapeSelectRef::ExternallyDefinedTile(i) => {
            if i.0 >= model.externally_defined_tile_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE",
                });
            }
        }
        FillAreaStyleTileShapeSelectRef::FillAreaStyleTileColouredRegion(i) => {
            if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION",
                });
            }
        }
        FillAreaStyleTileShapeSelectRef::FillAreaStyleTileCurveWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_curve_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE",
                });
            }
        }
        FillAreaStyleTileShapeSelectRef::FillAreaStyleTileSymbolWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_symbol_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
                });
            }
        }
        FillAreaStyleTileShapeSelectRef::PreDefinedTile(i) => {
            if i.0 >= model.pre_defined_tile_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_TILE",
                });
            }
        }
        FillAreaStyleTileShapeSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_fill_style_select_ref(
    model: &StepModel,
    r: &FillStyleSelectRef,
) -> Result<(), AuthorError> {
    match r {
        FillStyleSelectRef::ExternallyDefinedHatchStyle(i) => {
            if i.0 >= model.externally_defined_hatch_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_HATCH_STYLE",
                });
            }
        }
        FillStyleSelectRef::ExternallyDefinedTileStyle(i) => {
            if i.0 >= model.externally_defined_tile_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE_STYLE",
                });
            }
        }
        FillStyleSelectRef::FillAreaStyleColour(i) => {
            if i.0 >= model.fill_area_style_colour_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_COLOUR",
                });
            }
        }
        FillStyleSelectRef::FillAreaStyleHatching(i) => {
            if i.0 >= model.fill_area_style_hatching_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_HATCHING",
                });
            }
        }
        FillStyleSelectRef::FillAreaStyleTiles(i) => {
            if i.0 >= model.fill_area_style_tiles_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILES",
                });
            }
        }
        FillStyleSelectRef::TextureStyleSpecification(i) => {
            if i.0 >= model.texture_style_specification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXTURE_STYLE_SPECIFICATION",
                });
            }
        }
        FillStyleSelectRef::TextureStyleTessellationSpecification(i) => {
            if i.0
                >= model
                    .texture_style_tessellation_specification_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXTURE_STYLE_TESSELLATION_SPECIFICATION",
                });
            }
        }
        FillStyleSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_font_select_ref(model: &StepModel, r: &FontSelectRef) -> Result<(), AuthorError> {
    match r {
        FontSelectRef::DraughtingPreDefinedTextFont(i) => {
            if i.0 >= model.draughting_pre_defined_text_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_PRE_DEFINED_TEXT_FONT",
                });
            }
        }
        FontSelectRef::ExternallyDefinedTextFont(i) => {
            if i.0 >= model.externally_defined_text_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TEXT_FONT",
                });
            }
        }
        FontSelectRef::PreDefinedTextFont(i) => {
            if i.0 >= model.pre_defined_text_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_TEXT_FONT",
                });
            }
        }
        FontSelectRef::TextFont(i) => {
            if i.0 >= model.text_font_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_FONT",
                });
            }
        }
        FontSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_general_property_ref(
    model: &StepModel,
    r: &GeneralPropertyRef,
) -> Result<(), AuthorError> {
    match r {
        GeneralPropertyRef::GeneralProperty(i) => {
            if i.0 >= model.general_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_PROPERTY",
                });
            }
        }
        GeneralPropertyRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_geometric_item_specific_usage_select_ref(
    model: &StepModel,
    r: &GeometricItemSpecificUsageSelectRef,
) -> Result<(), AuthorError> {
    match r {
        GeometricItemSpecificUsageSelectRef::AllAroundShapeAspect(i) => {
            if i.0 >= model.all_around_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ALL_AROUND_SHAPE_ASPECT",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::CentreOfSymmetry(i) => {
            if i.0 >= model.centre_of_symmetry_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CENTRE_OF_SYMMETRY",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::CompositeGroupShapeAspect(i) => {
            if i.0 >= model.composite_group_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_GROUP_SHAPE_ASPECT",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::CompositeShapeAspect(i) => {
            if i.0 >= model.composite_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_SHAPE_ASPECT",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::ContinuousShapeAspect(i) => {
            if i.0 >= model.continuous_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTINUOUS_SHAPE_ASPECT",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        GeometricItemSpecificUsageSelectRef::DatumFeature(i) => {
            if i.0 >= model.datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_FEATURE",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::DatumTarget(i) => {
            if i.0 >= model.datum_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_TARGET",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::DefaultModelGeometricView(i) => {
            if i.0 >= model.default_model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFAULT_MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::DerivedShapeAspect(i) => {
            if i.0 >= model.derived_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_SHAPE_ASPECT",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::FeatureForDatumTargetRelationship(i) => {
            if i.0
                >= model
                    .feature_for_datum_target_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FEATURE_FOR_DATUM_TARGET_RELATIONSHIP",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::GeneralDatumReference(i) => {
            if i.0 >= model.general_datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_DATUM_REFERENCE",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::PlacedDatumTargetFeature(i) => {
            if i.0 >= model.placed_datum_target_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACED_DATUM_TARGET_FEATURE",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::ShapeAspect(i) => {
            if i.0 >= model.shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::ShapeAspectAssociativity(i) => {
            if i.0 >= model.shape_aspect_associativity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_ASSOCIATIVITY",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::ShapeAspectDerivingRelationship(i) => {
            if i.0 >= model.shape_aspect_deriving_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_DERIVING_RELATIONSHIP",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::ShapeAspectRelationship(i) => {
            if i.0 >= model.shape_aspect_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_RELATIONSHIP",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::ToleranceZone(i) => {
            if i.0 >= model.tolerance_zone_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::ToleranceZoneWithDatum(i) => {
            if i.0 >= model.tolerance_zone_with_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                });
            }
        }
        GeometricItemSpecificUsageSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_geometric_model_item_ref(
    model: &StepModel,
    r: &GeometricModelItemRef,
) -> Result<(), AuthorError> {
    match r {
        GeometricModelItemRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        GeometricModelItemRef::AnnotationPlaceholderLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE",
            });
        }
        GeometricModelItemRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        GeometricModelItemRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        GeometricModelItemRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        GeometricModelItemRef::AnnotationToAnnotationLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE",
            });
        }
        GeometricModelItemRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
        GeometricModelItemRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        GeometricModelItemRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        GeometricModelItemRef::AuxiliaryLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "AUXILIARY_LEADER_LINE",
            });
        }
        GeometricModelItemRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
        GeometricModelItemRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        GeometricModelItemRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
        GeometricModelItemRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        GeometricModelItemRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        GeometricModelItemRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        GeometricModelItemRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        GeometricModelItemRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        GeometricModelItemRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        GeometricModelItemRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        GeometricModelItemRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        GeometricModelItemRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        GeometricModelItemRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        GeometricModelItemRef::BrepWithVoids(i) => {
            if i.0 >= model.brep_with_voids_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BREP_WITH_VOIDS",
                });
            }
        }
        GeometricModelItemRef::CameraModel(i) => {
            if i.0 >= model.camera_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL",
                });
            }
        }
        GeometricModelItemRef::CameraModelD3(i) => {
            if i.0 >= model.camera_model_d3_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3",
                });
            }
        }
        GeometricModelItemRef::CameraModelD3MultiClipping(i) => {
            if i.0 >= model.camera_model_d3_multi_clipping_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                });
            }
        }
        GeometricModelItemRef::CameraModelD3WithHlhsr(i) => {
            if i.0 >= model.camera_model_d3_with_hlhsr_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_WITH_HLHSR",
                });
            }
        }
        GeometricModelItemRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        GeometricModelItemRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        GeometricModelItemRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        GeometricModelItemRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        GeometricModelItemRef::ComplexTriangulatedSurfaceSet(i) => {
            if i.0 >= model.complex_triangulated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_SURFACE_SET",
                });
            }
        }
        GeometricModelItemRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        GeometricModelItemRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        GeometricModelItemRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        GeometricModelItemRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        GeometricModelItemRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        GeometricModelItemRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
        GeometricModelItemRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        GeometricModelItemRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        GeometricModelItemRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        GeometricModelItemRef::DefinedSymbol(i) => {
            if i.0 >= model.defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_SYMBOL",
                });
            }
        }
        GeometricModelItemRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        GeometricModelItemRef::Direction(i) => {
            if i.0 >= model.direction_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTION",
                });
            }
        }
        GeometricModelItemRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        GeometricModelItemRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        GeometricModelItemRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        GeometricModelItemRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        GeometricModelItemRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        GeometricModelItemRef::ExternallyDefinedHatchStyle(i) => {
            if i.0 >= model.externally_defined_hatch_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_HATCH_STYLE",
                });
            }
        }
        GeometricModelItemRef::ExternallyDefinedTileStyle(i) => {
            if i.0 >= model.externally_defined_tile_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE_STYLE",
                });
            }
        }
        GeometricModelItemRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        GeometricModelItemRef::FillAreaStyleHatching(i) => {
            if i.0 >= model.fill_area_style_hatching_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_HATCHING",
                });
            }
        }
        GeometricModelItemRef::FillAreaStyleTileColouredRegion(i) => {
            if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION",
                });
            }
        }
        GeometricModelItemRef::FillAreaStyleTileCurveWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_curve_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE",
                });
            }
        }
        GeometricModelItemRef::FillAreaStyleTileSymbolWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_symbol_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
                });
            }
        }
        GeometricModelItemRef::FillAreaStyleTiles(i) => {
            if i.0 >= model.fill_area_style_tiles_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILES",
                });
            }
        }
        GeometricModelItemRef::GeometricCurveSet(i) => {
            if i.0 >= model.geometric_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_CURVE_SET",
                });
            }
        }
        GeometricModelItemRef::GeometricRepresentationItem(i) => {
            if i.0 >= model.geometric_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_ITEM",
                });
            }
        }
        GeometricModelItemRef::GeometricSet(i) => {
            if i.0 >= model.geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_SET",
                });
            }
        }
        GeometricModelItemRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        GeometricModelItemRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        GeometricModelItemRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        GeometricModelItemRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        GeometricModelItemRef::ManifoldSolidBrep(i) => {
            if i.0 >= model.manifold_solid_brep_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SOLID_BREP",
                });
            }
        }
        GeometricModelItemRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        GeometricModelItemRef::OneDirectionRepeatFactor(i) => {
            if i.0 >= model.one_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ONE_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        GeometricModelItemRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        GeometricModelItemRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        GeometricModelItemRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        GeometricModelItemRef::Placement(i) => {
            if i.0 >= model.placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACEMENT",
                });
            }
        }
        GeometricModelItemRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        GeometricModelItemRef::PlanarExtent(i) => {
            if i.0 >= model.planar_extent_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_EXTENT",
                });
            }
        }
        GeometricModelItemRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        GeometricModelItemRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        GeometricModelItemRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        GeometricModelItemRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        GeometricModelItemRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        GeometricModelItemRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        GeometricModelItemRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        GeometricModelItemRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        GeometricModelItemRef::RepositionedTessellatedItem(i) => {
            if i.0 >= model.repositioned_tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPOSITIONED_TESSELLATED_ITEM",
                });
            }
        }
        GeometricModelItemRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        GeometricModelItemRef::ShellBasedSurfaceModel(i) => {
            if i.0 >= model.shell_based_surface_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHELL_BASED_SURFACE_MODEL",
                });
            }
        }
        GeometricModelItemRef::SolidModel(i) => {
            if i.0 >= model.solid_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_MODEL",
                });
            }
        }
        GeometricModelItemRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        GeometricModelItemRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        GeometricModelItemRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        GeometricModelItemRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        GeometricModelItemRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        GeometricModelItemRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        GeometricModelItemRef::SymbolTarget(i) => {
            if i.0 >= model.symbol_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_TARGET",
                });
            }
        }
        GeometricModelItemRef::TessellatedCurveSet(i) => {
            if i.0 >= model.tessellated_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_CURVE_SET",
                });
            }
        }
        GeometricModelItemRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        GeometricModelItemRef::TessellatedGeometricSet(i) => {
            if i.0 >= model.tessellated_geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                });
            }
        }
        GeometricModelItemRef::TessellatedItem(i) => {
            if i.0 >= model.tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ITEM",
                });
            }
        }
        GeometricModelItemRef::TessellatedShell(i) => {
            if i.0 >= model.tessellated_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHELL",
                });
            }
        }
        GeometricModelItemRef::TessellatedSolid(i) => {
            if i.0 >= model.tessellated_solid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SOLID",
                });
            }
        }
        GeometricModelItemRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        GeometricModelItemRef::TessellatedSurfaceSet(i) => {
            if i.0 >= model.tessellated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SURFACE_SET",
                });
            }
        }
        GeometricModelItemRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        GeometricModelItemRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        GeometricModelItemRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        GeometricModelItemRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        GeometricModelItemRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        GeometricModelItemRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        GeometricModelItemRef::Vector(i) => {
            if i.0 >= model.vector_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VECTOR" });
            }
        }
        GeometricModelItemRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        GeometricModelItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_geometric_set_select_ref(
    model: &StepModel,
    r: &GeometricSetSelectRef,
) -> Result<(), AuthorError> {
    match r {
        GeometricSetSelectRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        GeometricSetSelectRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        GeometricSetSelectRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        GeometricSetSelectRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
        GeometricSetSelectRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        GeometricSetSelectRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
        GeometricSetSelectRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        GeometricSetSelectRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        GeometricSetSelectRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        GeometricSetSelectRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        GeometricSetSelectRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        GeometricSetSelectRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        GeometricSetSelectRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        GeometricSetSelectRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        GeometricSetSelectRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        GeometricSetSelectRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        GeometricSetSelectRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        GeometricSetSelectRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        GeometricSetSelectRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        GeometricSetSelectRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        GeometricSetSelectRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        GeometricSetSelectRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        GeometricSetSelectRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        GeometricSetSelectRef::Placement(i) => {
            if i.0 >= model.placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACEMENT",
                });
            }
        }
        GeometricSetSelectRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        GeometricSetSelectRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        GeometricSetSelectRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        GeometricSetSelectRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        GeometricSetSelectRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        GeometricSetSelectRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        GeometricSetSelectRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        GeometricSetSelectRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        GeometricSetSelectRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        GeometricSetSelectRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        GeometricSetSelectRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        GeometricSetSelectRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        GeometricSetSelectRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        GeometricSetSelectRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        GeometricSetSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_geometric_tolerance_ref(
    model: &StepModel,
    r: &GeometricToleranceRef,
) -> Result<(), AuthorError> {
    match r {
        GeometricToleranceRef::AngularityTolerance(i) => {
            if i.0 >= model.angularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULARITY_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::CircularRunoutTolerance(i) => {
            if i.0 >= model.circular_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CIRCULAR_RUNOUT_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::CoaxialityTolerance(i) => {
            if i.0 >= model.coaxiality_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COAXIALITY_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::ConcentricityTolerance(i) => {
            if i.0 >= model.concentricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONCENTRICITY_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::CylindricityTolerance(i) => {
            if i.0 >= model.cylindricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICITY_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::FlatnessTolerance(i) => {
            if i.0 >= model.flatness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FLATNESS_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::GeometricTolerance(i) => {
            if i.0 >= model.geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::GeometricToleranceWithDatumReference(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_datum_reference_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
                });
            }
        }
        GeometricToleranceRef::GeometricToleranceWithDefinedAreaUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_area_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT",
                });
            }
        }
        GeometricToleranceRef::GeometricToleranceWithDefinedUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT",
                });
            }
        }
        GeometricToleranceRef::GeometricToleranceWithMaximumTolerance(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_maximum_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::GeometricToleranceWithModifiers(i) => {
            if i.0 >= model.geometric_tolerance_with_modifiers_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
                });
            }
        }
        GeometricToleranceRef::LineProfileTolerance(i) => {
            if i.0 >= model.line_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LINE_PROFILE_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::ModifiedGeometricTolerance(i) => {
            if i.0 >= model.modified_geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MODIFIED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::ParallelismTolerance(i) => {
            if i.0 >= model.parallelism_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PARALLELISM_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::PerpendicularityTolerance(i) => {
            if i.0 >= model.perpendicularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERPENDICULARITY_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::PositionTolerance(i) => {
            if i.0 >= model.position_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POSITION_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::RoundnessTolerance(i) => {
            if i.0 >= model.roundness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ROUNDNESS_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::StraightnessTolerance(i) => {
            if i.0 >= model.straightness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STRAIGHTNESS_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::SurfaceProfileTolerance(i) => {
            if i.0 >= model.surface_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_PROFILE_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::SymmetryTolerance(i) => {
            if i.0 >= model.symmetry_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMMETRY_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::TotalRunoutTolerance(i) => {
            if i.0 >= model.total_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOTAL_RUNOUT_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::UnequallyDisposedGeometricTolerance(i) => {
            if i.0
                >= model
                    .unequally_disposed_geometric_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        GeometricToleranceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_geometric_tolerance_target_ref(
    model: &StepModel,
    r: &GeometricToleranceTargetRef,
) -> Result<(), AuthorError> {
    match r {
        GeometricToleranceTargetRef::AllAroundShapeAspect(i) => {
            if i.0 >= model.all_around_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ALL_AROUND_SHAPE_ASPECT",
                });
            }
        }
        GeometricToleranceTargetRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        GeometricToleranceTargetRef::AngularSize(i) => {
            if i.0 >= model.angular_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_SIZE",
                });
            }
        }
        GeometricToleranceTargetRef::CentreOfSymmetry(i) => {
            if i.0 >= model.centre_of_symmetry_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CENTRE_OF_SYMMETRY",
                });
            }
        }
        GeometricToleranceTargetRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        GeometricToleranceTargetRef::CompositeGroupShapeAspect(i) => {
            if i.0 >= model.composite_group_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_GROUP_SHAPE_ASPECT",
                });
            }
        }
        GeometricToleranceTargetRef::CompositeShapeAspect(i) => {
            if i.0 >= model.composite_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_SHAPE_ASPECT",
                });
            }
        }
        GeometricToleranceTargetRef::ContinuousShapeAspect(i) => {
            if i.0 >= model.continuous_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTINUOUS_SHAPE_ASPECT",
                });
            }
        }
        GeometricToleranceTargetRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        GeometricToleranceTargetRef::DatumFeature(i) => {
            if i.0 >= model.datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_FEATURE",
                });
            }
        }
        GeometricToleranceTargetRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
        GeometricToleranceTargetRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        GeometricToleranceTargetRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        GeometricToleranceTargetRef::DatumTarget(i) => {
            if i.0 >= model.datum_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_TARGET",
                });
            }
        }
        GeometricToleranceTargetRef::DefaultModelGeometricView(i) => {
            if i.0 >= model.default_model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFAULT_MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        GeometricToleranceTargetRef::DerivedShapeAspect(i) => {
            if i.0 >= model.derived_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_SHAPE_ASPECT",
                });
            }
        }
        GeometricToleranceTargetRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        GeometricToleranceTargetRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        GeometricToleranceTargetRef::DimensionalSize(i) => {
            if i.0 >= model.dimensional_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE",
                });
            }
        }
        GeometricToleranceTargetRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        GeometricToleranceTargetRef::DimensionalSizeWithPath(i) => {
            if i.0 >= model.dimensional_size_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_PATH",
                });
            }
        }
        GeometricToleranceTargetRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        GeometricToleranceTargetRef::GeneralDatumReference(i) => {
            if i.0 >= model.general_datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_DATUM_REFERENCE",
                });
            }
        }
        GeometricToleranceTargetRef::PlacedDatumTargetFeature(i) => {
            if i.0 >= model.placed_datum_target_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACED_DATUM_TARGET_FEATURE",
                });
            }
        }
        GeometricToleranceTargetRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        GeometricToleranceTargetRef::ShapeAspect(i) => {
            if i.0 >= model.shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT",
                });
            }
        }
        GeometricToleranceTargetRef::ToleranceZone(i) => {
            if i.0 >= model.tolerance_zone_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE",
                });
            }
        }
        GeometricToleranceTargetRef::ToleranceZoneWithDatum(i) => {
            if i.0 >= model.tolerance_zone_with_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                });
            }
        }
        GeometricToleranceTargetRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_group_ref(model: &StepModel, r: &GroupRef) -> Result<(), AuthorError> {
    match r {
        GroupRef::Group(i) => {
            if i.0 >= model.group_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "GROUP" });
            }
        }
        GroupRef::ProductConceptFeatureCategory(i) => {
            if i.0 >= model.product_concept_feature_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE_CATEGORY",
                });
            }
        }
        GroupRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_groupable_item_ref(model: &StepModel, r: &GroupableItemRef) -> Result<(), AuthorError> {
    match r {
        GroupableItemRef::ActionMethod(i) => {
            if i.0 >= model.action_method_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD",
                });
            }
        }
        GroupableItemRef::Address(i) => {
            if i.0 >= model.address_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ADDRESS" });
            }
        }
        GroupableItemRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        GroupableItemRef::AllAroundShapeAspect(i) => {
            if i.0 >= model.all_around_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ALL_AROUND_SHAPE_ASPECT",
                });
            }
        }
        GroupableItemRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        GroupableItemRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        GroupableItemRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        GroupableItemRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        GroupableItemRef::AnnotationPlaceholderLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE",
            });
        }
        GroupableItemRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        GroupableItemRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        GroupableItemRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        GroupableItemRef::AnnotationSymbol(i) => {
            if i.0 >= model.annotation_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL",
                });
            }
        }
        GroupableItemRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        GroupableItemRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        GroupableItemRef::AnnotationTextCharacter(i) => {
            if i.0 >= model.annotation_text_character_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_CHARACTER",
                });
            }
        }
        GroupableItemRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        GroupableItemRef::AnnotationToAnnotationLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE",
            });
        }
        GroupableItemRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
        GroupableItemRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        GroupableItemRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        GroupableItemRef::AppliedDateAndTimeAssignment(i) => {
            if i.0 >= model.applied_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        GroupableItemRef::AppliedGroupAssignment(i) => {
            if i.0 >= model.applied_group_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_GROUP_ASSIGNMENT",
                });
            }
        }
        GroupableItemRef::Approval(i) => {
            if i.0 >= model.approval_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "APPROVAL" });
            }
        }
        GroupableItemRef::ApprovalPersonOrganization(i) => {
            if i.0 >= model.approval_person_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_PERSON_ORGANIZATION",
                });
            }
        }
        GroupableItemRef::ApprovalStatus(i) => {
            if i.0 >= model.approval_status_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_STATUS",
                });
            }
        }
        GroupableItemRef::AreaUnit(i) => {
            if i.0 >= model.area_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AREA_UNIT",
                });
            }
        }
        GroupableItemRef::AscribableState(i) => {
            if i.0 >= model.ascribable_state_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASCRIBABLE_STATE",
                });
            }
        }
        GroupableItemRef::AscribableStateRelationship(i) => {
            if i.0 >= model.ascribable_state_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASCRIBABLE_STATE_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        GroupableItemRef::AuxiliaryLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "AUXILIARY_LEADER_LINE",
            });
        }
        GroupableItemRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
        GroupableItemRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        GroupableItemRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
        GroupableItemRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        GroupableItemRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        GroupableItemRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        GroupableItemRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        GroupableItemRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        GroupableItemRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        GroupableItemRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        GroupableItemRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        GroupableItemRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        GroupableItemRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        GroupableItemRef::BrepWithVoids(i) => {
            if i.0 >= model.brep_with_voids_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BREP_WITH_VOIDS",
                });
            }
        }
        GroupableItemRef::CalendarDate(i) => {
            if i.0 >= model.calendar_date_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CALENDAR_DATE",
                });
            }
        }
        GroupableItemRef::CameraImage(i) => {
            if i.0 >= model.camera_image_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE",
                });
            }
        }
        GroupableItemRef::CameraImage3dWithScale(i) => {
            if i.0 >= model.camera_image3d_with_scale_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE_3D_WITH_SCALE",
                });
            }
        }
        GroupableItemRef::CameraModel(i) => {
            if i.0 >= model.camera_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL",
                });
            }
        }
        GroupableItemRef::CameraModelD3(i) => {
            if i.0 >= model.camera_model_d3_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3",
                });
            }
        }
        GroupableItemRef::CameraModelD3MultiClipping(i) => {
            if i.0 >= model.camera_model_d3_multi_clipping_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                });
            }
        }
        GroupableItemRef::CameraModelD3WithHlhsr(i) => {
            if i.0 >= model.camera_model_d3_with_hlhsr_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_WITH_HLHSR",
                });
            }
        }
        GroupableItemRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        GroupableItemRef::CcDesignDateAndTimeAssignment(i) => {
            if i.0 >= model.cc_design_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        GroupableItemRef::CentreOfSymmetry(i) => {
            if i.0 >= model.centre_of_symmetry_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CENTRE_OF_SYMMETRY",
                });
            }
        }
        GroupableItemRef::Certification(i) => {
            if i.0 >= model.certification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CERTIFICATION",
                });
            }
        }
        GroupableItemRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        GroupableItemRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        GroupableItemRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        GroupableItemRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        GroupableItemRef::ComplexTriangulatedSurfaceSet(i) => {
            if i.0 >= model.complex_triangulated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_SURFACE_SET",
                });
            }
        }
        GroupableItemRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        GroupableItemRef::CompositeGroupShapeAspect(i) => {
            if i.0 >= model.composite_group_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_GROUP_SHAPE_ASPECT",
                });
            }
        }
        GroupableItemRef::CompositeShapeAspect(i) => {
            if i.0 >= model.composite_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_SHAPE_ASPECT",
                });
            }
        }
        GroupableItemRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        GroupableItemRef::CompoundRepresentationItem(i) => {
            if i.0 >= model.compound_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOUND_REPRESENTATION_ITEM",
                });
            }
        }
        GroupableItemRef::ConfigurationDesign(i) => {
            if i.0 >= model.configuration_design_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_DESIGN",
                });
            }
        }
        GroupableItemRef::ConfigurationEffectivity(i) => {
            if i.0 >= model.configuration_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_EFFECTIVITY",
                });
            }
        }
        GroupableItemRef::ConfigurationItem(i) => {
            if i.0 >= model.configuration_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_ITEM",
                });
            }
        }
        GroupableItemRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        GroupableItemRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        GroupableItemRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        GroupableItemRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::ConstructiveGeometryRepresentationRelationship(i) => {
            if i.0
                >= model
                    .constructive_geometry_representation_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::ContextDependentOverRidingStyledItem(i) => {
            if i.0
                >= model
                    .context_dependent_over_riding_styled_item_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        GroupableItemRef::ContextDependentShapeRepresentation(i) => {
            if i.0
                >= model
                    .context_dependent_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_SHAPE_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::ContextDependentUnit(i) => {
            if i.0 >= model.context_dependent_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_UNIT",
                });
            }
        }
        GroupableItemRef::ContinuousShapeAspect(i) => {
            if i.0 >= model.continuous_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTINUOUS_SHAPE_ASPECT",
                });
            }
        }
        GroupableItemRef::Contract(i) => {
            if i.0 >= model.contract_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONTRACT" });
            }
        }
        GroupableItemRef::ConversionBasedUnit(i) => {
            if i.0 >= model.conversion_based_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONVERSION_BASED_UNIT",
                });
            }
        }
        GroupableItemRef::CoordinatedUniversalTimeOffset(i) => {
            if i.0 >= model.coordinated_universal_time_offset_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATED_UNIVERSAL_TIME_OFFSET",
                });
            }
        }
        GroupableItemRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
        GroupableItemRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        GroupableItemRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        GroupableItemRef::DateAndTime(i) => {
            if i.0 >= model.date_and_time_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_AND_TIME",
                });
            }
        }
        GroupableItemRef::DateAndTimeAssignment(i) => {
            if i.0 >= model.date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        GroupableItemRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        GroupableItemRef::DatumFeature(i) => {
            if i.0 >= model.datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_FEATURE",
                });
            }
        }
        GroupableItemRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
        GroupableItemRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        GroupableItemRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        GroupableItemRef::DatumTarget(i) => {
            if i.0 >= model.datum_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_TARGET",
                });
            }
        }
        GroupableItemRef::DefaultModelGeometricView(i) => {
            if i.0 >= model.default_model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFAULT_MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        GroupableItemRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        GroupableItemRef::DefinedSymbol(i) => {
            if i.0 >= model.defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_SYMBOL",
                });
            }
        }
        GroupableItemRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::DefinitionalRepresentationRelationship(i) => {
            if i.0
                >= model
                    .definitional_representation_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::DefinitionalRepresentationRelationshipWithSameContext(i) => {
            if i.0
                >= model
                    .definitional_representation_relationship_with_same_context_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION_RELATIONSHIP_WITH_SAME_CONTEXT",
                });
            }
        }
        GroupableItemRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        GroupableItemRef::DerivedShapeAspect(i) => {
            if i.0 >= model.derived_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_SHAPE_ASPECT",
                });
            }
        }
        GroupableItemRef::DerivedUnit(i) => {
            if i.0 >= model.derived_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_UNIT",
                });
            }
        }
        GroupableItemRef::DerivedUnitElement(i) => {
            if i.0 >= model.derived_unit_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_UNIT_ELEMENT",
                });
            }
        }
        GroupableItemRef::DescriptiveRepresentationItem(i) => {
            if i.0 >= model.descriptive_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESCRIPTIVE_REPRESENTATION_ITEM",
                });
            }
        }
        GroupableItemRef::DesignContext(i) => {
            if i.0 >= model.design_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESIGN_CONTEXT",
                });
            }
        }
        GroupableItemRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        GroupableItemRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        GroupableItemRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        GroupableItemRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        GroupableItemRef::Direction(i) => {
            if i.0 >= model.direction_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTION",
                });
            }
        }
        GroupableItemRef::DocumentFile(i) => {
            if i.0 >= model.document_file_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_FILE",
                });
            }
        }
        GroupableItemRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        GroupableItemRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        GroupableItemRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        GroupableItemRef::Edge(i) => {
            if i.0 >= model.edge_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "EDGE" });
            }
        }
        GroupableItemRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        GroupableItemRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        GroupableItemRef::Effectivity(i) => {
            if i.0 >= model.effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EFFECTIVITY",
                });
            }
        }
        GroupableItemRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        GroupableItemRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        GroupableItemRef::ExternalSource(i) => {
            if i.0 >= model.external_source_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNAL_SOURCE",
                });
            }
        }
        GroupableItemRef::ExternallyDefinedHatchStyle(i) => {
            if i.0 >= model.externally_defined_hatch_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_HATCH_STYLE",
                });
            }
        }
        GroupableItemRef::ExternallyDefinedTileStyle(i) => {
            if i.0 >= model.externally_defined_tile_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE_STYLE",
                });
            }
        }
        GroupableItemRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        GroupableItemRef::FaceBound(i) => {
            if i.0 >= model.face_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_BOUND",
                });
            }
        }
        GroupableItemRef::FaceOuterBound(i) => {
            if i.0 >= model.face_outer_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_OUTER_BOUND",
                });
            }
        }
        GroupableItemRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        GroupableItemRef::FeatureForDatumTargetRelationship(i) => {
            if i.0
                >= model
                    .feature_for_datum_target_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FEATURE_FOR_DATUM_TARGET_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::FillAreaStyleHatching(i) => {
            if i.0 >= model.fill_area_style_hatching_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_HATCHING",
                });
            }
        }
        GroupableItemRef::FillAreaStyleTileColouredRegion(i) => {
            if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION",
                });
            }
        }
        GroupableItemRef::FillAreaStyleTileCurveWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_curve_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE",
                });
            }
        }
        GroupableItemRef::FillAreaStyleTileSymbolWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_symbol_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
                });
            }
        }
        GroupableItemRef::FillAreaStyleTiles(i) => {
            if i.0 >= model.fill_area_style_tiles_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILES",
                });
            }
        }
        GroupableItemRef::GeneralDatumReference(i) => {
            if i.0 >= model.general_datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_DATUM_REFERENCE",
                });
            }
        }
        GroupableItemRef::GeneralProperty(i) => {
            if i.0 >= model.general_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_PROPERTY",
                });
            }
        }
        GroupableItemRef::GeometricCurveSet(i) => {
            if i.0 >= model.geometric_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_CURVE_SET",
                });
            }
        }
        GroupableItemRef::GeometricItemSpecificUsage(i) => {
            if i.0 >= model.geometric_item_specific_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_ITEM_SPECIFIC_USAGE",
                });
            }
        }
        GroupableItemRef::GeometricRepresentationContext(i) => {
            if i.0 >= model.geometric_representation_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_CONTEXT",
                });
            }
        }
        GroupableItemRef::GeometricRepresentationItem(i) => {
            if i.0 >= model.geometric_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_ITEM",
                });
            }
        }
        GroupableItemRef::GeometricSet(i) => {
            if i.0 >= model.geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_SET",
                });
            }
        }
        GroupableItemRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::GlobalUncertaintyAssignedContext(i) => {
            if i.0 >= model.global_uncertainty_assigned_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT",
                });
            }
        }
        GroupableItemRef::GlobalUnitAssignedContext(i) => {
            if i.0 >= model.global_unit_assigned_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GLOBAL_UNIT_ASSIGNED_CONTEXT",
                });
            }
        }
        GroupableItemRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        GroupableItemRef::IntegerRepresentationItem(i) => {
            if i.0 >= model.integer_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTEGER_REPRESENTATION_ITEM",
                });
            }
        }
        GroupableItemRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        GroupableItemRef::ItemDefinedTransformation(i) => {
            if i.0 >= model.item_defined_transformation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ITEM_DEFINED_TRANSFORMATION",
                });
            }
        }
        GroupableItemRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        GroupableItemRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        GroupableItemRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        GroupableItemRef::LengthMeasureWithUnit(i) => {
            if i.0 >= model.length_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LENGTH_MEASURE_WITH_UNIT",
                });
            }
        }
        GroupableItemRef::LengthUnit(i) => {
            if i.0 >= model.length_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LENGTH_UNIT",
                });
            }
        }
        GroupableItemRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        GroupableItemRef::LocalTime(i) => {
            if i.0 >= model.local_time_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LOCAL_TIME",
                });
            }
        }
        GroupableItemRef::Loop(i) => {
            if i.0 >= model.loop_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LOOP" });
            }
        }
        GroupableItemRef::MakeFromUsageOption(i) => {
            if i.0 >= model.make_from_usage_option_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAKE_FROM_USAGE_OPTION",
                });
            }
        }
        GroupableItemRef::ManifoldSolidBrep(i) => {
            if i.0 >= model.manifold_solid_brep_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SOLID_BREP",
                });
            }
        }
        GroupableItemRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::MappedItem(i) => {
            if i.0 >= model.mapped_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAPPED_ITEM",
                });
            }
        }
        GroupableItemRef::MassMeasureWithUnit(i) => {
            if i.0 >= model.mass_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MASS_MEASURE_WITH_UNIT",
                });
            }
        }
        GroupableItemRef::MassUnit(i) => {
            if i.0 >= model.mass_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MASS_UNIT",
                });
            }
        }
        GroupableItemRef::MeasureRepresentationItem(i) => {
            if i.0 >= model.measure_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_REPRESENTATION_ITEM",
                });
            }
        }
        GroupableItemRef::MeasureWithUnit(i) => {
            if i.0 >= model.measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_WITH_UNIT",
                });
            }
        }
        GroupableItemRef::MechanicalDesignAndDraughtingRelationship(i) => {
            if i.0
                >= model
                    .mechanical_design_and_draughting_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_AND_DRAUGHTING_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::MechanicalDesignPresentationRepresentationWithDraughting(i) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        GroupableItemRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::NamedUnit(i) => {
            if i.0 >= model.named_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NAMED_UNIT",
                });
            }
        }
        GroupableItemRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        GroupableItemRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        GroupableItemRef::OneDirectionRepeatFactor(i) => {
            if i.0 >= model.one_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ONE_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        GroupableItemRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        GroupableItemRef::Organization(i) => {
            if i.0 >= model.organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION",
                });
            }
        }
        GroupableItemRef::OrganizationRelationship(i) => {
            if i.0 >= model.organization_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::OrganizationType(i) => {
            if i.0 >= model.organization_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION_TYPE",
                });
            }
        }
        GroupableItemRef::OrganizationalAddress(i) => {
            if i.0 >= model.organizational_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_ADDRESS",
                });
            }
        }
        GroupableItemRef::OrganizationalProject(i) => {
            if i.0 >= model.organizational_project_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT",
                });
            }
        }
        GroupableItemRef::OrganizationalProjectRelationship(i) => {
            if i.0 >= model.organizational_project_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        GroupableItemRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        GroupableItemRef::OverRidingStyledItem(i) => {
            if i.0 >= model.over_riding_styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        GroupableItemRef::ParametricRepresentationContext(i) => {
            if i.0 >= model.parametric_representation_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PARAMETRIC_REPRESENTATION_CONTEXT",
                });
            }
        }
        GroupableItemRef::Path(i) => {
            if i.0 >= model.path_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PATH" });
            }
        }
        GroupableItemRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        GroupableItemRef::Person(i) => {
            if i.0 >= model.person_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PERSON" });
            }
        }
        GroupableItemRef::PersonAndOrganization(i) => {
            if i.0 >= model.person_and_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION",
                });
            }
        }
        GroupableItemRef::PersonAndOrganizationAddress(i) => {
            if i.0 >= model.person_and_organization_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION_ADDRESS",
                });
            }
        }
        GroupableItemRef::PersonalAddress(i) => {
            if i.0 >= model.personal_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSONAL_ADDRESS",
                });
            }
        }
        GroupableItemRef::PlacedDatumTargetFeature(i) => {
            if i.0 >= model.placed_datum_target_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACED_DATUM_TARGET_FEATURE",
                });
            }
        }
        GroupableItemRef::Placement(i) => {
            if i.0 >= model.placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACEMENT",
                });
            }
        }
        GroupableItemRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        GroupableItemRef::PlanarExtent(i) => {
            if i.0 >= model.planar_extent_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_EXTENT",
                });
            }
        }
        GroupableItemRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        GroupableItemRef::PlaneAngleMeasureWithUnit(i) => {
            if i.0 >= model.plane_angle_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANE_ANGLE_MEASURE_WITH_UNIT",
                });
            }
        }
        GroupableItemRef::PlaneAngleUnit(i) => {
            if i.0 >= model.plane_angle_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANE_ANGLE_UNIT",
                });
            }
        }
        GroupableItemRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        GroupableItemRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        GroupableItemRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        GroupableItemRef::PrecisionQualifier(i) => {
            if i.0 >= model.precision_qualifier_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRECISION_QUALIFIER",
                });
            }
        }
        GroupableItemRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        GroupableItemRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        GroupableItemRef::Product(i) => {
            if i.0 >= model.product_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PRODUCT" });
            }
        }
        GroupableItemRef::ProductConcept(i) => {
            if i.0 >= model.product_concept_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT",
                });
            }
        }
        GroupableItemRef::ProductConceptContext(i) => {
            if i.0 >= model.product_concept_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_CONTEXT",
                });
            }
        }
        GroupableItemRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        GroupableItemRef::ProductDefinitionContext(i) => {
            if i.0 >= model.product_definition_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_CONTEXT",
                });
            }
        }
        GroupableItemRef::ProductDefinitionEffectivity(i) => {
            if i.0 >= model.product_definition_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_EFFECTIVITY",
                });
            }
        }
        GroupableItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        GroupableItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        GroupableItemRef::ProductDefinitionRelationship(i) => {
            if i.0 >= model.product_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        GroupableItemRef::ProductDefinitionUsage(i) => {
            if i.0 >= model.product_definition_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_USAGE",
                });
            }
        }
        GroupableItemRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        GroupableItemRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        GroupableItemRef::PropertyDefinitionRepresentation(i) => {
            if i.0 >= model.property_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::QualifiedRepresentationItem(i) => {
            if i.0 >= model.qualified_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUALIFIED_REPRESENTATION_ITEM",
                });
            }
        }
        GroupableItemRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        GroupableItemRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        GroupableItemRef::RatioMeasureWithUnit(i) => {
            if i.0 >= model.ratio_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIO_MEASURE_WITH_UNIT",
                });
            }
        }
        GroupableItemRef::RatioUnit(i) => {
            if i.0 >= model.ratio_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIO_UNIT",
                });
            }
        }
        GroupableItemRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        GroupableItemRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        GroupableItemRef::RealRepresentationItem(i) => {
            if i.0 >= model.real_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REAL_REPRESENTATION_ITEM",
                });
            }
        }
        GroupableItemRef::RepositionedTessellatedItem(i) => {
            if i.0 >= model.repositioned_tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPOSITIONED_TESSELLATED_ITEM",
                });
            }
        }
        GroupableItemRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        GroupableItemRef::RepresentationContext(i) => {
            if i.0 >= model.representation_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_CONTEXT",
                });
            }
        }
        GroupableItemRef::RepresentationItem(i) => {
            if i.0 >= model.representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_ITEM",
                });
            }
        }
        GroupableItemRef::RepresentationRelationship(i) => {
            if i.0 >= model.representation_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::RepresentationRelationshipWithTransformation(i) => {
            if i.0
                >= model
                    .representation_relationship_with_transformation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION",
                });
            }
        }
        GroupableItemRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        GroupableItemRef::SecurityClassification(i) => {
            if i.0 >= model.security_classification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION",
                });
            }
        }
        GroupableItemRef::ShapeAspect(i) => {
            if i.0 >= model.shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT",
                });
            }
        }
        GroupableItemRef::ShapeAspectAssociativity(i) => {
            if i.0 >= model.shape_aspect_associativity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_ASSOCIATIVITY",
                });
            }
        }
        GroupableItemRef::ShapeAspectDerivingRelationship(i) => {
            if i.0 >= model.shape_aspect_deriving_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_DERIVING_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::ShapeAspectRelationship(i) => {
            if i.0 >= model.shape_aspect_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::ShapeDefinitionRepresentation(i) => {
            if i.0 >= model.shape_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DEFINITION_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::ShapeRepresentationRelationship(i) => {
            if i.0 >= model.shape_representation_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        GroupableItemRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        GroupableItemRef::ShellBasedSurfaceModel(i) => {
            if i.0 >= model.shell_based_surface_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHELL_BASED_SURFACE_MODEL",
                });
            }
        }
        GroupableItemRef::SiUnit(i) => {
            if i.0 >= model.si_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SI_UNIT" });
            }
        }
        GroupableItemRef::SolidAngleUnit(i) => {
            if i.0 >= model.solid_angle_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_ANGLE_UNIT",
                });
            }
        }
        GroupableItemRef::SolidModel(i) => {
            if i.0 >= model.solid_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_MODEL",
                });
            }
        }
        GroupableItemRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        GroupableItemRef::StateObserved(i) => {
            if i.0 >= model.state_observed_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_OBSERVED",
                });
            }
        }
        GroupableItemRef::StateType(i) => {
            if i.0 >= model.state_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_TYPE",
                });
            }
        }
        GroupableItemRef::StyledItem(i) => {
            if i.0 >= model.styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STYLED_ITEM",
                });
            }
        }
        GroupableItemRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        GroupableItemRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        GroupableItemRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        GroupableItemRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        GroupableItemRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        GroupableItemRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::SymbolTarget(i) => {
            if i.0 >= model.symbol_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_TARGET",
                });
            }
        }
        GroupableItemRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        GroupableItemRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        GroupableItemRef::TessellatedCurveSet(i) => {
            if i.0 >= model.tessellated_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_CURVE_SET",
                });
            }
        }
        GroupableItemRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        GroupableItemRef::TessellatedGeometricSet(i) => {
            if i.0 >= model.tessellated_geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                });
            }
        }
        GroupableItemRef::TessellatedItem(i) => {
            if i.0 >= model.tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ITEM",
                });
            }
        }
        GroupableItemRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        GroupableItemRef::TessellatedShell(i) => {
            if i.0 >= model.tessellated_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHELL",
                });
            }
        }
        GroupableItemRef::TessellatedSolid(i) => {
            if i.0 >= model.tessellated_solid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SOLID",
                });
            }
        }
        GroupableItemRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        GroupableItemRef::TessellatedSurfaceSet(i) => {
            if i.0 >= model.tessellated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SURFACE_SET",
                });
            }
        }
        GroupableItemRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        GroupableItemRef::TimeUnit(i) => {
            if i.0 >= model.time_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TIME_UNIT",
                });
            }
        }
        GroupableItemRef::ToleranceZone(i) => {
            if i.0 >= model.tolerance_zone_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE",
                });
            }
        }
        GroupableItemRef::ToleranceZoneWithDatum(i) => {
            if i.0 >= model.tolerance_zone_with_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                });
            }
        }
        GroupableItemRef::TopologicalRepresentationItem(i) => {
            if i.0 >= model.topological_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOPOLOGICAL_REPRESENTATION_ITEM",
                });
            }
        }
        GroupableItemRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        GroupableItemRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        GroupableItemRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        GroupableItemRef::TypeQualifier(i) => {
            if i.0 >= model.type_qualifier_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TYPE_QUALIFIER",
                });
            }
        }
        GroupableItemRef::UncertaintyMeasureWithUnit(i) => {
            if i.0 >= model.uncertainty_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNCERTAINTY_MEASURE_WITH_UNIT",
                });
            }
        }
        GroupableItemRef::UncertaintyQualifier(i) => {
            if i.0 >= model.uncertainty_qualifier_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNCERTAINTY_QUALIFIER",
                });
            }
        }
        GroupableItemRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        GroupableItemRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        GroupableItemRef::ValueRepresentationItem(i) => {
            if i.0 >= model.value_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VALUE_REPRESENTATION_ITEM",
                });
            }
        }
        GroupableItemRef::Vector(i) => {
            if i.0 >= model.vector_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VECTOR" });
            }
        }
        GroupableItemRef::VersionedActionRequest(i) => {
            if i.0 >= model.versioned_action_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERSIONED_ACTION_REQUEST",
                });
            }
        }
        GroupableItemRef::Vertex(i) => {
            if i.0 >= model.vertex_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VERTEX" });
            }
        }
        GroupableItemRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
        GroupableItemRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        GroupableItemRef::VertexShell(i) => {
            if i.0 >= model.vertex_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_SHELL",
                });
            }
        }
        GroupableItemRef::VolumeUnit(i) => {
            if i.0 >= model.volume_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VOLUME_UNIT",
                });
            }
        }
        GroupableItemRef::WireShell(i) => {
            if i.0 >= model.wire_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "WIRE_SHELL",
                });
            }
        }
        GroupableItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_id_attribute_select_ref(
    model: &StepModel,
    r: &IdAttributeSelectRef,
) -> Result<(), AuthorError> {
    match r {
        IdAttributeSelectRef::Action(i) => {
            if i.0 >= model.action_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ACTION" });
            }
        }
        IdAttributeSelectRef::Address(i) => {
            if i.0 >= model.address_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ADDRESS" });
            }
        }
        IdAttributeSelectRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        IdAttributeSelectRef::AllAroundShapeAspect(i) => {
            if i.0 >= model.all_around_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ALL_AROUND_SHAPE_ASPECT",
                });
            }
        }
        IdAttributeSelectRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        IdAttributeSelectRef::AngularSize(i) => {
            if i.0 >= model.angular_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_SIZE",
                });
            }
        }
        IdAttributeSelectRef::AngularityTolerance(i) => {
            if i.0 >= model.angularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULARITY_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::ApplicationContext(i) => {
            if i.0 >= model.application_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLICATION_CONTEXT",
                });
            }
        }
        IdAttributeSelectRef::AscribableStateRelationship(i) => {
            if i.0 >= model.ascribable_state_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASCRIBABLE_STATE_RELATIONSHIP",
                });
            }
        }
        IdAttributeSelectRef::CentreOfSymmetry(i) => {
            if i.0 >= model.centre_of_symmetry_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CENTRE_OF_SYMMETRY",
                });
            }
        }
        IdAttributeSelectRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::CircularRunoutTolerance(i) => {
            if i.0 >= model.circular_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CIRCULAR_RUNOUT_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        IdAttributeSelectRef::CoaxialityTolerance(i) => {
            if i.0 >= model.coaxiality_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COAXIALITY_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        IdAttributeSelectRef::CompositeGroupShapeAspect(i) => {
            if i.0 >= model.composite_group_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_GROUP_SHAPE_ASPECT",
                });
            }
        }
        IdAttributeSelectRef::CompositeShapeAspect(i) => {
            if i.0 >= model.composite_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_SHAPE_ASPECT",
                });
            }
        }
        IdAttributeSelectRef::ConcentricityTolerance(i) => {
            if i.0 >= model.concentricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONCENTRICITY_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        IdAttributeSelectRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::ContinuousShapeAspect(i) => {
            if i.0 >= model.continuous_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTINUOUS_SHAPE_ASPECT",
                });
            }
        }
        IdAttributeSelectRef::CylindricityTolerance(i) => {
            if i.0 >= model.cylindricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICITY_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        IdAttributeSelectRef::DatumFeature(i) => {
            if i.0 >= model.datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_FEATURE",
                });
            }
        }
        IdAttributeSelectRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
        IdAttributeSelectRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        IdAttributeSelectRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        IdAttributeSelectRef::DatumTarget(i) => {
            if i.0 >= model.datum_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_TARGET",
                });
            }
        }
        IdAttributeSelectRef::DefaultModelGeometricView(i) => {
            if i.0 >= model.default_model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFAULT_MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        IdAttributeSelectRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::DerivedShapeAspect(i) => {
            if i.0 >= model.derived_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_SHAPE_ASPECT",
                });
            }
        }
        IdAttributeSelectRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        IdAttributeSelectRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        IdAttributeSelectRef::DimensionalSize(i) => {
            if i.0 >= model.dimensional_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE",
                });
            }
        }
        IdAttributeSelectRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        IdAttributeSelectRef::DimensionalSizeWithPath(i) => {
            if i.0 >= model.dimensional_size_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_PATH",
                });
            }
        }
        IdAttributeSelectRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        IdAttributeSelectRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        IdAttributeSelectRef::Edge(i) => {
            if i.0 >= model.edge_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "EDGE" });
            }
        }
        IdAttributeSelectRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        IdAttributeSelectRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        IdAttributeSelectRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        IdAttributeSelectRef::FaceBound(i) => {
            if i.0 >= model.face_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_BOUND",
                });
            }
        }
        IdAttributeSelectRef::FaceOuterBound(i) => {
            if i.0 >= model.face_outer_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_OUTER_BOUND",
                });
            }
        }
        IdAttributeSelectRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        IdAttributeSelectRef::FeatureForDatumTargetRelationship(i) => {
            if i.0
                >= model
                    .feature_for_datum_target_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FEATURE_FOR_DATUM_TARGET_RELATIONSHIP",
                });
            }
        }
        IdAttributeSelectRef::FlatnessTolerance(i) => {
            if i.0 >= model.flatness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FLATNESS_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::GeneralDatumReference(i) => {
            if i.0 >= model.general_datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_DATUM_REFERENCE",
                });
            }
        }
        IdAttributeSelectRef::GeometricTolerance(i) => {
            if i.0 >= model.geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::GeometricToleranceWithDatumReference(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_datum_reference_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
                });
            }
        }
        IdAttributeSelectRef::GeometricToleranceWithDefinedAreaUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_area_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT",
                });
            }
        }
        IdAttributeSelectRef::GeometricToleranceWithDefinedUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT",
                });
            }
        }
        IdAttributeSelectRef::GeometricToleranceWithMaximumTolerance(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_maximum_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::GeometricToleranceWithModifiers(i) => {
            if i.0 >= model.geometric_tolerance_with_modifiers_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
                });
            }
        }
        IdAttributeSelectRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::Group(i) => {
            if i.0 >= model.group_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "GROUP" });
            }
        }
        IdAttributeSelectRef::LineProfileTolerance(i) => {
            if i.0 >= model.line_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LINE_PROFILE_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::Loop(i) => {
            if i.0 >= model.loop_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LOOP" });
            }
        }
        IdAttributeSelectRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::MechanicalDesignPresentationRepresentationWithDraughting(i) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        IdAttributeSelectRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::ModifiedGeometricTolerance(i) => {
            if i.0 >= model.modified_geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MODIFIED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        IdAttributeSelectRef::OrganizationalAddress(i) => {
            if i.0 >= model.organizational_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_ADDRESS",
                });
            }
        }
        IdAttributeSelectRef::OrganizationalProject(i) => {
            if i.0 >= model.organizational_project_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT",
                });
            }
        }
        IdAttributeSelectRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        IdAttributeSelectRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        IdAttributeSelectRef::ParallelismTolerance(i) => {
            if i.0 >= model.parallelism_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PARALLELISM_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::Path(i) => {
            if i.0 >= model.path_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PATH" });
            }
        }
        IdAttributeSelectRef::PerpendicularityTolerance(i) => {
            if i.0 >= model.perpendicularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERPENDICULARITY_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::PersonAndOrganizationAddress(i) => {
            if i.0 >= model.person_and_organization_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION_ADDRESS",
                });
            }
        }
        IdAttributeSelectRef::PersonalAddress(i) => {
            if i.0 >= model.personal_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSONAL_ADDRESS",
                });
            }
        }
        IdAttributeSelectRef::PlacedDatumTargetFeature(i) => {
            if i.0 >= model.placed_datum_target_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACED_DATUM_TARGET_FEATURE",
                });
            }
        }
        IdAttributeSelectRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        IdAttributeSelectRef::PositionTolerance(i) => {
            if i.0 >= model.position_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POSITION_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        IdAttributeSelectRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        IdAttributeSelectRef::ProductCategory(i) => {
            if i.0 >= model.product_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CATEGORY",
                });
            }
        }
        IdAttributeSelectRef::ProductConceptFeatureCategory(i) => {
            if i.0 >= model.product_concept_feature_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE_CATEGORY",
                });
            }
        }
        IdAttributeSelectRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        IdAttributeSelectRef::ProductRelatedProductCategory(i) => {
            if i.0 >= model.product_related_product_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_RELATED_PRODUCT_CATEGORY",
                });
            }
        }
        IdAttributeSelectRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        IdAttributeSelectRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::RoundnessTolerance(i) => {
            if i.0 >= model.roundness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ROUNDNESS_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::ShapeAspect(i) => {
            if i.0 >= model.shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT",
                });
            }
        }
        IdAttributeSelectRef::ShapeAspectAssociativity(i) => {
            if i.0 >= model.shape_aspect_associativity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_ASSOCIATIVITY",
                });
            }
        }
        IdAttributeSelectRef::ShapeAspectDerivingRelationship(i) => {
            if i.0 >= model.shape_aspect_deriving_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_DERIVING_RELATIONSHIP",
                });
            }
        }
        IdAttributeSelectRef::ShapeAspectRelationship(i) => {
            if i.0 >= model.shape_aspect_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_RELATIONSHIP",
                });
            }
        }
        IdAttributeSelectRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        IdAttributeSelectRef::StraightnessTolerance(i) => {
            if i.0 >= model.straightness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STRAIGHTNESS_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::SurfaceProfileTolerance(i) => {
            if i.0 >= model.surface_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_PROFILE_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::SymmetryTolerance(i) => {
            if i.0 >= model.symmetry_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMMETRY_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        IdAttributeSelectRef::ToleranceZone(i) => {
            if i.0 >= model.tolerance_zone_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE",
                });
            }
        }
        IdAttributeSelectRef::ToleranceZoneWithDatum(i) => {
            if i.0 >= model.tolerance_zone_with_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                });
            }
        }
        IdAttributeSelectRef::TopologicalRepresentationItem(i) => {
            if i.0 >= model.topological_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOPOLOGICAL_REPRESENTATION_ITEM",
                });
            }
        }
        IdAttributeSelectRef::TotalRunoutTolerance(i) => {
            if i.0 >= model.total_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOTAL_RUNOUT_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::UnequallyDisposedGeometricTolerance(i) => {
            if i.0
                >= model
                    .unequally_disposed_geometric_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        IdAttributeSelectRef::Vertex(i) => {
            if i.0 >= model.vertex_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VERTEX" });
            }
        }
        IdAttributeSelectRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
        IdAttributeSelectRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        IdAttributeSelectRef::VertexShell(i) => {
            if i.0 >= model.vertex_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_SHELL",
                });
            }
        }
        IdAttributeSelectRef::WireShell(i) => {
            if i.0 >= model.wire_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "WIRE_SHELL",
                });
            }
        }
        IdAttributeSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_identification_role_ref(
    model: &StepModel,
    r: &IdentificationRoleRef,
) -> Result<(), AuthorError> {
    match r {
        IdentificationRoleRef::IdentificationRole(i) => {
            if i.0 >= model.identification_role_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "IDENTIFICATION_ROLE",
                });
            }
        }
    }
    Ok(())
}
fn check_invisible_item_ref(model: &StepModel, r: &InvisibleItemRef) -> Result<(), AuthorError> {
    match r {
        InvisibleItemRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        InvisibleItemRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        InvisibleItemRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        InvisibleItemRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        InvisibleItemRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        InvisibleItemRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        InvisibleItemRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        InvisibleItemRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        InvisibleItemRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::ContextDependentOverRidingStyledItem(i) => {
            if i.0
                >= model
                    .context_dependent_over_riding_styled_item_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        InvisibleItemRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        InvisibleItemRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        InvisibleItemRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        InvisibleItemRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        InvisibleItemRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        InvisibleItemRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        InvisibleItemRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::MechanicalDesignPresentationRepresentationWithDraughting(i) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        InvisibleItemRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::OverRidingStyledItem(i) => {
            if i.0 >= model.over_riding_styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        InvisibleItemRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        InvisibleItemRef::PresentationLayerAssignment(i) => {
            if i.0 >= model.presentation_layer_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_LAYER_ASSIGNMENT",
                });
            }
        }
        InvisibleItemRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        InvisibleItemRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        InvisibleItemRef::StyledItem(i) => {
            if i.0 >= model.styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STYLED_ITEM",
                });
            }
        }
        InvisibleItemRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        InvisibleItemRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        InvisibleItemRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        InvisibleItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_item_defined_transformation_ref(
    model: &StepModel,
    r: &ItemDefinedTransformationRef,
) -> Result<(), AuthorError> {
    match r {
        ItemDefinedTransformationRef::ItemDefinedTransformation(i) => {
            if i.0 >= model.item_defined_transformation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ITEM_DEFINED_TRANSFORMATION",
                });
            }
        }
        ItemDefinedTransformationRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_item_identified_representation_usage_definition_ref(
    model: &StepModel,
    r: &ItemIdentifiedRepresentationUsageDefinitionRef,
) -> Result<(), AuthorError> {
    match r {
        ItemIdentifiedRepresentationUsageDefinitionRef::AllAroundShapeAspect(i) => {
            if i.0 >= model.all_around_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ALL_AROUND_SHAPE_ASPECT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::AngularSize(i) => {
            if i.0 >= model.angular_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_SIZE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::AngularityTolerance(i) => {
            if i.0 >= model.angularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULARITY_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::AppliedApprovalAssignment(i) => {
            if i.0 >= model.applied_approval_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_APPROVAL_ASSIGNMENT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::AppliedDateAndTimeAssignment(i) => {
            if i.0 >= model.applied_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::AppliedDocumentReference(i) => {
            if i.0 >= model.applied_document_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DOCUMENT_REFERENCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::AppliedExternalIdentificationAssignment(
            i,
        ) => {
            if i.0
                >= model
                    .applied_external_identification_assignment_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::AppliedGroupAssignment(i) => {
            if i.0 >= model.applied_group_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_GROUP_ASSIGNMENT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::AppliedPersonAndOrganizationAssignment(
            i,
        ) => {
            if i.0
                >= model
                    .applied_person_and_organization_assignment_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::CentreOfSymmetry(i) => {
            if i.0 >= model.centre_of_symmetry_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CENTRE_OF_SYMMETRY",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::CharacterizedItemWithinRepresentation(
            i,
        ) => {
            if i.0
                >= model
                    .characterized_item_within_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_ITEM_WITHIN_REPRESENTATION",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::CharacterizedObject(i) => {
            if i.0 >= model.characterized_object_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_OBJECT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::CircularRunoutTolerance(i) => {
            if i.0 >= model.circular_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CIRCULAR_RUNOUT_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::CoaxialityTolerance(i) => {
            if i.0 >= model.coaxiality_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COAXIALITY_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::CompositeGroupShapeAspect(i) => {
            if i.0 >= model.composite_group_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_GROUP_SHAPE_ASPECT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::CompositeShapeAspect(i) => {
            if i.0 >= model.composite_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_SHAPE_ASPECT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ConcentricityTolerance(i) => {
            if i.0 >= model.concentricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONCENTRICITY_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ContinuousShapeAspect(i) => {
            if i.0 >= model.continuous_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTINUOUS_SHAPE_ASPECT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::CylindricityTolerance(i) => {
            if i.0 >= model.cylindricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICITY_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DatumFeature(i) => {
            if i.0 >= model.datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_FEATURE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DatumTarget(i) => {
            if i.0 >= model.datum_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_TARGET",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DefaultModelGeometricView(i) => {
            if i.0 >= model.default_model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFAULT_MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DerivedShapeAspect(i) => {
            if i.0 >= model.derived_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_SHAPE_ASPECT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DimensionalSize(i) => {
            if i.0 >= model.dimensional_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DimensionalSizeWithPath(i) => {
            if i.0 >= model.dimensional_size_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_PATH",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::DocumentFile(i) => {
            if i.0 >= model.document_file_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_FILE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::FeatureForDatumTargetRelationship(i) => {
            if i.0
                >= model
                    .feature_for_datum_target_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FEATURE_FOR_DATUM_TARGET_RELATIONSHIP",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::FlatnessTolerance(i) => {
            if i.0 >= model.flatness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FLATNESS_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::GeneralDatumReference(i) => {
            if i.0 >= model.general_datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_DATUM_REFERENCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::GeneralProperty(i) => {
            if i.0 >= model.general_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_PROPERTY",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::GeometricTolerance(i) => {
            if i.0 >= model.geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::GeometricToleranceWithDatumReference(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_datum_reference_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::GeometricToleranceWithDefinedAreaUnit(
            i,
        ) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_area_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::GeometricToleranceWithDefinedUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::GeometricToleranceWithMaximumTolerance(
            i,
        ) => {
            if i.0
                >= model
                    .geometric_tolerance_with_maximum_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::GeometricToleranceWithModifiers(i) => {
            if i.0 >= model.geometric_tolerance_with_modifiers_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::LineProfileTolerance(i) => {
            if i.0 >= model.line_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LINE_PROFILE_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::MakeFromUsageOption(i) => {
            if i.0 >= model.make_from_usage_option_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAKE_FROM_USAGE_OPTION",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ModelGeometricView(i) => {
            if i.0 >= model.model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ModifiedGeometricTolerance(i) => {
            if i.0 >= model.modified_geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MODIFIED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ParallelismTolerance(i) => {
            if i.0 >= model.parallelism_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PARALLELISM_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::PerpendicularityTolerance(i) => {
            if i.0 >= model.perpendicularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERPENDICULARITY_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::PlacedDatumTargetFeature(i) => {
            if i.0 >= model.placed_datum_target_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACED_DATUM_TARGET_FEATURE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::PositionTolerance(i) => {
            if i.0 >= model.position_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POSITION_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ProductDefinitionRelationship(i) => {
            if i.0 >= model.product_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ProductDefinitionUsage(i) => {
            if i.0 >= model.product_definition_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_USAGE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::PropertyDefinitionRelationship(i) => {
            if i.0 >= model.property_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION_RELATIONSHIP",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::RoundnessTolerance(i) => {
            if i.0 >= model.roundness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ROUNDNESS_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ShapeAspect(i) => {
            if i.0 >= model.shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ShapeAspectAssociativity(i) => {
            if i.0 >= model.shape_aspect_associativity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_ASSOCIATIVITY",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ShapeAspectDerivingRelationship(i) => {
            if i.0 >= model.shape_aspect_deriving_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_DERIVING_RELATIONSHIP",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ShapeAspectRelationship(i) => {
            if i.0 >= model.shape_aspect_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_RELATIONSHIP",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::StraightnessTolerance(i) => {
            if i.0 >= model.straightness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STRAIGHTNESS_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::SurfaceProfileTolerance(i) => {
            if i.0 >= model.surface_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_PROFILE_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::SymmetryTolerance(i) => {
            if i.0 >= model.symmetry_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMMETRY_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ToleranceZone(i) => {
            if i.0 >= model.tolerance_zone_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::ToleranceZoneWithDatum(i) => {
            if i.0 >= model.tolerance_zone_with_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::TotalRunoutTolerance(i) => {
            if i.0 >= model.total_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOTAL_RUNOUT_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::UnequallyDisposedGeometricTolerance(i) => {
            if i.0
                >= model
                    .unequally_disposed_geometric_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        ItemIdentifiedRepresentationUsageDefinitionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_item_identified_representation_usage_select_ref(
    model: &StepModel,
    r: &ItemIdentifiedRepresentationUsageSelectRef,
) -> Result<(), AuthorError> {
    match r {
        ItemIdentifiedRepresentationUsageSelectRef::AdvancedFace(i) => { if i.0 >= model.advanced_face_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ADVANCED_FACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationCurveOccurrence(i) => { if i.0 >= model.annotation_curve_occurrence_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ANNOTATION_CURVE_OCCURRENCE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationFillAreaOccurrence(i) => { if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ANNOTATION_FILL_AREA_OCCURRENCE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationOccurrence(i) => { if i.0 >= model.annotation_occurrence_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ANNOTATION_OCCURRENCE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationPlaceholderLeaderLine(_) => return Err(AuthorError::NotAp242 { entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE" }),
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationPlaceholderOccurrence(i) => { if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => return Err(AuthorError::NotAp242 { entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE" }),
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationPlane(i) => { if i.0 >= model.annotation_plane_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ANNOTATION_PLANE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationSymbol(i) => { if i.0 >= model.annotation_symbol_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ANNOTATION_SYMBOL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationSymbolOccurrence(i) => { if i.0 >= model.annotation_symbol_occurrence_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ANNOTATION_SYMBOL_OCCURRENCE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationText(i) => { if i.0 >= model.annotation_text_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ANNOTATION_TEXT" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationTextCharacter(i) => { if i.0 >= model.annotation_text_character_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ANNOTATION_TEXT_CHARACTER" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationTextOccurrence(i) => { if i.0 >= model.annotation_text_occurrence_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ANNOTATION_TEXT_OCCURRENCE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationToAnnotationLeaderLine(_) => return Err(AuthorError::NotAp242 { entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE" }),
        ItemIdentifiedRepresentationUsageSelectRef::AnnotationToModelLeaderLine(_) => return Err(AuthorError::NotAp242 { entity: "ANNOTATION_TO_MODEL_LEADER_LINE" }),
        ItemIdentifiedRepresentationUsageSelectRef::ApllPoint(_) => return Err(AuthorError::NotAp242 { entity: "APLL_POINT" }),
        ItemIdentifiedRepresentationUsageSelectRef::ApllPointWithSurface(_) => return Err(AuthorError::NotAp242 { entity: "APLL_POINT_WITH_SURFACE" }),
        ItemIdentifiedRepresentationUsageSelectRef::AuxiliaryLeaderLine(_) => return Err(AuthorError::NotAp242 { entity: "AUXILIARY_LEADER_LINE" }),
        ItemIdentifiedRepresentationUsageSelectRef::Axis1Placement(i) => { if i.0 >= model.axis1_placement_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "AXIS1_PLACEMENT" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Axis2Placement2d(i) => { if i.0 >= model.axis2_placement2d_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "AXIS2_PLACEMENT_2D" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Axis2Placement3d(i) => { if i.0 >= model.axis2_placement3d_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "AXIS2_PLACEMENT_3D" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::BSplineCurve(i) => { if i.0 >= model.b_spline_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "B_SPLINE_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::BSplineCurveWithKnots(i) => { if i.0 >= model.b_spline_curve_with_knots_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "B_SPLINE_CURVE_WITH_KNOTS" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::BSplineSurface(i) => { if i.0 >= model.b_spline_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "B_SPLINE_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::BSplineSurfaceWithKnots(i) => { if i.0 >= model.b_spline_surface_with_knots_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "B_SPLINE_SURFACE_WITH_KNOTS" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::BezierCurve(i) => { if i.0 >= model.bezier_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "BEZIER_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::BezierSurface(i) => { if i.0 >= model.bezier_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "BEZIER_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::BoundedCurve(i) => { if i.0 >= model.bounded_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "BOUNDED_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::BoundedPcurve(i) => { if i.0 >= model.bounded_pcurve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "BOUNDED_PCURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::BoundedSurface(i) => { if i.0 >= model.bounded_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "BOUNDED_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::BoundedSurfaceCurve(i) => { if i.0 >= model.bounded_surface_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "BOUNDED_SURFACE_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::BrepWithVoids(i) => { if i.0 >= model.brep_with_voids_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "BREP_WITH_VOIDS" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CameraImage(i) => { if i.0 >= model.camera_image_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CAMERA_IMAGE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CameraImage3dWithScale(i) => { if i.0 >= model.camera_image3d_with_scale_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CAMERA_IMAGE_3D_WITH_SCALE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CameraModel(i) => { if i.0 >= model.camera_model_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CAMERA_MODEL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CameraModelD3(i) => { if i.0 >= model.camera_model_d3_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CAMERA_MODEL_D3" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CameraModelD3MultiClipping(i) => { if i.0 >= model.camera_model_d3_multi_clipping_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CAMERA_MODEL_D3_MULTI_CLIPPING" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CameraModelD3WithHlhsr(i) => { if i.0 >= model.camera_model_d3_with_hlhsr_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CAMERA_MODEL_D3_WITH_HLHSR" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CartesianPoint(i) => { if i.0 >= model.cartesian_point_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CARTESIAN_POINT" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Circle(i) => { if i.0 >= model.circle_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CIRCLE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ClosedShell(i) => { if i.0 >= model.closed_shell_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CLOSED_SHELL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ComplexTriangulatedFace(i) => { if i.0 >= model.complex_triangulated_face_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "COMPLEX_TRIANGULATED_FACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ComplexTriangulatedSurfaceSet(i) => { if i.0 >= model.complex_triangulated_surface_set_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "COMPLEX_TRIANGULATED_SURFACE_SET" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CompositeCurve(i) => { if i.0 >= model.composite_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "COMPOSITE_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CompositeText(i) => { if i.0 >= model.composite_text_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "COMPOSITE_TEXT" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CompoundRepresentationItem(i) => { if i.0 >= model.compound_representation_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "COMPOUND_REPRESENTATION_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Conic(i) => { if i.0 >= model.conic_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CONIC" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ConicalSurface(i) => { if i.0 >= model.conical_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CONICAL_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ConnectedFaceSet(i) => { if i.0 >= model.connected_face_set_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CONNECTED_FACE_SET" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ContextDependentOverRidingStyledItem(i) => { if i.0 >= model.context_dependent_over_riding_styled_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CoordinatesList(i) => { if i.0 >= model.coordinates_list_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "COORDINATES_LIST" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Curve(i) => { if i.0 >= model.curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::CylindricalSurface(i) => { if i.0 >= model.cylindrical_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CYLINDRICAL_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::DefinedCharacterGlyph(i) => { if i.0 >= model.defined_character_glyph_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "DEFINED_CHARACTER_GLYPH" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::DefinedSymbol(i) => { if i.0 >= model.defined_symbol_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "DEFINED_SYMBOL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::DegenerateToroidalSurface(i) => { if i.0 >= model.degenerate_toroidal_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "DEGENERATE_TOROIDAL_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::DescriptiveRepresentationItem(i) => { if i.0 >= model.descriptive_representation_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "DESCRIPTIVE_REPRESENTATION_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Direction(i) => { if i.0 >= model.direction_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "DIRECTION" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::DraughtingAnnotationOccurrence(i) => { if i.0 >= model.draughting_annotation_occurrence_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "DRAUGHTING_ANNOTATION_OCCURRENCE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::DraughtingCallout(i) => { if i.0 >= model.draughting_callout_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "DRAUGHTING_CALLOUT" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Edge(i) => { if i.0 >= model.edge_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "EDGE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::EdgeCurve(i) => { if i.0 >= model.edge_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "EDGE_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::EdgeLoop(i) => { if i.0 >= model.edge_loop_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "EDGE_LOOP" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ElementarySurface(i) => { if i.0 >= model.elementary_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ELEMENTARY_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Ellipse(i) => { if i.0 >= model.ellipse_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ELLIPSE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ExternallyDefinedHatchStyle(i) => { if i.0 >= model.externally_defined_hatch_style_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "EXTERNALLY_DEFINED_HATCH_STYLE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ExternallyDefinedTileStyle(i) => { if i.0 >= model.externally_defined_tile_style_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "EXTERNALLY_DEFINED_TILE_STYLE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Face(i) => { if i.0 >= model.face_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "FACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::FaceBound(i) => { if i.0 >= model.face_bound_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "FACE_BOUND" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::FaceOuterBound(i) => { if i.0 >= model.face_outer_bound_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "FACE_OUTER_BOUND" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::FaceSurface(i) => { if i.0 >= model.face_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "FACE_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::FillAreaStyleHatching(i) => { if i.0 >= model.fill_area_style_hatching_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "FILL_AREA_STYLE_HATCHING" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::FillAreaStyleTileColouredRegion(i) => { if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::FillAreaStyleTileCurveWithStyle(i) => { if i.0 >= model.fill_area_style_tile_curve_with_style_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::FillAreaStyleTileSymbolWithStyle(i) => { if i.0 >= model.fill_area_style_tile_symbol_with_style_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::FillAreaStyleTiles(i) => { if i.0 >= model.fill_area_style_tiles_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "FILL_AREA_STYLE_TILES" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::GeometricCurveSet(i) => { if i.0 >= model.geometric_curve_set_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "GEOMETRIC_CURVE_SET" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::GeometricRepresentationItem(i) => { if i.0 >= model.geometric_representation_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "GEOMETRIC_REPRESENTATION_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::GeometricSet(i) => { if i.0 >= model.geometric_set_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "GEOMETRIC_SET" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Hyperbola(i) => { if i.0 >= model.hyperbola_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "HYPERBOLA" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::IntegerRepresentationItem(i) => { if i.0 >= model.integer_representation_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "INTEGER_REPRESENTATION_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::IntersectionCurve(i) => { if i.0 >= model.intersection_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "INTERSECTION_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::LeaderCurve(i) => { if i.0 >= model.leader_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "LEADER_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::LeaderDirectedCallout(i) => { if i.0 >= model.leader_directed_callout_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "LEADER_DIRECTED_CALLOUT" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::LeaderTerminator(i) => { if i.0 >= model.leader_terminator_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "LEADER_TERMINATOR" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Line(i) => { if i.0 >= model.line_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "LINE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Loop(i) => { if i.0 >= model.loop_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "LOOP" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ManifoldSolidBrep(i) => { if i.0 >= model.manifold_solid_brep_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MANIFOLD_SOLID_BREP" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::MappedItem(i) => { if i.0 >= model.mapped_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MAPPED_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::MeasureRepresentationItem(i) => { if i.0 >= model.measure_representation_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MEASURE_REPRESENTATION_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::OffsetSurface(i) => { if i.0 >= model.offset_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "OFFSET_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::OneDirectionRepeatFactor(i) => { if i.0 >= model.one_direction_repeat_factor_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ONE_DIRECTION_REPEAT_FACTOR" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::OpenShell(i) => { if i.0 >= model.open_shell_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "OPEN_SHELL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::OrientedClosedShell(i) => { if i.0 >= model.oriented_closed_shell_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ORIENTED_CLOSED_SHELL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::OrientedEdge(i) => { if i.0 >= model.oriented_edge_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ORIENTED_EDGE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::OverRidingStyledItem(i) => { if i.0 >= model.over_riding_styled_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "OVER_RIDING_STYLED_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Path(i) => { if i.0 >= model.path_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "PATH" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Pcurve(i) => { if i.0 >= model.pcurve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "PCURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Placement(i) => { if i.0 >= model.placement_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "PLACEMENT" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::PlanarBox(i) => { if i.0 >= model.planar_box_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "PLANAR_BOX" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::PlanarExtent(i) => { if i.0 >= model.planar_extent_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "PLANAR_EXTENT" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Plane(i) => { if i.0 >= model.plane_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "PLANE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Point(i) => { if i.0 >= model.point_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "POINT" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::PolyLoop(i) => { if i.0 >= model.poly_loop_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "POLY_LOOP" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Polyline(i) => { if i.0 >= model.polyline_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "POLYLINE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::QualifiedRepresentationItem(i) => { if i.0 >= model.qualified_representation_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "QUALIFIED_REPRESENTATION_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::QuasiUniformCurve(i) => { if i.0 >= model.quasi_uniform_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "QUASI_UNIFORM_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::QuasiUniformSurface(i) => { if i.0 >= model.quasi_uniform_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "QUASI_UNIFORM_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::RationalBSplineCurve(i) => { if i.0 >= model.rational_b_spline_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "RATIONAL_B_SPLINE_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::RationalBSplineSurface(i) => { if i.0 >= model.rational_b_spline_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "RATIONAL_B_SPLINE_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::RealRepresentationItem(i) => { if i.0 >= model.real_representation_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "REAL_REPRESENTATION_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::RepositionedTessellatedItem(i) => { if i.0 >= model.repositioned_tessellated_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "REPOSITIONED_TESSELLATED_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::RepresentationItem(i) => { if i.0 >= model.representation_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "REPRESENTATION_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::SeamCurve(i) => { if i.0 >= model.seam_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SEAM_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ShellBasedSurfaceModel(i) => { if i.0 >= model.shell_based_surface_model_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SHELL_BASED_SURFACE_MODEL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::SolidModel(i) => { if i.0 >= model.solid_model_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SOLID_MODEL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::SphericalSurface(i) => { if i.0 >= model.spherical_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SPHERICAL_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::StyledItem(i) => { if i.0 >= model.styled_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "STYLED_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Surface(i) => { if i.0 >= model.surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::SurfaceCurve(i) => { if i.0 >= model.surface_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SURFACE_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::SurfaceOfLinearExtrusion(i) => { if i.0 >= model.surface_of_linear_extrusion_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SURFACE_OF_LINEAR_EXTRUSION" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::SurfaceOfRevolution(i) => { if i.0 >= model.surface_of_revolution_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SURFACE_OF_REVOLUTION" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::SweptSurface(i) => { if i.0 >= model.swept_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SWEPT_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::SymbolTarget(i) => { if i.0 >= model.symbol_target_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SYMBOL_TARGET" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TerminatorSymbol(i) => { if i.0 >= model.terminator_symbol_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TERMINATOR_SYMBOL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TessellatedAnnotationOccurrence(i) => { if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_ANNOTATION_OCCURRENCE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TessellatedCurveSet(i) => { if i.0 >= model.tessellated_curve_set_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_CURVE_SET" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TessellatedFace(i) => { if i.0 >= model.tessellated_face_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_FACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TessellatedGeometricSet(i) => { if i.0 >= model.tessellated_geometric_set_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_GEOMETRIC_SET" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TessellatedItem(i) => { if i.0 >= model.tessellated_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TessellatedShell(i) => { if i.0 >= model.tessellated_shell_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_SHELL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TessellatedSolid(i) => { if i.0 >= model.tessellated_solid_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_SOLID" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TessellatedStructuredItem(i) => { if i.0 >= model.tessellated_structured_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_STRUCTURED_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TessellatedSurfaceSet(i) => { if i.0 >= model.tessellated_surface_set_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_SURFACE_SET" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TextLiteral(i) => { if i.0 >= model.text_literal_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TEXT_LITERAL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TopologicalRepresentationItem(i) => { if i.0 >= model.topological_representation_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TOPOLOGICAL_REPRESENTATION_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ToroidalSurface(i) => { if i.0 >= model.toroidal_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TOROIDAL_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TrimmedCurve(i) => { if i.0 >= model.trimmed_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TRIMMED_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::TwoDirectionRepeatFactor(i) => { if i.0 >= model.two_direction_repeat_factor_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TWO_DIRECTION_REPEAT_FACTOR" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::UniformCurve(i) => { if i.0 >= model.uniform_curve_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "UNIFORM_CURVE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::UniformSurface(i) => { if i.0 >= model.uniform_surface_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "UNIFORM_SURFACE" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ValueRepresentationItem(i) => { if i.0 >= model.value_representation_item_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "VALUE_REPRESENTATION_ITEM" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Vector(i) => { if i.0 >= model.vector_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "VECTOR" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::Vertex(i) => { if i.0 >= model.vertex_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "VERTEX" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::VertexLoop(i) => { if i.0 >= model.vertex_loop_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "VERTEX_LOOP" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::VertexPoint(i) => { if i.0 >= model.vertex_point_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "VERTEX_POINT" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::VertexShell(i) => { if i.0 >= model.vertex_shell_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "VERTEX_SHELL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::WireShell(i) => { if i.0 >= model.wire_shell_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "WIRE_SHELL" }); } }
        ItemIdentifiedRepresentationUsageSelectRef::ListRepresentationItem(v) => { for e in v { check_representation_item_ref(model, e)?; } }
        ItemIdentifiedRepresentationUsageSelectRef::SetRepresentationItem(v) => { for e in v { check_representation_item_ref(model, e)?; } }
        ItemIdentifiedRepresentationUsageSelectRef::Complex(i) => { if i.0 >= model.complex_unit_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "COMPLEX" }); } }
    }
    Ok(())
}
fn check_layered_item_ref(model: &StepModel, r: &LayeredItemRef) -> Result<(), AuthorError> {
    match r {
        LayeredItemRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        LayeredItemRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        LayeredItemRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        LayeredItemRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        LayeredItemRef::AnnotationPlaceholderLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE",
            });
        }
        LayeredItemRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        LayeredItemRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        LayeredItemRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        LayeredItemRef::AnnotationSymbol(i) => {
            if i.0 >= model.annotation_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL",
                });
            }
        }
        LayeredItemRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        LayeredItemRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        LayeredItemRef::AnnotationTextCharacter(i) => {
            if i.0 >= model.annotation_text_character_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_CHARACTER",
                });
            }
        }
        LayeredItemRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        LayeredItemRef::AnnotationToAnnotationLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE",
            });
        }
        LayeredItemRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
        LayeredItemRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        LayeredItemRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        LayeredItemRef::AuxiliaryLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "AUXILIARY_LEADER_LINE",
            });
        }
        LayeredItemRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
        LayeredItemRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        LayeredItemRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
        LayeredItemRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        LayeredItemRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        LayeredItemRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        LayeredItemRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        LayeredItemRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        LayeredItemRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        LayeredItemRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        LayeredItemRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        LayeredItemRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        LayeredItemRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        LayeredItemRef::BrepWithVoids(i) => {
            if i.0 >= model.brep_with_voids_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BREP_WITH_VOIDS",
                });
            }
        }
        LayeredItemRef::CameraImage(i) => {
            if i.0 >= model.camera_image_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE",
                });
            }
        }
        LayeredItemRef::CameraImage3dWithScale(i) => {
            if i.0 >= model.camera_image3d_with_scale_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE_3D_WITH_SCALE",
                });
            }
        }
        LayeredItemRef::CameraModel(i) => {
            if i.0 >= model.camera_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL",
                });
            }
        }
        LayeredItemRef::CameraModelD3(i) => {
            if i.0 >= model.camera_model_d3_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3",
                });
            }
        }
        LayeredItemRef::CameraModelD3MultiClipping(i) => {
            if i.0 >= model.camera_model_d3_multi_clipping_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                });
            }
        }
        LayeredItemRef::CameraModelD3WithHlhsr(i) => {
            if i.0 >= model.camera_model_d3_with_hlhsr_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_WITH_HLHSR",
                });
            }
        }
        LayeredItemRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        LayeredItemRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        LayeredItemRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        LayeredItemRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        LayeredItemRef::ComplexTriangulatedSurfaceSet(i) => {
            if i.0 >= model.complex_triangulated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_SURFACE_SET",
                });
            }
        }
        LayeredItemRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        LayeredItemRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        LayeredItemRef::CompoundRepresentationItem(i) => {
            if i.0 >= model.compound_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOUND_REPRESENTATION_ITEM",
                });
            }
        }
        LayeredItemRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        LayeredItemRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        LayeredItemRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        LayeredItemRef::ContextDependentOverRidingStyledItem(i) => {
            if i.0
                >= model
                    .context_dependent_over_riding_styled_item_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        LayeredItemRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
        LayeredItemRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        LayeredItemRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        LayeredItemRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        LayeredItemRef::DefinedSymbol(i) => {
            if i.0 >= model.defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_SYMBOL",
                });
            }
        }
        LayeredItemRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        LayeredItemRef::DescriptiveRepresentationItem(i) => {
            if i.0 >= model.descriptive_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESCRIPTIVE_REPRESENTATION_ITEM",
                });
            }
        }
        LayeredItemRef::Direction(i) => {
            if i.0 >= model.direction_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTION",
                });
            }
        }
        LayeredItemRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        LayeredItemRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        LayeredItemRef::Edge(i) => {
            if i.0 >= model.edge_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "EDGE" });
            }
        }
        LayeredItemRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        LayeredItemRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        LayeredItemRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        LayeredItemRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        LayeredItemRef::ExternallyDefinedHatchStyle(i) => {
            if i.0 >= model.externally_defined_hatch_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_HATCH_STYLE",
                });
            }
        }
        LayeredItemRef::ExternallyDefinedTileStyle(i) => {
            if i.0 >= model.externally_defined_tile_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE_STYLE",
                });
            }
        }
        LayeredItemRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        LayeredItemRef::FaceBound(i) => {
            if i.0 >= model.face_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_BOUND",
                });
            }
        }
        LayeredItemRef::FaceOuterBound(i) => {
            if i.0 >= model.face_outer_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_OUTER_BOUND",
                });
            }
        }
        LayeredItemRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        LayeredItemRef::FillAreaStyleHatching(i) => {
            if i.0 >= model.fill_area_style_hatching_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_HATCHING",
                });
            }
        }
        LayeredItemRef::FillAreaStyleTileColouredRegion(i) => {
            if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION",
                });
            }
        }
        LayeredItemRef::FillAreaStyleTileCurveWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_curve_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE",
                });
            }
        }
        LayeredItemRef::FillAreaStyleTileSymbolWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_symbol_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
                });
            }
        }
        LayeredItemRef::FillAreaStyleTiles(i) => {
            if i.0 >= model.fill_area_style_tiles_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILES",
                });
            }
        }
        LayeredItemRef::GeometricCurveSet(i) => {
            if i.0 >= model.geometric_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_CURVE_SET",
                });
            }
        }
        LayeredItemRef::GeometricRepresentationItem(i) => {
            if i.0 >= model.geometric_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_ITEM",
                });
            }
        }
        LayeredItemRef::GeometricSet(i) => {
            if i.0 >= model.geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_SET",
                });
            }
        }
        LayeredItemRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        LayeredItemRef::IntegerRepresentationItem(i) => {
            if i.0 >= model.integer_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTEGER_REPRESENTATION_ITEM",
                });
            }
        }
        LayeredItemRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        LayeredItemRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        LayeredItemRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        LayeredItemRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        LayeredItemRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        LayeredItemRef::Loop(i) => {
            if i.0 >= model.loop_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LOOP" });
            }
        }
        LayeredItemRef::ManifoldSolidBrep(i) => {
            if i.0 >= model.manifold_solid_brep_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SOLID_BREP",
                });
            }
        }
        LayeredItemRef::MappedItem(i) => {
            if i.0 >= model.mapped_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAPPED_ITEM",
                });
            }
        }
        LayeredItemRef::MeasureRepresentationItem(i) => {
            if i.0 >= model.measure_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_REPRESENTATION_ITEM",
                });
            }
        }
        LayeredItemRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        LayeredItemRef::OneDirectionRepeatFactor(i) => {
            if i.0 >= model.one_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ONE_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        LayeredItemRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        LayeredItemRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        LayeredItemRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        LayeredItemRef::OverRidingStyledItem(i) => {
            if i.0 >= model.over_riding_styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        LayeredItemRef::Path(i) => {
            if i.0 >= model.path_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PATH" });
            }
        }
        LayeredItemRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        LayeredItemRef::Placement(i) => {
            if i.0 >= model.placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACEMENT",
                });
            }
        }
        LayeredItemRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        LayeredItemRef::PlanarExtent(i) => {
            if i.0 >= model.planar_extent_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_EXTENT",
                });
            }
        }
        LayeredItemRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        LayeredItemRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        LayeredItemRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        LayeredItemRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        LayeredItemRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        LayeredItemRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        LayeredItemRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        LayeredItemRef::QualifiedRepresentationItem(i) => {
            if i.0 >= model.qualified_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUALIFIED_REPRESENTATION_ITEM",
                });
            }
        }
        LayeredItemRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        LayeredItemRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        LayeredItemRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        LayeredItemRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        LayeredItemRef::RealRepresentationItem(i) => {
            if i.0 >= model.real_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REAL_REPRESENTATION_ITEM",
                });
            }
        }
        LayeredItemRef::RepositionedTessellatedItem(i) => {
            if i.0 >= model.repositioned_tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPOSITIONED_TESSELLATED_ITEM",
                });
            }
        }
        LayeredItemRef::RepresentationItem(i) => {
            if i.0 >= model.representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_ITEM",
                });
            }
        }
        LayeredItemRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        LayeredItemRef::ShellBasedSurfaceModel(i) => {
            if i.0 >= model.shell_based_surface_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHELL_BASED_SURFACE_MODEL",
                });
            }
        }
        LayeredItemRef::SolidModel(i) => {
            if i.0 >= model.solid_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_MODEL",
                });
            }
        }
        LayeredItemRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        LayeredItemRef::StyledItem(i) => {
            if i.0 >= model.styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STYLED_ITEM",
                });
            }
        }
        LayeredItemRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        LayeredItemRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        LayeredItemRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        LayeredItemRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        LayeredItemRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        LayeredItemRef::SymbolTarget(i) => {
            if i.0 >= model.symbol_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_TARGET",
                });
            }
        }
        LayeredItemRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        LayeredItemRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        LayeredItemRef::TessellatedCurveSet(i) => {
            if i.0 >= model.tessellated_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_CURVE_SET",
                });
            }
        }
        LayeredItemRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        LayeredItemRef::TessellatedGeometricSet(i) => {
            if i.0 >= model.tessellated_geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                });
            }
        }
        LayeredItemRef::TessellatedItem(i) => {
            if i.0 >= model.tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ITEM",
                });
            }
        }
        LayeredItemRef::TessellatedShell(i) => {
            if i.0 >= model.tessellated_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHELL",
                });
            }
        }
        LayeredItemRef::TessellatedSolid(i) => {
            if i.0 >= model.tessellated_solid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SOLID",
                });
            }
        }
        LayeredItemRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        LayeredItemRef::TessellatedSurfaceSet(i) => {
            if i.0 >= model.tessellated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SURFACE_SET",
                });
            }
        }
        LayeredItemRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        LayeredItemRef::TopologicalRepresentationItem(i) => {
            if i.0 >= model.topological_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOPOLOGICAL_REPRESENTATION_ITEM",
                });
            }
        }
        LayeredItemRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        LayeredItemRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        LayeredItemRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        LayeredItemRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        LayeredItemRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        LayeredItemRef::ValueRepresentationItem(i) => {
            if i.0 >= model.value_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VALUE_REPRESENTATION_ITEM",
                });
            }
        }
        LayeredItemRef::Vector(i) => {
            if i.0 >= model.vector_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VECTOR" });
            }
        }
        LayeredItemRef::Vertex(i) => {
            if i.0 >= model.vertex_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VERTEX" });
            }
        }
        LayeredItemRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
        LayeredItemRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        LayeredItemRef::VertexShell(i) => {
            if i.0 >= model.vertex_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_SHELL",
                });
            }
        }
        LayeredItemRef::WireShell(i) => {
            if i.0 >= model.wire_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "WIRE_SHELL",
                });
            }
        }
        LayeredItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_length_measure_with_unit_ref(
    model: &StepModel,
    r: &LengthMeasureWithUnitRef,
) -> Result<(), AuthorError> {
    match r {
        LengthMeasureWithUnitRef::LengthMeasureWithUnit(i) => {
            if i.0 >= model.length_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LENGTH_MEASURE_WITH_UNIT",
                });
            }
        }
        LengthMeasureWithUnitRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_length_or_plane_angle_measure_with_unit_select_ref(
    model: &StepModel,
    r: &LengthOrPlaneAngleMeasureWithUnitSelectRef,
) -> Result<(), AuthorError> {
    match r {
        LengthOrPlaneAngleMeasureWithUnitSelectRef::LengthMeasureWithUnit(i) => {
            if i.0 >= model.length_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LENGTH_MEASURE_WITH_UNIT",
                });
            }
        }
        LengthOrPlaneAngleMeasureWithUnitSelectRef::PlaneAngleMeasureWithUnit(i) => {
            if i.0 >= model.plane_angle_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANE_ANGLE_MEASURE_WITH_UNIT",
                });
            }
        }
        LengthOrPlaneAngleMeasureWithUnitSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_local_time_ref(model: &StepModel, r: &LocalTimeRef) -> Result<(), AuthorError> {
    match r {
        LocalTimeRef::LocalTime(i) => {
            if i.0 >= model.local_time_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LOCAL_TIME",
                });
            }
        }
    }
    Ok(())
}
fn check_loop_ref(model: &StepModel, r: &LoopRef) -> Result<(), AuthorError> {
    match r {
        LoopRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        LoopRef::Loop(i) => {
            if i.0 >= model.loop_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LOOP" });
            }
        }
        LoopRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        LoopRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
        LoopRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_manifold_solid_brep_ref(
    model: &StepModel,
    r: &ManifoldSolidBrepRef,
) -> Result<(), AuthorError> {
    match r {
        ManifoldSolidBrepRef::BrepWithVoids(i) => {
            if i.0 >= model.brep_with_voids_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BREP_WITH_VOIDS",
                });
            }
        }
        ManifoldSolidBrepRef::ManifoldSolidBrep(i) => {
            if i.0 >= model.manifold_solid_brep_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SOLID_BREP",
                });
            }
        }
        ManifoldSolidBrepRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_marker_select_ref(model: &StepModel, r: &MarkerSelectRef) -> Result<(), AuthorError> {
    match r {
        MarkerSelectRef::PreDefinedMarker(i) => {
            if i.0 >= model.pre_defined_marker_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_MARKER",
                });
            }
        }
        MarkerSelectRef::PreDefinedPointMarkerSymbol(i) => {
            if i.0 >= model.pre_defined_point_marker_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_POINT_MARKER_SYMBOL",
                });
            }
        }
        MarkerSelectRef::MarkerType(_) => {}
        MarkerSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_measure_with_unit_ref(
    model: &StepModel,
    r: &MeasureWithUnitRef,
) -> Result<(), AuthorError> {
    match r {
        MeasureWithUnitRef::LengthMeasureWithUnit(i) => {
            if i.0 >= model.length_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LENGTH_MEASURE_WITH_UNIT",
                });
            }
        }
        MeasureWithUnitRef::MassMeasureWithUnit(i) => {
            if i.0 >= model.mass_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MASS_MEASURE_WITH_UNIT",
                });
            }
        }
        MeasureWithUnitRef::MeasureRepresentationItem(i) => {
            if i.0 >= model.measure_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_REPRESENTATION_ITEM",
                });
            }
        }
        MeasureWithUnitRef::MeasureWithUnit(i) => {
            if i.0 >= model.measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_WITH_UNIT",
                });
            }
        }
        MeasureWithUnitRef::PlaneAngleMeasureWithUnit(i) => {
            if i.0 >= model.plane_angle_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANE_ANGLE_MEASURE_WITH_UNIT",
                });
            }
        }
        MeasureWithUnitRef::RatioMeasureWithUnit(i) => {
            if i.0 >= model.ratio_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIO_MEASURE_WITH_UNIT",
                });
            }
        }
        MeasureWithUnitRef::UncertaintyMeasureWithUnit(i) => {
            if i.0 >= model.uncertainty_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNCERTAINTY_MEASURE_WITH_UNIT",
                });
            }
        }
        MeasureWithUnitRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_mechanical_design_and_draughting_relationship_select_ref(
    model: &StepModel,
    r: &MechanicalDesignAndDraughtingRelationshipSelectRef,
) -> Result<(), AuthorError> {
    match r {
        MechanicalDesignAndDraughtingRelationshipSelectRef::AdvancedBrepShapeRepresentation(i) => { if i.0 >= model.advanced_brep_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ADVANCED_BREP_SHAPE_REPRESENTATION" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::DraughtingModel(i) => { if i.0 >= model.draughting_model_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "DRAUGHTING_MODEL" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => { if i.0 >= model.geometrically_bounded_surface_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::GeometricallyBoundedWireframeShapeRepresentation(i) => { if i.0 >= model.geometrically_bounded_wireframe_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::ManifoldSurfaceShapeRepresentation(i) => { if i.0 >= model.manifold_surface_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::MechanicalDesignGeometricPresentationRepresentation(i) => { if i.0 >= model.mechanical_design_geometric_presentation_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::MechanicalDesignPresentationRepresentationWithDraughting(i) => { if i.0 >= model.mechanical_design_presentation_representation_with_draughting_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::MechanicalDesignShadedPresentationRepresentation(i) => { if i.0 >= model.mechanical_design_shaded_presentation_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::ShapeDimensionRepresentation(i) => { if i.0 >= model.shape_dimension_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SHAPE_DIMENSION_REPRESENTATION" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::ShapeRepresentation(i) => { if i.0 >= model.shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SHAPE_REPRESENTATION" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::ShapeRepresentationWithParameters(i) => { if i.0 >= model.shape_representation_with_parameters_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::TessellatedShapeRepresentation(i) => { if i.0 >= model.tessellated_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_SHAPE_REPRESENTATION" }); } }
        MechanicalDesignAndDraughtingRelationshipSelectRef::Complex(i) => { if i.0 >= model.complex_unit_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "COMPLEX" }); } }
    }
    Ok(())
}
fn check_name_attribute_select_ref(
    model: &StepModel,
    r: &NameAttributeSelectRef,
) -> Result<(), AuthorError> {
    match r {
        NameAttributeSelectRef::ActionRequestSolution(i) => {
            if i.0 >= model.action_request_solution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_REQUEST_SOLUTION",
                });
            }
        }
        NameAttributeSelectRef::Address(i) => {
            if i.0 >= model.address_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ADDRESS" });
            }
        }
        NameAttributeSelectRef::AreaUnit(i) => {
            if i.0 >= model.area_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AREA_UNIT",
                });
            }
        }
        NameAttributeSelectRef::ConfigurationDesign(i) => {
            if i.0 >= model.configuration_design_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_DESIGN",
                });
            }
        }
        NameAttributeSelectRef::ConfigurationEffectivity(i) => {
            if i.0 >= model.configuration_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_EFFECTIVITY",
                });
            }
        }
        NameAttributeSelectRef::ContextDependentShapeRepresentation(i) => {
            if i.0
                >= model
                    .context_dependent_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_SHAPE_REPRESENTATION",
                });
            }
        }
        NameAttributeSelectRef::DerivedUnit(i) => {
            if i.0 >= model.derived_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_UNIT",
                });
            }
        }
        NameAttributeSelectRef::Effectivity(i) => {
            if i.0 >= model.effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EFFECTIVITY",
                });
            }
        }
        NameAttributeSelectRef::OrganizationalAddress(i) => {
            if i.0 >= model.organizational_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_ADDRESS",
                });
            }
        }
        NameAttributeSelectRef::PersonAndOrganization(i) => {
            if i.0 >= model.person_and_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION",
                });
            }
        }
        NameAttributeSelectRef::PersonAndOrganizationAddress(i) => {
            if i.0 >= model.person_and_organization_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION_ADDRESS",
                });
            }
        }
        NameAttributeSelectRef::PersonalAddress(i) => {
            if i.0 >= model.personal_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSONAL_ADDRESS",
                });
            }
        }
        NameAttributeSelectRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        NameAttributeSelectRef::ProductDefinitionEffectivity(i) => {
            if i.0 >= model.product_definition_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_EFFECTIVITY",
                });
            }
        }
        NameAttributeSelectRef::ProductDefinitionSubstitute(i) => {
            if i.0 >= model.product_definition_substitute_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SUBSTITUTE",
                });
            }
        }
        NameAttributeSelectRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        NameAttributeSelectRef::PropertyDefinitionRepresentation(i) => {
            if i.0 >= model.property_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION_REPRESENTATION",
                });
            }
        }
        NameAttributeSelectRef::ShapeDefinitionRepresentation(i) => {
            if i.0 >= model.shape_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DEFINITION_REPRESENTATION",
                });
            }
        }
        NameAttributeSelectRef::VolumeUnit(i) => {
            if i.0 >= model.volume_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VOLUME_UNIT",
                });
            }
        }
        NameAttributeSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_named_unit_ref(model: &StepModel, r: &NamedUnitRef) -> Result<(), AuthorError> {
    match r {
        NamedUnitRef::ContextDependentUnit(i) => {
            if i.0 >= model.context_dependent_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_UNIT",
                });
            }
        }
        NamedUnitRef::ConversionBasedUnit(i) => {
            if i.0 >= model.conversion_based_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONVERSION_BASED_UNIT",
                });
            }
        }
        NamedUnitRef::LengthUnit(i) => {
            if i.0 >= model.length_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LENGTH_UNIT",
                });
            }
        }
        NamedUnitRef::MassUnit(i) => {
            if i.0 >= model.mass_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MASS_UNIT",
                });
            }
        }
        NamedUnitRef::NamedUnit(i) => {
            if i.0 >= model.named_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NAMED_UNIT",
                });
            }
        }
        NamedUnitRef::PlaneAngleUnit(i) => {
            if i.0 >= model.plane_angle_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANE_ANGLE_UNIT",
                });
            }
        }
        NamedUnitRef::RatioUnit(i) => {
            if i.0 >= model.ratio_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIO_UNIT",
                });
            }
        }
        NamedUnitRef::SiUnit(i) => {
            if i.0 >= model.si_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SI_UNIT" });
            }
        }
        NamedUnitRef::SolidAngleUnit(i) => {
            if i.0 >= model.solid_angle_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_ANGLE_UNIT",
                });
            }
        }
        NamedUnitRef::TimeUnit(i) => {
            if i.0 >= model.time_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TIME_UNIT",
                });
            }
        }
        NamedUnitRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_object_role_ref(model: &StepModel, r: &ObjectRoleRef) -> Result<(), AuthorError> {
    match r {
        ObjectRoleRef::ObjectRole(i) => {
            if i.0 >= model.object_role_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OBJECT_ROLE",
                });
            }
        }
    }
    Ok(())
}
fn check_one_direction_repeat_factor_ref(
    model: &StepModel,
    r: &OneDirectionRepeatFactorRef,
) -> Result<(), AuthorError> {
    match r {
        OneDirectionRepeatFactorRef::OneDirectionRepeatFactor(i) => {
            if i.0 >= model.one_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ONE_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        OneDirectionRepeatFactorRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        OneDirectionRepeatFactorRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_organization_ref(model: &StepModel, r: &OrganizationRef) -> Result<(), AuthorError> {
    match r {
        OrganizationRef::Organization(i) => {
            if i.0 >= model.organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION",
                });
            }
        }
    }
    Ok(())
}
fn check_organizational_project_ref(
    model: &StepModel,
    r: &OrganizationalProjectRef,
) -> Result<(), AuthorError> {
    match r {
        OrganizationalProjectRef::OrganizationalProject(i) => {
            if i.0 >= model.organizational_project_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT",
                });
            }
        }
    }
    Ok(())
}
fn check_oriented_closed_shell_ref(
    model: &StepModel,
    r: &OrientedClosedShellRef,
) -> Result<(), AuthorError> {
    match r {
        OrientedClosedShellRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        OrientedClosedShellRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_oriented_edge_ref(model: &StepModel, r: &OrientedEdgeRef) -> Result<(), AuthorError> {
    match r {
        OrientedEdgeRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        OrientedEdgeRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_pcurve_or_surface_ref(
    model: &StepModel,
    r: &PcurveOrSurfaceRef,
) -> Result<(), AuthorError> {
    match r {
        PcurveOrSurfaceRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        PcurveOrSurfaceRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        PcurveOrSurfaceRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        PcurveOrSurfaceRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        PcurveOrSurfaceRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        PcurveOrSurfaceRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        PcurveOrSurfaceRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        PcurveOrSurfaceRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        PcurveOrSurfaceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_person_ref(model: &StepModel, r: &PersonRef) -> Result<(), AuthorError> {
    match r {
        PersonRef::Person(i) => {
            if i.0 >= model.person_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PERSON" });
            }
        }
    }
    Ok(())
}
fn check_person_and_organization_ref(
    model: &StepModel,
    r: &PersonAndOrganizationRef,
) -> Result<(), AuthorError> {
    match r {
        PersonAndOrganizationRef::PersonAndOrganization(i) => {
            if i.0 >= model.person_and_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION",
                });
            }
        }
    }
    Ok(())
}
fn check_person_and_organization_item_ref(
    model: &StepModel,
    r: &PersonAndOrganizationItemRef,
) -> Result<(), AuthorError> {
    match r {
        PersonAndOrganizationItemRef::Action(i) => {
            if i.0 >= model.action_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ACTION" });
            }
        }
        PersonAndOrganizationItemRef::ActionDirective(i) => {
            if i.0 >= model.action_directive_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_DIRECTIVE",
                });
            }
        }
        PersonAndOrganizationItemRef::ActionMethod(i) => {
            if i.0 >= model.action_method_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD",
                });
            }
        }
        PersonAndOrganizationItemRef::ActionProperty(i) => {
            if i.0 >= model.action_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_PROPERTY",
                });
            }
        }
        PersonAndOrganizationItemRef::ActionRelationship(i) => {
            if i.0 >= model.action_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_RELATIONSHIP",
                });
            }
        }
        PersonAndOrganizationItemRef::ActionRequestSolution(i) => {
            if i.0 >= model.action_request_solution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_REQUEST_SOLUTION",
                });
            }
        }
        PersonAndOrganizationItemRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::AppliedDateAndTimeAssignment(i) => {
            if i.0 >= model.applied_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        PersonAndOrganizationItemRef::AppliedDocumentReference(i) => {
            if i.0 >= model.applied_document_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DOCUMENT_REFERENCE",
                });
            }
        }
        PersonAndOrganizationItemRef::AppliedPersonAndOrganizationAssignment(i) => {
            if i.0
                >= model
                    .applied_person_and_organization_assignment_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT",
                });
            }
        }
        PersonAndOrganizationItemRef::Approval(i) => {
            if i.0 >= model.approval_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "APPROVAL" });
            }
        }
        PersonAndOrganizationItemRef::ApprovalStatus(i) => {
            if i.0 >= model.approval_status_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_STATUS",
                });
            }
        }
        PersonAndOrganizationItemRef::AscribableState(i) => {
            if i.0 >= model.ascribable_state_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASCRIBABLE_STATE",
                });
            }
        }
        PersonAndOrganizationItemRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        PersonAndOrganizationItemRef::CcDesignDateAndTimeAssignment(i) => {
            if i.0 >= model.cc_design_date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        PersonAndOrganizationItemRef::Certification(i) => {
            if i.0 >= model.certification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CERTIFICATION",
                });
            }
        }
        PersonAndOrganizationItemRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::ConfigurationDesign(i) => {
            if i.0 >= model.configuration_design_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_DESIGN",
                });
            }
        }
        PersonAndOrganizationItemRef::ConfigurationEffectivity(i) => {
            if i.0 >= model.configuration_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_EFFECTIVITY",
                });
            }
        }
        PersonAndOrganizationItemRef::ConfigurationItem(i) => {
            if i.0 >= model.configuration_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_ITEM",
                });
            }
        }
        PersonAndOrganizationItemRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::Contract(i) => {
            if i.0 >= model.contract_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONTRACT" });
            }
        }
        PersonAndOrganizationItemRef::DateAndTimeAssignment(i) => {
            if i.0 >= model.date_and_time_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATE_AND_TIME_ASSIGNMENT",
                });
            }
        }
        PersonAndOrganizationItemRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::DesignContext(i) => {
            if i.0 >= model.design_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESIGN_CONTEXT",
                });
            }
        }
        PersonAndOrganizationItemRef::DocumentFile(i) => {
            if i.0 >= model.document_file_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_FILE",
                });
            }
        }
        PersonAndOrganizationItemRef::DocumentType(i) => {
            if i.0 >= model.document_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_TYPE",
                });
            }
        }
        PersonAndOrganizationItemRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        PersonAndOrganizationItemRef::Effectivity(i) => {
            if i.0 >= model.effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EFFECTIVITY",
                });
            }
        }
        PersonAndOrganizationItemRef::GeneralProperty(i) => {
            if i.0 >= model.general_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_PROPERTY",
                });
            }
        }
        PersonAndOrganizationItemRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::MakeFromUsageOption(i) => {
            if i.0 >= model.make_from_usage_option_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAKE_FROM_USAGE_OPTION",
                });
            }
        }
        PersonAndOrganizationItemRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::MechanicalDesignPresentationRepresentationWithDraughting(
            i,
        ) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        PersonAndOrganizationItemRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        PersonAndOrganizationItemRef::Organization(i) => {
            if i.0 >= model.organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION",
                });
            }
        }
        PersonAndOrganizationItemRef::OrganizationRelationship(i) => {
            if i.0 >= model.organization_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION_RELATIONSHIP",
                });
            }
        }
        PersonAndOrganizationItemRef::OrganizationalAddress(i) => {
            if i.0 >= model.organizational_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_ADDRESS",
                });
            }
        }
        PersonAndOrganizationItemRef::OrganizationalProject(i) => {
            if i.0 >= model.organizational_project_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT",
                });
            }
        }
        PersonAndOrganizationItemRef::PersonAndOrganization(i) => {
            if i.0 >= model.person_and_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION",
                });
            }
        }
        PersonAndOrganizationItemRef::PersonAndOrganizationAddress(i) => {
            if i.0 >= model.person_and_organization_address_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION_ADDRESS",
                });
            }
        }
        PersonAndOrganizationItemRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        PersonAndOrganizationItemRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        PersonAndOrganizationItemRef::Product(i) => {
            if i.0 >= model.product_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PRODUCT" });
            }
        }
        PersonAndOrganizationItemRef::ProductConcept(i) => {
            if i.0 >= model.product_concept_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductConceptFeature(i) => {
            if i.0 >= model.product_concept_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductConceptFeatureCategory(i) => {
            if i.0 >= model.product_concept_feature_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE_CATEGORY",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductDefinitionContext(i) => {
            if i.0 >= model.product_definition_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_CONTEXT",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductDefinitionEffectivity(i) => {
            if i.0 >= model.product_definition_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_EFFECTIVITY",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductDefinitionRelationship(i) => {
            if i.0 >= model.product_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductDefinitionSubstitute(i) => {
            if i.0 >= model.product_definition_substitute_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SUBSTITUTE",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductDefinitionUsage(i) => {
            if i.0 >= model.product_definition_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_USAGE",
                });
            }
        }
        PersonAndOrganizationItemRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        PersonAndOrganizationItemRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        PersonAndOrganizationItemRef::PropertyDefinitionRepresentation(i) => {
            if i.0 >= model.property_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::ResourceProperty(i) => {
            if i.0 >= model.resource_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RESOURCE_PROPERTY",
                });
            }
        }
        PersonAndOrganizationItemRef::SecurityClassification(i) => {
            if i.0 >= model.security_classification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION",
                });
            }
        }
        PersonAndOrganizationItemRef::SecurityClassificationLevel(i) => {
            if i.0 >= model.security_classification_level_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION_LEVEL",
                });
            }
        }
        PersonAndOrganizationItemRef::ShapeDefinitionRepresentation(i) => {
            if i.0 >= model.shape_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DEFINITION_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        PersonAndOrganizationItemRef::StateObserved(i) => {
            if i.0 >= model.state_observed_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_OBSERVED",
                });
            }
        }
        PersonAndOrganizationItemRef::StateType(i) => {
            if i.0 >= model.state_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_TYPE",
                });
            }
        }
        PersonAndOrganizationItemRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        PersonAndOrganizationItemRef::VersionedActionRequest(i) => {
            if i.0 >= model.versioned_action_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERSIONED_ACTION_REQUEST",
                });
            }
        }
        PersonAndOrganizationItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_person_and_organization_role_ref(
    model: &StepModel,
    r: &PersonAndOrganizationRoleRef,
) -> Result<(), AuthorError> {
    match r {
        PersonAndOrganizationRoleRef::PersonAndOrganizationRole(i) => {
            if i.0 >= model.person_and_organization_role_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION_ROLE",
                });
            }
        }
    }
    Ok(())
}
fn check_person_organization_select_ref(
    model: &StepModel,
    r: &PersonOrganizationSelectRef,
) -> Result<(), AuthorError> {
    match r {
        PersonOrganizationSelectRef::Organization(i) => {
            if i.0 >= model.organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATION",
                });
            }
        }
        PersonOrganizationSelectRef::Person(i) => {
            if i.0 >= model.person_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PERSON" });
            }
        }
        PersonOrganizationSelectRef::PersonAndOrganization(i) => {
            if i.0 >= model.person_and_organization_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERSON_AND_ORGANIZATION",
                });
            }
        }
    }
    Ok(())
}
fn check_planar_box_ref(model: &StepModel, r: &PlanarBoxRef) -> Result<(), AuthorError> {
    match r {
        PlanarBoxRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        PlanarBoxRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_plane_or_planar_box_ref(
    model: &StepModel,
    r: &PlaneOrPlanarBoxRef,
) -> Result<(), AuthorError> {
    match r {
        PlaneOrPlanarBoxRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        PlaneOrPlanarBoxRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        PlaneOrPlanarBoxRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_point_ref(model: &StepModel, r: &PointRef) -> Result<(), AuthorError> {
    match r {
        PointRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        PointRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        PointRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        PointRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        PointRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_presentation_area_ref(
    model: &StepModel,
    r: &PresentationAreaRef,
) -> Result<(), AuthorError> {
    match r {
        PresentationAreaRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        PresentationAreaRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_presentation_representation_select_ref(
    model: &StepModel,
    r: &PresentationRepresentationSelectRef,
) -> Result<(), AuthorError> {
    match r {
        PresentationRepresentationSelectRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        PresentationRepresentationSelectRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        PresentationRepresentationSelectRef::PresentationSet(i) => {
            if i.0 >= model.presentation_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_SET",
                });
            }
        }
        PresentationRepresentationSelectRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        PresentationRepresentationSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_presentation_set_ref(
    model: &StepModel,
    r: &PresentationSetRef,
) -> Result<(), AuthorError> {
    match r {
        PresentationSetRef::PresentationSet(i) => {
            if i.0 >= model.presentation_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_SET",
                });
            }
        }
        PresentationSetRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_presentation_size_assignment_select_ref(
    model: &StepModel,
    r: &PresentationSizeAssignmentSelectRef,
) -> Result<(), AuthorError> {
    match r {
        PresentationSizeAssignmentSelectRef::AreaInSet(i) => {
            if i.0 >= model.area_in_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AREA_IN_SET",
                });
            }
        }
        PresentationSizeAssignmentSelectRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        PresentationSizeAssignmentSelectRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        PresentationSizeAssignmentSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_presentation_style_assignment_ref(
    model: &StepModel,
    r: &PresentationStyleAssignmentRef,
) -> Result<(), AuthorError> {
    match r {
        PresentationStyleAssignmentRef::PresentationStyleAssignment(i) => {
            if i.0 >= model.presentation_style_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_STYLE_ASSIGNMENT",
                });
            }
        }
        PresentationStyleAssignmentRef::PresentationStyleByContext(i) => {
            if i.0 >= model.presentation_style_by_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_STYLE_BY_CONTEXT",
                });
            }
        }
        PresentationStyleAssignmentRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_presentation_style_select_ref(
    model: &StepModel,
    r: &PresentationStyleSelectRef,
) -> Result<(), AuthorError> {
    match r {
        PresentationStyleSelectRef::ApproximationTolerance(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APPROXIMATION_TOLERANCE",
            });
        }
        PresentationStyleSelectRef::CurveStyle(i) => {
            if i.0 >= model.curve_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CURVE_STYLE",
                });
            }
        }
        PresentationStyleSelectRef::ExternallyDefinedStyle(i) => {
            if i.0 >= model.externally_defined_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_STYLE",
                });
            }
        }
        PresentationStyleSelectRef::FillAreaStyle(i) => {
            if i.0 >= model.fill_area_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE",
                });
            }
        }
        PresentationStyleSelectRef::PointStyle(i) => {
            if i.0 >= model.point_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POINT_STYLE",
                });
            }
        }
        PresentationStyleSelectRef::PreDefinedPresentationStyle(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "PRE_DEFINED_PRESENTATION_STYLE",
            });
        }
        PresentationStyleSelectRef::SurfaceStyleUsage(i) => {
            if i.0 >= model.surface_style_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_STYLE_USAGE",
                });
            }
        }
        PresentationStyleSelectRef::SymbolStyle(i) => {
            if i.0 >= model.symbol_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_STYLE",
                });
            }
        }
        PresentationStyleSelectRef::TextStyle(i) => {
            if i.0 >= model.text_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_STYLE",
                });
            }
        }
        PresentationStyleSelectRef::TextStyleWithBoxCharacteristics(i) => {
            if i.0 >= model.text_style_with_box_characteristics_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_STYLE_WITH_BOX_CHARACTERISTICS",
                });
            }
        }
        PresentationStyleSelectRef::TextureStyleTessellationSpecification(i) => {
            if i.0
                >= model
                    .texture_style_tessellation_specification_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXTURE_STYLE_TESSELLATION_SPECIFICATION",
                });
            }
        }
        PresentationStyleSelectRef::NullStyle(_) => {}
        PresentationStyleSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_presented_item_ref(model: &StepModel, r: &PresentedItemRef) -> Result<(), AuthorError> {
    match r {
        PresentedItemRef::AppliedPresentedItem(i) => {
            if i.0 >= model.applied_presented_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_PRESENTED_ITEM",
                });
            }
        }
        PresentedItemRef::PresentedItem(i) => {
            if i.0 >= model.presented_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTED_ITEM",
                });
            }
        }
        PresentedItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_presented_item_select_ref(
    model: &StepModel,
    r: &PresentedItemSelectRef,
) -> Result<(), AuthorError> {
    match r {
        PresentedItemSelectRef::Action(i) => {
            if i.0 >= model.action_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ACTION" });
            }
        }
        PresentedItemSelectRef::ActionMethod(i) => {
            if i.0 >= model.action_method_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD",
                });
            }
        }
        PresentedItemSelectRef::ActionRelationship(i) => {
            if i.0 >= model.action_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_RELATIONSHIP",
                });
            }
        }
        PresentedItemSelectRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        PresentedItemSelectRef::MakeFromUsageOption(i) => {
            if i.0 >= model.make_from_usage_option_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAKE_FROM_USAGE_OPTION",
                });
            }
        }
        PresentedItemSelectRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        PresentedItemSelectRef::ProductConcept(i) => {
            if i.0 >= model.product_concept_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT",
                });
            }
        }
        PresentedItemSelectRef::ProductConceptFeature(i) => {
            if i.0 >= model.product_concept_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE",
                });
            }
        }
        PresentedItemSelectRef::ProductConceptFeatureCategory(i) => {
            if i.0 >= model.product_concept_feature_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE_CATEGORY",
                });
            }
        }
        PresentedItemSelectRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        PresentedItemSelectRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        PresentedItemSelectRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        PresentedItemSelectRef::ProductDefinitionRelationship(i) => {
            if i.0 >= model.product_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP",
                });
            }
        }
        PresentedItemSelectRef::ProductDefinitionUsage(i) => {
            if i.0 >= model.product_definition_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_USAGE",
                });
            }
        }
        PresentedItemSelectRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        PresentedItemSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_product_ref(model: &StepModel, r: &ProductRef) -> Result<(), AuthorError> {
    match r {
        ProductRef::Product(i) => {
            if i.0 >= model.product_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PRODUCT" });
            }
        }
        ProductRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_product_category_ref(
    model: &StepModel,
    r: &ProductCategoryRef,
) -> Result<(), AuthorError> {
    match r {
        ProductCategoryRef::ProductCategory(i) => {
            if i.0 >= model.product_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CATEGORY",
                });
            }
        }
        ProductCategoryRef::ProductRelatedProductCategory(i) => {
            if i.0 >= model.product_related_product_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_RELATED_PRODUCT_CATEGORY",
                });
            }
        }
        ProductCategoryRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_product_concept_ref(model: &StepModel, r: &ProductConceptRef) -> Result<(), AuthorError> {
    match r {
        ProductConceptRef::ProductConcept(i) => {
            if i.0 >= model.product_concept_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT",
                });
            }
        }
        ProductConceptRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_product_concept_context_ref(
    model: &StepModel,
    r: &ProductConceptContextRef,
) -> Result<(), AuthorError> {
    match r {
        ProductConceptContextRef::ProductConceptContext(i) => {
            if i.0 >= model.product_concept_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_CONTEXT",
                });
            }
        }
    }
    Ok(())
}
fn check_product_context_ref(model: &StepModel, r: &ProductContextRef) -> Result<(), AuthorError> {
    match r {
        ProductContextRef::MechanicalContext(i) => {
            if i.0 >= model.mechanical_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_CONTEXT",
                });
            }
        }
        ProductContextRef::ProductContext(i) => {
            if i.0 >= model.product_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONTEXT",
                });
            }
        }
        ProductContextRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_product_definition_ref(
    model: &StepModel,
    r: &ProductDefinitionRef,
) -> Result<(), AuthorError> {
    match r {
        ProductDefinitionRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        ProductDefinitionRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        ProductDefinitionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_product_definition_context_ref(
    model: &StepModel,
    r: &ProductDefinitionContextRef,
) -> Result<(), AuthorError> {
    match r {
        ProductDefinitionContextRef::DesignContext(i) => {
            if i.0 >= model.design_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESIGN_CONTEXT",
                });
            }
        }
        ProductDefinitionContextRef::ProductDefinitionContext(i) => {
            if i.0 >= model.product_definition_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_CONTEXT",
                });
            }
        }
        ProductDefinitionContextRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_product_definition_context_role_ref(
    model: &StepModel,
    r: &ProductDefinitionContextRoleRef,
) -> Result<(), AuthorError> {
    match r {
        ProductDefinitionContextRoleRef::ProductDefinitionContextRole(i) => {
            if i.0 >= model.product_definition_context_role_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_CONTEXT_ROLE",
                });
            }
        }
    }
    Ok(())
}
fn check_product_definition_formation_ref(
    model: &StepModel,
    r: &ProductDefinitionFormationRef,
) -> Result<(), AuthorError> {
    match r {
        ProductDefinitionFormationRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        ProductDefinitionFormationRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        ProductDefinitionFormationRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_product_definition_or_reference_ref(
    model: &StepModel,
    r: &ProductDefinitionOrReferenceRef,
) -> Result<(), AuthorError> {
    match r {
        ProductDefinitionOrReferenceRef::GenericProductDefinitionReference(i) => {
            if i.0 >= model.generic_product_definition_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERIC_PRODUCT_DEFINITION_REFERENCE",
                });
            }
        }
        ProductDefinitionOrReferenceRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        ProductDefinitionOrReferenceRef::ProductDefinitionOccurrence(i) => {
            if i.0 >= model.product_definition_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_OCCURRENCE",
                });
            }
        }
        ProductDefinitionOrReferenceRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        ProductDefinitionOrReferenceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_product_definition_relationship_ref(
    model: &StepModel,
    r: &ProductDefinitionRelationshipRef,
) -> Result<(), AuthorError> {
    match r {
        ProductDefinitionRelationshipRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        ProductDefinitionRelationshipRef::MakeFromUsageOption(i) => {
            if i.0 >= model.make_from_usage_option_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAKE_FROM_USAGE_OPTION",
                });
            }
        }
        ProductDefinitionRelationshipRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        ProductDefinitionRelationshipRef::ProductDefinitionRelationship(i) => {
            if i.0 >= model.product_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP",
                });
            }
        }
        ProductDefinitionRelationshipRef::ProductDefinitionUsage(i) => {
            if i.0 >= model.product_definition_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_USAGE",
                });
            }
        }
        ProductDefinitionRelationshipRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_product_definition_shape_ref(
    model: &StepModel,
    r: &ProductDefinitionShapeRef,
) -> Result<(), AuthorError> {
    match r {
        ProductDefinitionShapeRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        ProductDefinitionShapeRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_product_or_formation_or_definition_ref(
    model: &StepModel,
    r: &ProductOrFormationOrDefinitionRef,
) -> Result<(), AuthorError> {
    match r {
        ProductOrFormationOrDefinitionRef::Product(i) => {
            if i.0 >= model.product_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PRODUCT" });
            }
        }
        ProductOrFormationOrDefinitionRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        ProductOrFormationOrDefinitionRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        ProductOrFormationOrDefinitionRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        ProductOrFormationOrDefinitionRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        ProductOrFormationOrDefinitionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_property_definition_ref(
    model: &StepModel,
    r: &PropertyDefinitionRef,
) -> Result<(), AuthorError> {
    match r {
        PropertyDefinitionRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        PropertyDefinitionRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        PropertyDefinitionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_rendering_properties_select_ref(
    model: &StepModel,
    r: &RenderingPropertiesSelectRef,
) -> Result<(), AuthorError> {
    match r {
        RenderingPropertiesSelectRef::SurfaceStyleReflectanceAmbient(i) => {
            if i.0 >= model.surface_style_reflectance_ambient_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_STYLE_REFLECTANCE_AMBIENT",
                });
            }
        }
        RenderingPropertiesSelectRef::SurfaceStyleTransparent(i) => {
            if i.0 >= model.surface_style_transparent_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_STYLE_TRANSPARENT",
                });
            }
        }
        RenderingPropertiesSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_representation_ref(model: &StepModel, r: &RepresentationRef) -> Result<(), AuthorError> {
    match r {
        RepresentationRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        RepresentationRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        RepresentationRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        RepresentationRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        RepresentationRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        RepresentationRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        RepresentationRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        RepresentationRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        RepresentationRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        RepresentationRef::MechanicalDesignPresentationRepresentationWithDraughting(i) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        RepresentationRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        RepresentationRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        RepresentationRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        RepresentationRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        RepresentationRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        RepresentationRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        RepresentationRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        RepresentationRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        RepresentationRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        RepresentationRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        RepresentationRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_representation_context_ref(
    model: &StepModel,
    r: &RepresentationContextRef,
) -> Result<(), AuthorError> {
    match r {
        RepresentationContextRef::GeometricRepresentationContext(i) => {
            if i.0 >= model.geometric_representation_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_CONTEXT",
                });
            }
        }
        RepresentationContextRef::GlobalUncertaintyAssignedContext(i) => {
            if i.0 >= model.global_uncertainty_assigned_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT",
                });
            }
        }
        RepresentationContextRef::GlobalUnitAssignedContext(i) => {
            if i.0 >= model.global_unit_assigned_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GLOBAL_UNIT_ASSIGNED_CONTEXT",
                });
            }
        }
        RepresentationContextRef::ParametricRepresentationContext(i) => {
            if i.0 >= model.parametric_representation_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PARAMETRIC_REPRESENTATION_CONTEXT",
                });
            }
        }
        RepresentationContextRef::RepresentationContext(i) => {
            if i.0 >= model.representation_context_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_CONTEXT",
                });
            }
        }
        RepresentationContextRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_representation_context_reference_ref(
    model: &StepModel,
    r: &RepresentationContextReferenceRef,
) -> Result<(), AuthorError> {
    match r {
        RepresentationContextReferenceRef::RepresentationContextReference(i) => {
            if i.0 >= model.representation_context_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_CONTEXT_REFERENCE",
                });
            }
        }
    }
    Ok(())
}
fn check_representation_item_ref(
    model: &StepModel,
    r: &RepresentationItemRef,
) -> Result<(), AuthorError> {
    match r {
        RepresentationItemRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        RepresentationItemRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        RepresentationItemRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        RepresentationItemRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        RepresentationItemRef::AnnotationPlaceholderLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE",
            });
        }
        RepresentationItemRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        RepresentationItemRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        RepresentationItemRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        RepresentationItemRef::AnnotationSymbol(i) => {
            if i.0 >= model.annotation_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL",
                });
            }
        }
        RepresentationItemRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        RepresentationItemRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        RepresentationItemRef::AnnotationTextCharacter(i) => {
            if i.0 >= model.annotation_text_character_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_CHARACTER",
                });
            }
        }
        RepresentationItemRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        RepresentationItemRef::AnnotationToAnnotationLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE",
            });
        }
        RepresentationItemRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
        RepresentationItemRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        RepresentationItemRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        RepresentationItemRef::AuxiliaryLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "AUXILIARY_LEADER_LINE",
            });
        }
        RepresentationItemRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
        RepresentationItemRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        RepresentationItemRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
        RepresentationItemRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        RepresentationItemRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        RepresentationItemRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        RepresentationItemRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        RepresentationItemRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        RepresentationItemRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        RepresentationItemRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        RepresentationItemRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        RepresentationItemRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        RepresentationItemRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        RepresentationItemRef::BrepWithVoids(i) => {
            if i.0 >= model.brep_with_voids_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BREP_WITH_VOIDS",
                });
            }
        }
        RepresentationItemRef::CameraImage(i) => {
            if i.0 >= model.camera_image_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE",
                });
            }
        }
        RepresentationItemRef::CameraImage3dWithScale(i) => {
            if i.0 >= model.camera_image3d_with_scale_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE_3D_WITH_SCALE",
                });
            }
        }
        RepresentationItemRef::CameraModel(i) => {
            if i.0 >= model.camera_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL",
                });
            }
        }
        RepresentationItemRef::CameraModelD3(i) => {
            if i.0 >= model.camera_model_d3_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3",
                });
            }
        }
        RepresentationItemRef::CameraModelD3MultiClipping(i) => {
            if i.0 >= model.camera_model_d3_multi_clipping_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                });
            }
        }
        RepresentationItemRef::CameraModelD3WithHlhsr(i) => {
            if i.0 >= model.camera_model_d3_with_hlhsr_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_WITH_HLHSR",
                });
            }
        }
        RepresentationItemRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        RepresentationItemRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        RepresentationItemRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        RepresentationItemRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        RepresentationItemRef::ComplexTriangulatedSurfaceSet(i) => {
            if i.0 >= model.complex_triangulated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_SURFACE_SET",
                });
            }
        }
        RepresentationItemRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        RepresentationItemRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        RepresentationItemRef::CompoundRepresentationItem(i) => {
            if i.0 >= model.compound_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOUND_REPRESENTATION_ITEM",
                });
            }
        }
        RepresentationItemRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        RepresentationItemRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        RepresentationItemRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        RepresentationItemRef::ContextDependentOverRidingStyledItem(i) => {
            if i.0
                >= model
                    .context_dependent_over_riding_styled_item_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        RepresentationItemRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
        RepresentationItemRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        RepresentationItemRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        RepresentationItemRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        RepresentationItemRef::DefinedSymbol(i) => {
            if i.0 >= model.defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_SYMBOL",
                });
            }
        }
        RepresentationItemRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        RepresentationItemRef::DescriptiveRepresentationItem(i) => {
            if i.0 >= model.descriptive_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESCRIPTIVE_REPRESENTATION_ITEM",
                });
            }
        }
        RepresentationItemRef::Direction(i) => {
            if i.0 >= model.direction_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTION",
                });
            }
        }
        RepresentationItemRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        RepresentationItemRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        RepresentationItemRef::Edge(i) => {
            if i.0 >= model.edge_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "EDGE" });
            }
        }
        RepresentationItemRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        RepresentationItemRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        RepresentationItemRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        RepresentationItemRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        RepresentationItemRef::ExternallyDefinedHatchStyle(i) => {
            if i.0 >= model.externally_defined_hatch_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_HATCH_STYLE",
                });
            }
        }
        RepresentationItemRef::ExternallyDefinedTileStyle(i) => {
            if i.0 >= model.externally_defined_tile_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE_STYLE",
                });
            }
        }
        RepresentationItemRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        RepresentationItemRef::FaceBound(i) => {
            if i.0 >= model.face_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_BOUND",
                });
            }
        }
        RepresentationItemRef::FaceOuterBound(i) => {
            if i.0 >= model.face_outer_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_OUTER_BOUND",
                });
            }
        }
        RepresentationItemRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        RepresentationItemRef::FillAreaStyleHatching(i) => {
            if i.0 >= model.fill_area_style_hatching_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_HATCHING",
                });
            }
        }
        RepresentationItemRef::FillAreaStyleTileColouredRegion(i) => {
            if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION",
                });
            }
        }
        RepresentationItemRef::FillAreaStyleTileCurveWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_curve_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE",
                });
            }
        }
        RepresentationItemRef::FillAreaStyleTileSymbolWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_symbol_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
                });
            }
        }
        RepresentationItemRef::FillAreaStyleTiles(i) => {
            if i.0 >= model.fill_area_style_tiles_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILES",
                });
            }
        }
        RepresentationItemRef::GeometricCurveSet(i) => {
            if i.0 >= model.geometric_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_CURVE_SET",
                });
            }
        }
        RepresentationItemRef::GeometricRepresentationItem(i) => {
            if i.0 >= model.geometric_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_ITEM",
                });
            }
        }
        RepresentationItemRef::GeometricSet(i) => {
            if i.0 >= model.geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_SET",
                });
            }
        }
        RepresentationItemRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        RepresentationItemRef::IntegerRepresentationItem(i) => {
            if i.0 >= model.integer_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTEGER_REPRESENTATION_ITEM",
                });
            }
        }
        RepresentationItemRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        RepresentationItemRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        RepresentationItemRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        RepresentationItemRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        RepresentationItemRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        RepresentationItemRef::Loop(i) => {
            if i.0 >= model.loop_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LOOP" });
            }
        }
        RepresentationItemRef::ManifoldSolidBrep(i) => {
            if i.0 >= model.manifold_solid_brep_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SOLID_BREP",
                });
            }
        }
        RepresentationItemRef::MappedItem(i) => {
            if i.0 >= model.mapped_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAPPED_ITEM",
                });
            }
        }
        RepresentationItemRef::MeasureRepresentationItem(i) => {
            if i.0 >= model.measure_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_REPRESENTATION_ITEM",
                });
            }
        }
        RepresentationItemRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        RepresentationItemRef::OneDirectionRepeatFactor(i) => {
            if i.0 >= model.one_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ONE_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        RepresentationItemRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        RepresentationItemRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        RepresentationItemRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        RepresentationItemRef::OverRidingStyledItem(i) => {
            if i.0 >= model.over_riding_styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        RepresentationItemRef::Path(i) => {
            if i.0 >= model.path_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PATH" });
            }
        }
        RepresentationItemRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        RepresentationItemRef::Placement(i) => {
            if i.0 >= model.placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACEMENT",
                });
            }
        }
        RepresentationItemRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        RepresentationItemRef::PlanarExtent(i) => {
            if i.0 >= model.planar_extent_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_EXTENT",
                });
            }
        }
        RepresentationItemRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        RepresentationItemRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        RepresentationItemRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        RepresentationItemRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        RepresentationItemRef::QualifiedRepresentationItem(i) => {
            if i.0 >= model.qualified_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUALIFIED_REPRESENTATION_ITEM",
                });
            }
        }
        RepresentationItemRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        RepresentationItemRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        RepresentationItemRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        RepresentationItemRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        RepresentationItemRef::RealRepresentationItem(i) => {
            if i.0 >= model.real_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REAL_REPRESENTATION_ITEM",
                });
            }
        }
        RepresentationItemRef::RepositionedTessellatedItem(i) => {
            if i.0 >= model.repositioned_tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPOSITIONED_TESSELLATED_ITEM",
                });
            }
        }
        RepresentationItemRef::RepresentationItem(i) => {
            if i.0 >= model.representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_ITEM",
                });
            }
        }
        RepresentationItemRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        RepresentationItemRef::ShellBasedSurfaceModel(i) => {
            if i.0 >= model.shell_based_surface_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHELL_BASED_SURFACE_MODEL",
                });
            }
        }
        RepresentationItemRef::SolidModel(i) => {
            if i.0 >= model.solid_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_MODEL",
                });
            }
        }
        RepresentationItemRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        RepresentationItemRef::StyledItem(i) => {
            if i.0 >= model.styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STYLED_ITEM",
                });
            }
        }
        RepresentationItemRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        RepresentationItemRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        RepresentationItemRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        RepresentationItemRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        RepresentationItemRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        RepresentationItemRef::SymbolTarget(i) => {
            if i.0 >= model.symbol_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_TARGET",
                });
            }
        }
        RepresentationItemRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        RepresentationItemRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        RepresentationItemRef::TessellatedCurveSet(i) => {
            if i.0 >= model.tessellated_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_CURVE_SET",
                });
            }
        }
        RepresentationItemRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        RepresentationItemRef::TessellatedGeometricSet(i) => {
            if i.0 >= model.tessellated_geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                });
            }
        }
        RepresentationItemRef::TessellatedItem(i) => {
            if i.0 >= model.tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ITEM",
                });
            }
        }
        RepresentationItemRef::TessellatedShell(i) => {
            if i.0 >= model.tessellated_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHELL",
                });
            }
        }
        RepresentationItemRef::TessellatedSolid(i) => {
            if i.0 >= model.tessellated_solid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SOLID",
                });
            }
        }
        RepresentationItemRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        RepresentationItemRef::TessellatedSurfaceSet(i) => {
            if i.0 >= model.tessellated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SURFACE_SET",
                });
            }
        }
        RepresentationItemRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        RepresentationItemRef::TopologicalRepresentationItem(i) => {
            if i.0 >= model.topological_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOPOLOGICAL_REPRESENTATION_ITEM",
                });
            }
        }
        RepresentationItemRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        RepresentationItemRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        RepresentationItemRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        RepresentationItemRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        RepresentationItemRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        RepresentationItemRef::ValueRepresentationItem(i) => {
            if i.0 >= model.value_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VALUE_REPRESENTATION_ITEM",
                });
            }
        }
        RepresentationItemRef::Vector(i) => {
            if i.0 >= model.vector_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VECTOR" });
            }
        }
        RepresentationItemRef::Vertex(i) => {
            if i.0 >= model.vertex_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VERTEX" });
            }
        }
        RepresentationItemRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
        RepresentationItemRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        RepresentationItemRef::VertexShell(i) => {
            if i.0 >= model.vertex_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_SHELL",
                });
            }
        }
        RepresentationItemRef::WireShell(i) => {
            if i.0 >= model.wire_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "WIRE_SHELL",
                });
            }
        }
        RepresentationItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_representation_map_ref(
    model: &StepModel,
    r: &RepresentationMapRef,
) -> Result<(), AuthorError> {
    match r {
        RepresentationMapRef::CameraUsage(i) => {
            if i.0 >= model.camera_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_USAGE",
                });
            }
        }
        RepresentationMapRef::RepresentationMap(i) => {
            if i.0 >= model.representation_map_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_MAP",
                });
            }
        }
        RepresentationMapRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_representation_or_representation_reference_ref(
    model: &StepModel,
    r: &RepresentationOrRepresentationReferenceRef,
) -> Result<(), AuthorError> {
    match r {
        RepresentationOrRepresentationReferenceRef::AdvancedBrepShapeRepresentation(i) => { if i.0 >= model.advanced_brep_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "ADVANCED_BREP_SHAPE_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::CharacterizedRepresentation(i) => { if i.0 >= model.characterized_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CHARACTERIZED_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::ConstructiveGeometryRepresentation(i) => { if i.0 >= model.constructive_geometry_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::DefinitionalRepresentation(i) => { if i.0 >= model.definitional_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "DEFINITIONAL_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::DraughtingModel(i) => { if i.0 >= model.draughting_model_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "DRAUGHTING_MODEL" }); } }
        RepresentationOrRepresentationReferenceRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => { if i.0 >= model.geometrically_bounded_surface_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::GeometricallyBoundedWireframeShapeRepresentation(i) => { if i.0 >= model.geometrically_bounded_wireframe_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::ManifoldSurfaceShapeRepresentation(i) => { if i.0 >= model.manifold_surface_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::MechanicalDesignGeometricPresentationRepresentation(i) => { if i.0 >= model.mechanical_design_geometric_presentation_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::MechanicalDesignPresentationRepresentationWithDraughting(i) => { if i.0 >= model.mechanical_design_presentation_representation_with_draughting_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING" }); } }
        RepresentationOrRepresentationReferenceRef::MechanicalDesignShadedPresentationRepresentation(i) => { if i.0 >= model.mechanical_design_shaded_presentation_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::PresentationArea(i) => { if i.0 >= model.presentation_area_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "PRESENTATION_AREA" }); } }
        RepresentationOrRepresentationReferenceRef::PresentationRepresentation(i) => { if i.0 >= model.presentation_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "PRESENTATION_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::PresentationView(i) => { if i.0 >= model.presentation_view_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "PRESENTATION_VIEW" }); } }
        RepresentationOrRepresentationReferenceRef::Representation(i) => { if i.0 >= model.representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::RepresentationReference(i) => { if i.0 >= model.representation_reference_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "REPRESENTATION_REFERENCE" }); } }
        RepresentationOrRepresentationReferenceRef::ShapeDimensionRepresentation(i) => { if i.0 >= model.shape_dimension_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SHAPE_DIMENSION_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::ShapeRepresentation(i) => { if i.0 >= model.shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SHAPE_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::ShapeRepresentationWithParameters(i) => { if i.0 >= model.shape_representation_with_parameters_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS" }); } }
        RepresentationOrRepresentationReferenceRef::SymbolRepresentation(i) => { if i.0 >= model.symbol_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "SYMBOL_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::TessellatedShapeRepresentation(i) => { if i.0 >= model.tessellated_shape_representation_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "TESSELLATED_SHAPE_REPRESENTATION" }); } }
        RepresentationOrRepresentationReferenceRef::Complex(i) => { if i.0 >= model.complex_unit_arena.items.len() { return Err(AuthorError::DanglingRef { entity: "COMPLEX" }); } }
    }
    Ok(())
}
fn check_represented_definition_ref(
    model: &StepModel,
    r: &RepresentedDefinitionRef,
) -> Result<(), AuthorError> {
    match r {
        RepresentedDefinitionRef::AllAroundShapeAspect(i) => {
            if i.0 >= model.all_around_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ALL_AROUND_SHAPE_ASPECT",
                });
            }
        }
        RepresentedDefinitionRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        RepresentedDefinitionRef::CentreOfSymmetry(i) => {
            if i.0 >= model.centre_of_symmetry_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CENTRE_OF_SYMMETRY",
                });
            }
        }
        RepresentedDefinitionRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        RepresentedDefinitionRef::CompositeGroupShapeAspect(i) => {
            if i.0 >= model.composite_group_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_GROUP_SHAPE_ASPECT",
                });
            }
        }
        RepresentedDefinitionRef::CompositeShapeAspect(i) => {
            if i.0 >= model.composite_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_SHAPE_ASPECT",
                });
            }
        }
        RepresentedDefinitionRef::ContinuousShapeAspect(i) => {
            if i.0 >= model.continuous_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTINUOUS_SHAPE_ASPECT",
                });
            }
        }
        RepresentedDefinitionRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        RepresentedDefinitionRef::DatumFeature(i) => {
            if i.0 >= model.datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_FEATURE",
                });
            }
        }
        RepresentedDefinitionRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
        RepresentedDefinitionRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        RepresentedDefinitionRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        RepresentedDefinitionRef::DatumTarget(i) => {
            if i.0 >= model.datum_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_TARGET",
                });
            }
        }
        RepresentedDefinitionRef::DefaultModelGeometricView(i) => {
            if i.0 >= model.default_model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFAULT_MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        RepresentedDefinitionRef::DerivedShapeAspect(i) => {
            if i.0 >= model.derived_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_SHAPE_ASPECT",
                });
            }
        }
        RepresentedDefinitionRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        RepresentedDefinitionRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        RepresentedDefinitionRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        RepresentedDefinitionRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        RepresentedDefinitionRef::FeatureForDatumTargetRelationship(i) => {
            if i.0
                >= model
                    .feature_for_datum_target_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FEATURE_FOR_DATUM_TARGET_RELATIONSHIP",
                });
            }
        }
        RepresentedDefinitionRef::GeneralDatumReference(i) => {
            if i.0 >= model.general_datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_DATUM_REFERENCE",
                });
            }
        }
        RepresentedDefinitionRef::GeneralProperty(i) => {
            if i.0 >= model.general_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_PROPERTY",
                });
            }
        }
        RepresentedDefinitionRef::PlacedDatumTargetFeature(i) => {
            if i.0 >= model.placed_datum_target_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACED_DATUM_TARGET_FEATURE",
                });
            }
        }
        RepresentedDefinitionRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        RepresentedDefinitionRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        RepresentedDefinitionRef::PropertyDefinitionRelationship(i) => {
            if i.0 >= model.property_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION_RELATIONSHIP",
                });
            }
        }
        RepresentedDefinitionRef::ShapeAspect(i) => {
            if i.0 >= model.shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT",
                });
            }
        }
        RepresentedDefinitionRef::ShapeAspectAssociativity(i) => {
            if i.0 >= model.shape_aspect_associativity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_ASSOCIATIVITY",
                });
            }
        }
        RepresentedDefinitionRef::ShapeAspectDerivingRelationship(i) => {
            if i.0 >= model.shape_aspect_deriving_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_DERIVING_RELATIONSHIP",
                });
            }
        }
        RepresentedDefinitionRef::ShapeAspectRelationship(i) => {
            if i.0 >= model.shape_aspect_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT_RELATIONSHIP",
                });
            }
        }
        RepresentedDefinitionRef::ToleranceZone(i) => {
            if i.0 >= model.tolerance_zone_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE",
                });
            }
        }
        RepresentedDefinitionRef::ToleranceZoneWithDatum(i) => {
            if i.0 >= model.tolerance_zone_with_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                });
            }
        }
        RepresentedDefinitionRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_resource_requirement_type_ref(
    model: &StepModel,
    r: &ResourceRequirementTypeRef,
) -> Result<(), AuthorError> {
    match r {
        ResourceRequirementTypeRef::ResourceRequirementType(i) => {
            if i.0 >= model.resource_requirement_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RESOURCE_REQUIREMENT_TYPE",
                });
            }
        }
    }
    Ok(())
}
fn check_role_select_ref(model: &StepModel, r: &RoleSelectRef) -> Result<(), AuthorError> {
    match r {
        RoleSelectRef::ActionAssignment(i) => {
            if i.0 >= model.action_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_ASSIGNMENT",
                });
            }
        }
        RoleSelectRef::ActionRequestAssignment(i) => {
            if i.0 >= model.action_request_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_REQUEST_ASSIGNMENT",
                });
            }
        }
        RoleSelectRef::AppliedApprovalAssignment(i) => {
            if i.0 >= model.applied_approval_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_APPROVAL_ASSIGNMENT",
                });
            }
        }
        RoleSelectRef::AppliedDocumentReference(i) => {
            if i.0 >= model.applied_document_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DOCUMENT_REFERENCE",
                });
            }
        }
        RoleSelectRef::AppliedGroupAssignment(i) => {
            if i.0 >= model.applied_group_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_GROUP_ASSIGNMENT",
                });
            }
        }
        RoleSelectRef::AppliedSecurityClassificationAssignment(i) => {
            if i.0
                >= model
                    .applied_security_classification_assignment_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_SECURITY_CLASSIFICATION_ASSIGNMENT",
                });
            }
        }
        RoleSelectRef::ApprovalAssignment(i) => {
            if i.0 >= model.approval_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_ASSIGNMENT",
                });
            }
        }
        RoleSelectRef::ApprovalDateTime(i) => {
            if i.0 >= model.approval_date_time_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPROVAL_DATE_TIME",
                });
            }
        }
        RoleSelectRef::CcDesignApproval(i) => {
            if i.0 >= model.cc_design_approval_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CC_DESIGN_APPROVAL",
                });
            }
        }
        RoleSelectRef::CcDesignSecurityClassification(i) => {
            if i.0 >= model.cc_design_security_classification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CC_DESIGN_SECURITY_CLASSIFICATION",
                });
            }
        }
        RoleSelectRef::Change(i) => {
            if i.0 >= model.change_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CHANGE" });
            }
        }
        RoleSelectRef::ChangeRequest(i) => {
            if i.0 >= model.change_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHANGE_REQUEST",
                });
            }
        }
        RoleSelectRef::DocumentReference(i) => {
            if i.0 >= model.document_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_REFERENCE",
                });
            }
        }
        RoleSelectRef::GroupAssignment(i) => {
            if i.0 >= model.group_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GROUP_ASSIGNMENT",
                });
            }
        }
        RoleSelectRef::SecurityClassificationAssignment(i) => {
            if i.0 >= model.security_classification_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION_ASSIGNMENT",
                });
            }
        }
        RoleSelectRef::StartRequest(i) => {
            if i.0 >= model.start_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "START_REQUEST",
                });
            }
        }
        RoleSelectRef::StartWork(i) => {
            if i.0 >= model.start_work_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "START_WORK",
                });
            }
        }
        RoleSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_security_classification_ref(
    model: &StepModel,
    r: &SecurityClassificationRef,
) -> Result<(), AuthorError> {
    match r {
        SecurityClassificationRef::SecurityClassification(i) => {
            if i.0 >= model.security_classification_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION",
                });
            }
        }
    }
    Ok(())
}
fn check_security_classification_item_ref(
    model: &StepModel,
    r: &SecurityClassificationItemRef,
) -> Result<(), AuthorError> {
    match r {
        SecurityClassificationItemRef::Action(i) => {
            if i.0 >= model.action_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ACTION" });
            }
        }
        SecurityClassificationItemRef::ActionDirective(i) => {
            if i.0 >= model.action_directive_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_DIRECTIVE",
                });
            }
        }
        SecurityClassificationItemRef::ActionMethod(i) => {
            if i.0 >= model.action_method_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD",
                });
            }
        }
        SecurityClassificationItemRef::ActionMethodRelationship(i) => {
            if i.0 >= model.action_method_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD_RELATIONSHIP",
                });
            }
        }
        SecurityClassificationItemRef::ActionProperty(i) => {
            if i.0 >= model.action_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_PROPERTY",
                });
            }
        }
        SecurityClassificationItemRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::AppliedDocumentReference(i) => {
            if i.0 >= model.applied_document_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_DOCUMENT_REFERENCE",
                });
            }
        }
        SecurityClassificationItemRef::AppliedExternalIdentificationAssignment(i) => {
            if i.0
                >= model
                    .applied_external_identification_assignment_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT",
                });
            }
        }
        SecurityClassificationItemRef::AssemblyComponentUsage(i) => {
            if i.0 >= model.assembly_component_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ASSEMBLY_COMPONENT_USAGE",
                });
            }
        }
        SecurityClassificationItemRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::ConfigurationDesign(i) => {
            if i.0 >= model.configuration_design_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_DESIGN",
                });
            }
        }
        SecurityClassificationItemRef::ConfigurationEffectivity(i) => {
            if i.0 >= model.configuration_effectivity_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONFIGURATION_EFFECTIVITY",
                });
            }
        }
        SecurityClassificationItemRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::Document(i) => {
            if i.0 >= model.document_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DOCUMENT" });
            }
        }
        SecurityClassificationItemRef::DocumentFile(i) => {
            if i.0 >= model.document_file_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DOCUMENT_FILE",
                });
            }
        }
        SecurityClassificationItemRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        SecurityClassificationItemRef::GeneralProperty(i) => {
            if i.0 >= model.general_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_PROPERTY",
                });
            }
        }
        SecurityClassificationItemRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::Group(i) => {
            if i.0 >= model.group_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "GROUP" });
            }
        }
        SecurityClassificationItemRef::MakeFromUsageOption(i) => {
            if i.0 >= model.make_from_usage_option_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAKE_FROM_USAGE_OPTION",
                });
            }
        }
        SecurityClassificationItemRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::MechanicalDesignPresentationRepresentationWithDraughting(
            i,
        ) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        SecurityClassificationItemRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::NextAssemblyUsageOccurrence(i) => {
            if i.0 >= model.next_assembly_usage_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NEXT_ASSEMBLY_USAGE_OCCURRENCE",
                });
            }
        }
        SecurityClassificationItemRef::OrganizationalProject(i) => {
            if i.0 >= model.organizational_project_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORGANIZATIONAL_PROJECT",
                });
            }
        }
        SecurityClassificationItemRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        SecurityClassificationItemRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        SecurityClassificationItemRef::Product(i) => {
            if i.0 >= model.product_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PRODUCT" });
            }
        }
        SecurityClassificationItemRef::ProductConcept(i) => {
            if i.0 >= model.product_concept_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT",
                });
            }
        }
        SecurityClassificationItemRef::ProductConceptFeature(i) => {
            if i.0 >= model.product_concept_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE",
                });
            }
        }
        SecurityClassificationItemRef::ProductConceptFeatureCategory(i) => {
            if i.0 >= model.product_concept_feature_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE_CATEGORY",
                });
            }
        }
        SecurityClassificationItemRef::ProductDefinition(i) => {
            if i.0 >= model.product_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION",
                });
            }
        }
        SecurityClassificationItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        SecurityClassificationItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        SecurityClassificationItemRef::ProductDefinitionRelationship(i) => {
            if i.0 >= model.product_definition_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_RELATIONSHIP",
                });
            }
        }
        SecurityClassificationItemRef::ProductDefinitionShape(i) => {
            if i.0 >= model.product_definition_shape_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_SHAPE",
                });
            }
        }
        SecurityClassificationItemRef::ProductDefinitionUsage(i) => {
            if i.0 >= model.product_definition_usage_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_USAGE",
                });
            }
        }
        SecurityClassificationItemRef::ProductDefinitionWithAssociatedDocuments(i) => {
            if i.0
                >= model
                    .product_definition_with_associated_documents_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS",
                });
            }
        }
        SecurityClassificationItemRef::PropertyDefinition(i) => {
            if i.0 >= model.property_definition_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION",
                });
            }
        }
        SecurityClassificationItemRef::PropertyDefinitionRepresentation(i) => {
            if i.0 >= model.property_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PROPERTY_DEFINITION_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::ResourceProperty(i) => {
            if i.0 >= model.resource_property_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RESOURCE_PROPERTY",
                });
            }
        }
        SecurityClassificationItemRef::ShapeDefinitionRepresentation(i) => {
            if i.0 >= model.shape_definition_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DEFINITION_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        SecurityClassificationItemRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        SecurityClassificationItemRef::VersionedActionRequest(i) => {
            if i.0 >= model.versioned_action_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERSIONED_ACTION_REQUEST",
                });
            }
        }
        SecurityClassificationItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_security_classification_level_ref(
    model: &StepModel,
    r: &SecurityClassificationLevelRef,
) -> Result<(), AuthorError> {
    match r {
        SecurityClassificationLevelRef::SecurityClassificationLevel(i) => {
            if i.0 >= model.security_classification_level_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SECURITY_CLASSIFICATION_LEVEL",
                });
            }
        }
    }
    Ok(())
}
fn check_shape_aspect_ref(model: &StepModel, r: &ShapeAspectRef) -> Result<(), AuthorError> {
    match r {
        ShapeAspectRef::AllAroundShapeAspect(i) => {
            if i.0 >= model.all_around_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ALL_AROUND_SHAPE_ASPECT",
                });
            }
        }
        ShapeAspectRef::CentreOfSymmetry(i) => {
            if i.0 >= model.centre_of_symmetry_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CENTRE_OF_SYMMETRY",
                });
            }
        }
        ShapeAspectRef::CommonDatum(i) => {
            if i.0 >= model.common_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMMON_DATUM",
                });
            }
        }
        ShapeAspectRef::CompositeGroupShapeAspect(i) => {
            if i.0 >= model.composite_group_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_GROUP_SHAPE_ASPECT",
                });
            }
        }
        ShapeAspectRef::CompositeShapeAspect(i) => {
            if i.0 >= model.composite_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_SHAPE_ASPECT",
                });
            }
        }
        ShapeAspectRef::ContinuousShapeAspect(i) => {
            if i.0 >= model.continuous_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTINUOUS_SHAPE_ASPECT",
                });
            }
        }
        ShapeAspectRef::Datum(i) => {
            if i.0 >= model.datum_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "DATUM" });
            }
        }
        ShapeAspectRef::DatumFeature(i) => {
            if i.0 >= model.datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_FEATURE",
                });
            }
        }
        ShapeAspectRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
        ShapeAspectRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        ShapeAspectRef::DatumSystem(i) => {
            if i.0 >= model.datum_system_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_SYSTEM",
                });
            }
        }
        ShapeAspectRef::DatumTarget(i) => {
            if i.0 >= model.datum_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_TARGET",
                });
            }
        }
        ShapeAspectRef::DefaultModelGeometricView(i) => {
            if i.0 >= model.default_model_geometric_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFAULT_MODEL_GEOMETRIC_VIEW",
                });
            }
        }
        ShapeAspectRef::DerivedShapeAspect(i) => {
            if i.0 >= model.derived_shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_SHAPE_ASPECT",
                });
            }
        }
        ShapeAspectRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        ShapeAspectRef::GeneralDatumReference(i) => {
            if i.0 >= model.general_datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_DATUM_REFERENCE",
                });
            }
        }
        ShapeAspectRef::PlacedDatumTargetFeature(i) => {
            if i.0 >= model.placed_datum_target_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACED_DATUM_TARGET_FEATURE",
                });
            }
        }
        ShapeAspectRef::ShapeAspect(i) => {
            if i.0 >= model.shape_aspect_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_ASPECT",
                });
            }
        }
        ShapeAspectRef::ToleranceZone(i) => {
            if i.0 >= model.tolerance_zone_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE",
                });
            }
        }
        ShapeAspectRef::ToleranceZoneWithDatum(i) => {
            if i.0 >= model.tolerance_zone_with_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                });
            }
        }
        ShapeAspectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_shape_dimension_representation_ref(
    model: &StepModel,
    r: &ShapeDimensionRepresentationRef,
) -> Result<(), AuthorError> {
    match r {
        ShapeDimensionRepresentationRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        ShapeDimensionRepresentationRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_shape_model_ref(model: &StepModel, r: &ShapeModelRef) -> Result<(), AuthorError> {
    match r {
        ShapeModelRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        ShapeModelRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        ShapeModelRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        ShapeModelRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        ShapeModelRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        ShapeModelRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        ShapeModelRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        ShapeModelRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        ShapeModelRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        ShapeModelRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_shape_representation_relationship_ref(
    model: &StepModel,
    r: &ShapeRepresentationRelationshipRef,
) -> Result<(), AuthorError> {
    match r {
        ShapeRepresentationRelationshipRef::ShapeRepresentationRelationship(i) => {
            if i.0 >= model.shape_representation_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        ShapeRepresentationRelationshipRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_shell_ref(model: &StepModel, r: &ShellRef) -> Result<(), AuthorError> {
    match r {
        ShellRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        ShellRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        ShellRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        ShellRef::VertexShell(i) => {
            if i.0 >= model.vertex_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_SHELL",
                });
            }
        }
        ShellRef::WireShell(i) => {
            if i.0 >= model.wire_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "WIRE_SHELL",
                });
            }
        }
        ShellRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_size_select_ref(model: &StepModel, r: &SizeSelectRef) -> Result<(), AuthorError> {
    match r {
        SizeSelectRef::LengthMeasureWithUnit(i) => {
            if i.0 >= model.length_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LENGTH_MEASURE_WITH_UNIT",
                });
            }
        }
        SizeSelectRef::MassMeasureWithUnit(i) => {
            if i.0 >= model.mass_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MASS_MEASURE_WITH_UNIT",
                });
            }
        }
        SizeSelectRef::MeasureRepresentationItem(i) => {
            if i.0 >= model.measure_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_REPRESENTATION_ITEM",
                });
            }
        }
        SizeSelectRef::MeasureWithUnit(i) => {
            if i.0 >= model.measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_WITH_UNIT",
                });
            }
        }
        SizeSelectRef::PlaneAngleMeasureWithUnit(i) => {
            if i.0 >= model.plane_angle_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANE_ANGLE_MEASURE_WITH_UNIT",
                });
            }
        }
        SizeSelectRef::RatioMeasureWithUnit(i) => {
            if i.0 >= model.ratio_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIO_MEASURE_WITH_UNIT",
                });
            }
        }
        SizeSelectRef::UncertaintyMeasureWithUnit(i) => {
            if i.0 >= model.uncertainty_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNCERTAINTY_MEASURE_WITH_UNIT",
                });
            }
        }
        SizeSelectRef::DescriptiveMeasure(_) => {}
        SizeSelectRef::PositiveLengthMeasure(_) => {}
        SizeSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_start_request_item_ref(
    model: &StepModel,
    r: &StartRequestItemRef,
) -> Result<(), AuthorError> {
    match r {
        StartRequestItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        StartRequestItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        StartRequestItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_state_observed_ref(model: &StepModel, r: &StateObservedRef) -> Result<(), AuthorError> {
    match r {
        StateObservedRef::StateObserved(i) => {
            if i.0 >= model.state_observed_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_OBSERVED",
                });
            }
        }
        StateObservedRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_state_type_ref(model: &StepModel, r: &StateTypeRef) -> Result<(), AuthorError> {
    match r {
        StateTypeRef::StateType(i) => {
            if i.0 >= model.state_type_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STATE_TYPE",
                });
            }
        }
        StateTypeRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_style_context_select_ref(
    model: &StepModel,
    r: &StyleContextSelectRef,
) -> Result<(), AuthorError> {
    match r {
        StyleContextSelectRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        StyleContextSelectRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        StyleContextSelectRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        StyleContextSelectRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        StyleContextSelectRef::AnnotationPlaceholderLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE",
            });
        }
        StyleContextSelectRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        StyleContextSelectRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        StyleContextSelectRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        StyleContextSelectRef::AnnotationSymbol(i) => {
            if i.0 >= model.annotation_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL",
                });
            }
        }
        StyleContextSelectRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        StyleContextSelectRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        StyleContextSelectRef::AnnotationTextCharacter(i) => {
            if i.0 >= model.annotation_text_character_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_CHARACTER",
                });
            }
        }
        StyleContextSelectRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        StyleContextSelectRef::AnnotationToAnnotationLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE",
            });
        }
        StyleContextSelectRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
        StyleContextSelectRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        StyleContextSelectRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        StyleContextSelectRef::AuxiliaryLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "AUXILIARY_LEADER_LINE",
            });
        }
        StyleContextSelectRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
        StyleContextSelectRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        StyleContextSelectRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
        StyleContextSelectRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        StyleContextSelectRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        StyleContextSelectRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        StyleContextSelectRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        StyleContextSelectRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        StyleContextSelectRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        StyleContextSelectRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        StyleContextSelectRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        StyleContextSelectRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        StyleContextSelectRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        StyleContextSelectRef::BrepWithVoids(i) => {
            if i.0 >= model.brep_with_voids_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BREP_WITH_VOIDS",
                });
            }
        }
        StyleContextSelectRef::CameraImage(i) => {
            if i.0 >= model.camera_image_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE",
                });
            }
        }
        StyleContextSelectRef::CameraImage3dWithScale(i) => {
            if i.0 >= model.camera_image3d_with_scale_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE_3D_WITH_SCALE",
                });
            }
        }
        StyleContextSelectRef::CameraModel(i) => {
            if i.0 >= model.camera_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL",
                });
            }
        }
        StyleContextSelectRef::CameraModelD3(i) => {
            if i.0 >= model.camera_model_d3_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3",
                });
            }
        }
        StyleContextSelectRef::CameraModelD3MultiClipping(i) => {
            if i.0 >= model.camera_model_d3_multi_clipping_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                });
            }
        }
        StyleContextSelectRef::CameraModelD3WithHlhsr(i) => {
            if i.0 >= model.camera_model_d3_with_hlhsr_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_WITH_HLHSR",
                });
            }
        }
        StyleContextSelectRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        StyleContextSelectRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        StyleContextSelectRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        StyleContextSelectRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        StyleContextSelectRef::ComplexTriangulatedSurfaceSet(i) => {
            if i.0 >= model.complex_triangulated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_SURFACE_SET",
                });
            }
        }
        StyleContextSelectRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        StyleContextSelectRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        StyleContextSelectRef::CompoundRepresentationItem(i) => {
            if i.0 >= model.compound_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOUND_REPRESENTATION_ITEM",
                });
            }
        }
        StyleContextSelectRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        StyleContextSelectRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        StyleContextSelectRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        StyleContextSelectRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::ConstructiveGeometryRepresentationRelationship(i) => {
            if i.0
                >= model
                    .constructive_geometry_representation_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        StyleContextSelectRef::ContextDependentOverRidingStyledItem(i) => {
            if i.0
                >= model
                    .context_dependent_over_riding_styled_item_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        StyleContextSelectRef::ContextDependentShapeRepresentation(i) => {
            if i.0
                >= model
                    .context_dependent_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_SHAPE_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
        StyleContextSelectRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        StyleContextSelectRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        StyleContextSelectRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        StyleContextSelectRef::DefinedSymbol(i) => {
            if i.0 >= model.defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_SYMBOL",
                });
            }
        }
        StyleContextSelectRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::DefinitionalRepresentationRelationship(i) => {
            if i.0
                >= model
                    .definitional_representation_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        StyleContextSelectRef::DefinitionalRepresentationRelationshipWithSameContext(i) => {
            if i.0
                >= model
                    .definitional_representation_relationship_with_same_context_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION_RELATIONSHIP_WITH_SAME_CONTEXT",
                });
            }
        }
        StyleContextSelectRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        StyleContextSelectRef::DescriptiveRepresentationItem(i) => {
            if i.0 >= model.descriptive_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DESCRIPTIVE_REPRESENTATION_ITEM",
                });
            }
        }
        StyleContextSelectRef::Direction(i) => {
            if i.0 >= model.direction_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTION",
                });
            }
        }
        StyleContextSelectRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        StyleContextSelectRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        StyleContextSelectRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        StyleContextSelectRef::Edge(i) => {
            if i.0 >= model.edge_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "EDGE" });
            }
        }
        StyleContextSelectRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        StyleContextSelectRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        StyleContextSelectRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        StyleContextSelectRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        StyleContextSelectRef::ExternallyDefinedHatchStyle(i) => {
            if i.0 >= model.externally_defined_hatch_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_HATCH_STYLE",
                });
            }
        }
        StyleContextSelectRef::ExternallyDefinedTileStyle(i) => {
            if i.0 >= model.externally_defined_tile_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE_STYLE",
                });
            }
        }
        StyleContextSelectRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        StyleContextSelectRef::FaceBound(i) => {
            if i.0 >= model.face_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_BOUND",
                });
            }
        }
        StyleContextSelectRef::FaceOuterBound(i) => {
            if i.0 >= model.face_outer_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_OUTER_BOUND",
                });
            }
        }
        StyleContextSelectRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        StyleContextSelectRef::FillAreaStyleHatching(i) => {
            if i.0 >= model.fill_area_style_hatching_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_HATCHING",
                });
            }
        }
        StyleContextSelectRef::FillAreaStyleTileColouredRegion(i) => {
            if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION",
                });
            }
        }
        StyleContextSelectRef::FillAreaStyleTileCurveWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_curve_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE",
                });
            }
        }
        StyleContextSelectRef::FillAreaStyleTileSymbolWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_symbol_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
                });
            }
        }
        StyleContextSelectRef::FillAreaStyleTiles(i) => {
            if i.0 >= model.fill_area_style_tiles_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILES",
                });
            }
        }
        StyleContextSelectRef::GeometricCurveSet(i) => {
            if i.0 >= model.geometric_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_CURVE_SET",
                });
            }
        }
        StyleContextSelectRef::GeometricRepresentationItem(i) => {
            if i.0 >= model.geometric_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_ITEM",
                });
            }
        }
        StyleContextSelectRef::GeometricSet(i) => {
            if i.0 >= model.geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_SET",
                });
            }
        }
        StyleContextSelectRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::Group(i) => {
            if i.0 >= model.group_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "GROUP" });
            }
        }
        StyleContextSelectRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        StyleContextSelectRef::IntegerRepresentationItem(i) => {
            if i.0 >= model.integer_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTEGER_REPRESENTATION_ITEM",
                });
            }
        }
        StyleContextSelectRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        StyleContextSelectRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        StyleContextSelectRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        StyleContextSelectRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        StyleContextSelectRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        StyleContextSelectRef::Loop(i) => {
            if i.0 >= model.loop_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LOOP" });
            }
        }
        StyleContextSelectRef::ManifoldSolidBrep(i) => {
            if i.0 >= model.manifold_solid_brep_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SOLID_BREP",
                });
            }
        }
        StyleContextSelectRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::MappedItem(i) => {
            if i.0 >= model.mapped_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAPPED_ITEM",
                });
            }
        }
        StyleContextSelectRef::MeasureRepresentationItem(i) => {
            if i.0 >= model.measure_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MEASURE_REPRESENTATION_ITEM",
                });
            }
        }
        StyleContextSelectRef::MechanicalDesignAndDraughtingRelationship(i) => {
            if i.0
                >= model
                    .mechanical_design_and_draughting_relationship_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_AND_DRAUGHTING_RELATIONSHIP",
                });
            }
        }
        StyleContextSelectRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::MechanicalDesignPresentationRepresentationWithDraughting(i) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        StyleContextSelectRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        StyleContextSelectRef::OneDirectionRepeatFactor(i) => {
            if i.0 >= model.one_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ONE_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        StyleContextSelectRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        StyleContextSelectRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        StyleContextSelectRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        StyleContextSelectRef::OverRidingStyledItem(i) => {
            if i.0 >= model.over_riding_styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        StyleContextSelectRef::Path(i) => {
            if i.0 >= model.path_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PATH" });
            }
        }
        StyleContextSelectRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        StyleContextSelectRef::Placement(i) => {
            if i.0 >= model.placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACEMENT",
                });
            }
        }
        StyleContextSelectRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        StyleContextSelectRef::PlanarExtent(i) => {
            if i.0 >= model.planar_extent_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_EXTENT",
                });
            }
        }
        StyleContextSelectRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        StyleContextSelectRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        StyleContextSelectRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        StyleContextSelectRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        StyleContextSelectRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        StyleContextSelectRef::PresentationLayerAssignment(i) => {
            if i.0 >= model.presentation_layer_assignment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_LAYER_ASSIGNMENT",
                });
            }
        }
        StyleContextSelectRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::PresentationSet(i) => {
            if i.0 >= model.presentation_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_SET",
                });
            }
        }
        StyleContextSelectRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        StyleContextSelectRef::ProductConceptFeatureCategory(i) => {
            if i.0 >= model.product_concept_feature_category_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_CONCEPT_FEATURE_CATEGORY",
                });
            }
        }
        StyleContextSelectRef::QualifiedRepresentationItem(i) => {
            if i.0 >= model.qualified_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUALIFIED_REPRESENTATION_ITEM",
                });
            }
        }
        StyleContextSelectRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        StyleContextSelectRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        StyleContextSelectRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        StyleContextSelectRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        StyleContextSelectRef::RealRepresentationItem(i) => {
            if i.0 >= model.real_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REAL_REPRESENTATION_ITEM",
                });
            }
        }
        StyleContextSelectRef::RepositionedTessellatedItem(i) => {
            if i.0 >= model.repositioned_tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPOSITIONED_TESSELLATED_ITEM",
                });
            }
        }
        StyleContextSelectRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::RepresentationItem(i) => {
            if i.0 >= model.representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_ITEM",
                });
            }
        }
        StyleContextSelectRef::RepresentationRelationship(i) => {
            if i.0 >= model.representation_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        StyleContextSelectRef::RepresentationRelationshipWithTransformation(i) => {
            if i.0
                >= model
                    .representation_relationship_with_transformation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION",
                });
            }
        }
        StyleContextSelectRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        StyleContextSelectRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::ShapeRepresentationRelationship(i) => {
            if i.0 >= model.shape_representation_relationship_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_RELATIONSHIP",
                });
            }
        }
        StyleContextSelectRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        StyleContextSelectRef::ShellBasedSurfaceModel(i) => {
            if i.0 >= model.shell_based_surface_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHELL_BASED_SURFACE_MODEL",
                });
            }
        }
        StyleContextSelectRef::SolidModel(i) => {
            if i.0 >= model.solid_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_MODEL",
                });
            }
        }
        StyleContextSelectRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        StyleContextSelectRef::StyledItem(i) => {
            if i.0 >= model.styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STYLED_ITEM",
                });
            }
        }
        StyleContextSelectRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        StyleContextSelectRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        StyleContextSelectRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        StyleContextSelectRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        StyleContextSelectRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        StyleContextSelectRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::SymbolTarget(i) => {
            if i.0 >= model.symbol_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_TARGET",
                });
            }
        }
        StyleContextSelectRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        StyleContextSelectRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        StyleContextSelectRef::TessellatedCurveSet(i) => {
            if i.0 >= model.tessellated_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_CURVE_SET",
                });
            }
        }
        StyleContextSelectRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        StyleContextSelectRef::TessellatedGeometricSet(i) => {
            if i.0 >= model.tessellated_geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                });
            }
        }
        StyleContextSelectRef::TessellatedItem(i) => {
            if i.0 >= model.tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ITEM",
                });
            }
        }
        StyleContextSelectRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        StyleContextSelectRef::TessellatedShell(i) => {
            if i.0 >= model.tessellated_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHELL",
                });
            }
        }
        StyleContextSelectRef::TessellatedSolid(i) => {
            if i.0 >= model.tessellated_solid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SOLID",
                });
            }
        }
        StyleContextSelectRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        StyleContextSelectRef::TessellatedSurfaceSet(i) => {
            if i.0 >= model.tessellated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SURFACE_SET",
                });
            }
        }
        StyleContextSelectRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        StyleContextSelectRef::TopologicalRepresentationItem(i) => {
            if i.0 >= model.topological_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOPOLOGICAL_REPRESENTATION_ITEM",
                });
            }
        }
        StyleContextSelectRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        StyleContextSelectRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        StyleContextSelectRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        StyleContextSelectRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        StyleContextSelectRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        StyleContextSelectRef::ValueRepresentationItem(i) => {
            if i.0 >= model.value_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VALUE_REPRESENTATION_ITEM",
                });
            }
        }
        StyleContextSelectRef::Vector(i) => {
            if i.0 >= model.vector_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VECTOR" });
            }
        }
        StyleContextSelectRef::Vertex(i) => {
            if i.0 >= model.vertex_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VERTEX" });
            }
        }
        StyleContextSelectRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
        StyleContextSelectRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        StyleContextSelectRef::VertexShell(i) => {
            if i.0 >= model.vertex_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_SHELL",
                });
            }
        }
        StyleContextSelectRef::WireShell(i) => {
            if i.0 >= model.wire_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "WIRE_SHELL",
                });
            }
        }
        StyleContextSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_styled_item_ref(model: &StepModel, r: &StyledItemRef) -> Result<(), AuthorError> {
    match r {
        StyledItemRef::AnnotationCurveOccurrence(i) => {
            if i.0 >= model.annotation_curve_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_CURVE_OCCURRENCE",
                });
            }
        }
        StyledItemRef::AnnotationFillAreaOccurrence(i) => {
            if i.0 >= model.annotation_fill_area_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_FILL_AREA_OCCURRENCE",
                });
            }
        }
        StyledItemRef::AnnotationOccurrence(i) => {
            if i.0 >= model.annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_OCCURRENCE",
                });
            }
        }
        StyledItemRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        StyledItemRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        StyledItemRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        StyledItemRef::AnnotationSymbolOccurrence(i) => {
            if i.0 >= model.annotation_symbol_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL_OCCURRENCE",
                });
            }
        }
        StyledItemRef::AnnotationTextOccurrence(i) => {
            if i.0 >= model.annotation_text_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_OCCURRENCE",
                });
            }
        }
        StyledItemRef::ContextDependentOverRidingStyledItem(i) => {
            if i.0
                >= model
                    .context_dependent_over_riding_styled_item_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        StyledItemRef::DraughtingAnnotationOccurrence(i) => {
            if i.0 >= model.draughting_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_ANNOTATION_OCCURRENCE",
                });
            }
        }
        StyledItemRef::LeaderCurve(i) => {
            if i.0 >= model.leader_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_CURVE",
                });
            }
        }
        StyledItemRef::LeaderTerminator(i) => {
            if i.0 >= model.leader_terminator_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_TERMINATOR",
                });
            }
        }
        StyledItemRef::OverRidingStyledItem(i) => {
            if i.0 >= model.over_riding_styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OVER_RIDING_STYLED_ITEM",
                });
            }
        }
        StyledItemRef::StyledItem(i) => {
            if i.0 >= model.styled_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STYLED_ITEM",
                });
            }
        }
        StyledItemRef::TerminatorSymbol(i) => {
            if i.0 >= model.terminator_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TERMINATOR_SYMBOL",
                });
            }
        }
        StyledItemRef::TessellatedAnnotationOccurrence(i) => {
            if i.0 >= model.tessellated_annotation_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ANNOTATION_OCCURRENCE",
                });
            }
        }
        StyledItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_styled_item_target_ref(
    model: &StepModel,
    r: &StyledItemTargetRef,
) -> Result<(), AuthorError> {
    match r {
        StyledItemTargetRef::AdvancedBrepShapeRepresentation(i) => {
            if i.0 >= model.advanced_brep_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_BREP_SHAPE_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::AdvancedFace(i) => {
            if i.0 >= model.advanced_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ADVANCED_FACE",
                });
            }
        }
        StyledItemTargetRef::AnnotationPlaceholderLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_LEADER_LINE",
            });
        }
        StyledItemTargetRef::AnnotationPlaceholderOccurrence(i) => {
            if i.0 >= model.annotation_placeholder_occurrence_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE",
                });
            }
        }
        StyledItemTargetRef::AnnotationPlaceholderOccurrenceWithLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_PLACEHOLDER_OCCURRENCE_WITH_LEADER_LINE",
            });
        }
        StyledItemTargetRef::AnnotationPlane(i) => {
            if i.0 >= model.annotation_plane_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_PLANE",
                });
            }
        }
        StyledItemTargetRef::AnnotationSymbol(i) => {
            if i.0 >= model.annotation_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_SYMBOL",
                });
            }
        }
        StyledItemTargetRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        StyledItemTargetRef::AnnotationTextCharacter(i) => {
            if i.0 >= model.annotation_text_character_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_CHARACTER",
                });
            }
        }
        StyledItemTargetRef::AnnotationToAnnotationLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_ANNOTATION_LEADER_LINE",
            });
        }
        StyledItemTargetRef::AnnotationToModelLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "ANNOTATION_TO_MODEL_LEADER_LINE",
            });
        }
        StyledItemTargetRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        StyledItemTargetRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        StyledItemTargetRef::AuxiliaryLeaderLine(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "AUXILIARY_LEADER_LINE",
            });
        }
        StyledItemTargetRef::Axis1Placement(i) => {
            if i.0 >= model.axis1_placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS1_PLACEMENT",
                });
            }
        }
        StyledItemTargetRef::Axis2Placement2d(i) => {
            if i.0 >= model.axis2_placement2d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_2D",
                });
            }
        }
        StyledItemTargetRef::Axis2Placement3d(i) => {
            if i.0 >= model.axis2_placement3d_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AXIS2_PLACEMENT_3D",
                });
            }
        }
        StyledItemTargetRef::BSplineCurve(i) => {
            if i.0 >= model.b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE",
                });
            }
        }
        StyledItemTargetRef::BSplineCurveWithKnots(i) => {
            if i.0 >= model.b_spline_curve_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_CURVE_WITH_KNOTS",
                });
            }
        }
        StyledItemTargetRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        StyledItemTargetRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        StyledItemTargetRef::BezierCurve(i) => {
            if i.0 >= model.bezier_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_CURVE",
                });
            }
        }
        StyledItemTargetRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        StyledItemTargetRef::BoundedCurve(i) => {
            if i.0 >= model.bounded_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_CURVE",
                });
            }
        }
        StyledItemTargetRef::BoundedPcurve(i) => {
            if i.0 >= model.bounded_pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_PCURVE",
                });
            }
        }
        StyledItemTargetRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        StyledItemTargetRef::BoundedSurfaceCurve(i) => {
            if i.0 >= model.bounded_surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE_CURVE",
                });
            }
        }
        StyledItemTargetRef::BrepWithVoids(i) => {
            if i.0 >= model.brep_with_voids_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BREP_WITH_VOIDS",
                });
            }
        }
        StyledItemTargetRef::CameraImage(i) => {
            if i.0 >= model.camera_image_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE",
                });
            }
        }
        StyledItemTargetRef::CameraImage3dWithScale(i) => {
            if i.0 >= model.camera_image3d_with_scale_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_IMAGE_3D_WITH_SCALE",
                });
            }
        }
        StyledItemTargetRef::CameraModel(i) => {
            if i.0 >= model.camera_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL",
                });
            }
        }
        StyledItemTargetRef::CameraModelD3(i) => {
            if i.0 >= model.camera_model_d3_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3",
                });
            }
        }
        StyledItemTargetRef::CameraModelD3MultiClipping(i) => {
            if i.0 >= model.camera_model_d3_multi_clipping_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_MULTI_CLIPPING",
                });
            }
        }
        StyledItemTargetRef::CameraModelD3WithHlhsr(i) => {
            if i.0 >= model.camera_model_d3_with_hlhsr_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CAMERA_MODEL_D3_WITH_HLHSR",
                });
            }
        }
        StyledItemTargetRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        StyledItemTargetRef::CharacterizedRepresentation(i) => {
            if i.0 >= model.characterized_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CHARACTERIZED_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::Circle(i) => {
            if i.0 >= model.circle_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CIRCLE" });
            }
        }
        StyledItemTargetRef::ClosedShell(i) => {
            if i.0 >= model.closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CLOSED_SHELL",
                });
            }
        }
        StyledItemTargetRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        StyledItemTargetRef::ComplexTriangulatedSurfaceSet(i) => {
            if i.0 >= model.complex_triangulated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_SURFACE_SET",
                });
            }
        }
        StyledItemTargetRef::CompositeCurve(i) => {
            if i.0 >= model.composite_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_CURVE",
                });
            }
        }
        StyledItemTargetRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        StyledItemTargetRef::Conic(i) => {
            if i.0 >= model.conic_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CONIC" });
            }
        }
        StyledItemTargetRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        StyledItemTargetRef::ConnectedFaceSet(i) => {
            if i.0 >= model.connected_face_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONNECTED_FACE_SET",
                });
            }
        }
        StyledItemTargetRef::ConstructiveGeometryRepresentation(i) => {
            if i.0 >= model.constructive_geometry_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONSTRUCTIVE_GEOMETRY_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
        StyledItemTargetRef::Curve(i) => {
            if i.0 >= model.curve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "CURVE" });
            }
        }
        StyledItemTargetRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        StyledItemTargetRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        StyledItemTargetRef::DefinedSymbol(i) => {
            if i.0 >= model.defined_symbol_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_SYMBOL",
                });
            }
        }
        StyledItemTargetRef::DefinitionalRepresentation(i) => {
            if i.0 >= model.definitional_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINITIONAL_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        StyledItemTargetRef::Direction(i) => {
            if i.0 >= model.direction_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTION",
                });
            }
        }
        StyledItemTargetRef::DraughtingCallout(i) => {
            if i.0 >= model.draughting_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_CALLOUT",
                });
            }
        }
        StyledItemTargetRef::DraughtingModel(i) => {
            if i.0 >= model.draughting_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DRAUGHTING_MODEL",
                });
            }
        }
        StyledItemTargetRef::Edge(i) => {
            if i.0 >= model.edge_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "EDGE" });
            }
        }
        StyledItemTargetRef::EdgeCurve(i) => {
            if i.0 >= model.edge_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_CURVE",
                });
            }
        }
        StyledItemTargetRef::EdgeLoop(i) => {
            if i.0 >= model.edge_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EDGE_LOOP",
                });
            }
        }
        StyledItemTargetRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        StyledItemTargetRef::Ellipse(i) => {
            if i.0 >= model.ellipse_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ELLIPSE" });
            }
        }
        StyledItemTargetRef::ExternallyDefinedHatchStyle(i) => {
            if i.0 >= model.externally_defined_hatch_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_HATCH_STYLE",
                });
            }
        }
        StyledItemTargetRef::ExternallyDefinedTileStyle(i) => {
            if i.0 >= model.externally_defined_tile_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "EXTERNALLY_DEFINED_TILE_STYLE",
                });
            }
        }
        StyledItemTargetRef::Face(i) => {
            if i.0 >= model.face_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "FACE" });
            }
        }
        StyledItemTargetRef::FaceBound(i) => {
            if i.0 >= model.face_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_BOUND",
                });
            }
        }
        StyledItemTargetRef::FaceOuterBound(i) => {
            if i.0 >= model.face_outer_bound_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_OUTER_BOUND",
                });
            }
        }
        StyledItemTargetRef::FaceSurface(i) => {
            if i.0 >= model.face_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FACE_SURFACE",
                });
            }
        }
        StyledItemTargetRef::FillAreaStyleHatching(i) => {
            if i.0 >= model.fill_area_style_hatching_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_HATCHING",
                });
            }
        }
        StyledItemTargetRef::FillAreaStyleTileColouredRegion(i) => {
            if i.0 >= model.fill_area_style_tile_coloured_region_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_COLOURED_REGION",
                });
            }
        }
        StyledItemTargetRef::FillAreaStyleTileCurveWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_curve_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_CURVE_WITH_STYLE",
                });
            }
        }
        StyledItemTargetRef::FillAreaStyleTileSymbolWithStyle(i) => {
            if i.0
                >= model
                    .fill_area_style_tile_symbol_with_style_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE",
                });
            }
        }
        StyledItemTargetRef::FillAreaStyleTiles(i) => {
            if i.0 >= model.fill_area_style_tiles_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FILL_AREA_STYLE_TILES",
                });
            }
        }
        StyledItemTargetRef::GeometricCurveSet(i) => {
            if i.0 >= model.geometric_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_CURVE_SET",
                });
            }
        }
        StyledItemTargetRef::GeometricRepresentationItem(i) => {
            if i.0 >= model.geometric_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_REPRESENTATION_ITEM",
                });
            }
        }
        StyledItemTargetRef::GeometricSet(i) => {
            if i.0 >= model.geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_SET",
                });
            }
        }
        StyledItemTargetRef::GeometricallyBoundedSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::GeometricallyBoundedWireframeShapeRepresentation(i) => {
            if i.0
                >= model
                    .geometrically_bounded_wireframe_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::Hyperbola(i) => {
            if i.0 >= model.hyperbola_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "HYPERBOLA",
                });
            }
        }
        StyledItemTargetRef::IntersectionCurve(i) => {
            if i.0 >= model.intersection_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "INTERSECTION_CURVE",
                });
            }
        }
        StyledItemTargetRef::LeaderDirectedCallout(i) => {
            if i.0 >= model.leader_directed_callout_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LEADER_DIRECTED_CALLOUT",
                });
            }
        }
        StyledItemTargetRef::Line(i) => {
            if i.0 >= model.line_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LINE" });
            }
        }
        StyledItemTargetRef::Loop(i) => {
            if i.0 >= model.loop_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "LOOP" });
            }
        }
        StyledItemTargetRef::ManifoldSolidBrep(i) => {
            if i.0 >= model.manifold_solid_brep_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SOLID_BREP",
                });
            }
        }
        StyledItemTargetRef::ManifoldSurfaceShapeRepresentation(i) => {
            if i.0
                >= model
                    .manifold_surface_shape_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MANIFOLD_SURFACE_SHAPE_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::MappedItem(i) => {
            if i.0 >= model.mapped_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MAPPED_ITEM",
                });
            }
        }
        StyledItemTargetRef::MechanicalDesignGeometricPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_geometric_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::MechanicalDesignPresentationRepresentationWithDraughting(i) => {
            if i.0
                >= model
                    .mechanical_design_presentation_representation_with_draughting_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_PRESENTATION_REPRESENTATION_WITH_DRAUGHTING",
                });
            }
        }
        StyledItemTargetRef::MechanicalDesignShadedPresentationRepresentation(i) => {
            if i.0
                >= model
                    .mechanical_design_shaded_presentation_representation_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "MECHANICAL_DESIGN_SHADED_PRESENTATION_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        StyledItemTargetRef::OneDirectionRepeatFactor(i) => {
            if i.0 >= model.one_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ONE_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        StyledItemTargetRef::OpenShell(i) => {
            if i.0 >= model.open_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OPEN_SHELL",
                });
            }
        }
        StyledItemTargetRef::OrientedClosedShell(i) => {
            if i.0 >= model.oriented_closed_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_CLOSED_SHELL",
                });
            }
        }
        StyledItemTargetRef::OrientedEdge(i) => {
            if i.0 >= model.oriented_edge_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ORIENTED_EDGE",
                });
            }
        }
        StyledItemTargetRef::Path(i) => {
            if i.0 >= model.path_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PATH" });
            }
        }
        StyledItemTargetRef::Pcurve(i) => {
            if i.0 >= model.pcurve_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PCURVE" });
            }
        }
        StyledItemTargetRef::Placement(i) => {
            if i.0 >= model.placement_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLACEMENT",
                });
            }
        }
        StyledItemTargetRef::PlanarBox(i) => {
            if i.0 >= model.planar_box_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_BOX",
                });
            }
        }
        StyledItemTargetRef::PlanarExtent(i) => {
            if i.0 >= model.planar_extent_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANAR_EXTENT",
                });
            }
        }
        StyledItemTargetRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        StyledItemTargetRef::Point(i) => {
            if i.0 >= model.point_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POINT" });
            }
        }
        StyledItemTargetRef::PolyLoop(i) => {
            if i.0 >= model.poly_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POLY_LOOP",
                });
            }
        }
        StyledItemTargetRef::Polyline(i) => {
            if i.0 >= model.polyline_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "POLYLINE" });
            }
        }
        StyledItemTargetRef::PresentationArea(i) => {
            if i.0 >= model.presentation_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_AREA",
                });
            }
        }
        StyledItemTargetRef::PresentationRepresentation(i) => {
            if i.0 >= model.presentation_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::PresentationView(i) => {
            if i.0 >= model.presentation_view_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRESENTATION_VIEW",
                });
            }
        }
        StyledItemTargetRef::QuasiUniformCurve(i) => {
            if i.0 >= model.quasi_uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_CURVE",
                });
            }
        }
        StyledItemTargetRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        StyledItemTargetRef::RationalBSplineCurve(i) => {
            if i.0 >= model.rational_b_spline_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_CURVE",
                });
            }
        }
        StyledItemTargetRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        StyledItemTargetRef::RepositionedTessellatedItem(i) => {
            if i.0 >= model.repositioned_tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPOSITIONED_TESSELLATED_ITEM",
                });
            }
        }
        StyledItemTargetRef::Representation(i) => {
            if i.0 >= model.representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::RepresentationReference(i) => {
            if i.0 >= model.representation_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPRESENTATION_REFERENCE",
                });
            }
        }
        StyledItemTargetRef::SeamCurve(i) => {
            if i.0 >= model.seam_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SEAM_CURVE",
                });
            }
        }
        StyledItemTargetRef::ShapeDimensionRepresentation(i) => {
            if i.0 >= model.shape_dimension_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_DIMENSION_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::ShapeRepresentation(i) => {
            if i.0 >= model.shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::ShapeRepresentationWithParameters(i) => {
            if i.0 >= model.shape_representation_with_parameters_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHAPE_REPRESENTATION_WITH_PARAMETERS",
                });
            }
        }
        StyledItemTargetRef::ShellBasedSurfaceModel(i) => {
            if i.0 >= model.shell_based_surface_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SHELL_BASED_SURFACE_MODEL",
                });
            }
        }
        StyledItemTargetRef::SolidModel(i) => {
            if i.0 >= model.solid_model_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_MODEL",
                });
            }
        }
        StyledItemTargetRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        StyledItemTargetRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        StyledItemTargetRef::SurfaceCurve(i) => {
            if i.0 >= model.surface_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_CURVE",
                });
            }
        }
        StyledItemTargetRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        StyledItemTargetRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        StyledItemTargetRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        StyledItemTargetRef::SymbolRepresentation(i) => {
            if i.0 >= model.symbol_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::SymbolTarget(i) => {
            if i.0 >= model.symbol_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_TARGET",
                });
            }
        }
        StyledItemTargetRef::TessellatedCurveSet(i) => {
            if i.0 >= model.tessellated_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_CURVE_SET",
                });
            }
        }
        StyledItemTargetRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        StyledItemTargetRef::TessellatedGeometricSet(i) => {
            if i.0 >= model.tessellated_geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                });
            }
        }
        StyledItemTargetRef::TessellatedItem(i) => {
            if i.0 >= model.tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ITEM",
                });
            }
        }
        StyledItemTargetRef::TessellatedShapeRepresentation(i) => {
            if i.0 >= model.tessellated_shape_representation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHAPE_REPRESENTATION",
                });
            }
        }
        StyledItemTargetRef::TessellatedShell(i) => {
            if i.0 >= model.tessellated_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHELL",
                });
            }
        }
        StyledItemTargetRef::TessellatedSolid(i) => {
            if i.0 >= model.tessellated_solid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SOLID",
                });
            }
        }
        StyledItemTargetRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        StyledItemTargetRef::TessellatedSurfaceSet(i) => {
            if i.0 >= model.tessellated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SURFACE_SET",
                });
            }
        }
        StyledItemTargetRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        StyledItemTargetRef::TopologicalRepresentationItem(i) => {
            if i.0 >= model.topological_representation_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOPOLOGICAL_REPRESENTATION_ITEM",
                });
            }
        }
        StyledItemTargetRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        StyledItemTargetRef::TrimmedCurve(i) => {
            if i.0 >= model.trimmed_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TRIMMED_CURVE",
                });
            }
        }
        StyledItemTargetRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        StyledItemTargetRef::UniformCurve(i) => {
            if i.0 >= model.uniform_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_CURVE",
                });
            }
        }
        StyledItemTargetRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        StyledItemTargetRef::Vector(i) => {
            if i.0 >= model.vector_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VECTOR" });
            }
        }
        StyledItemTargetRef::Vertex(i) => {
            if i.0 >= model.vertex_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VERTEX" });
            }
        }
        StyledItemTargetRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
        StyledItemTargetRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        StyledItemTargetRef::VertexShell(i) => {
            if i.0 >= model.vertex_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_SHELL",
                });
            }
        }
        StyledItemTargetRef::WireShell(i) => {
            if i.0 >= model.wire_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "WIRE_SHELL",
                });
            }
        }
        StyledItemTargetRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_supported_item_ref(model: &StepModel, r: &SupportedItemRef) -> Result<(), AuthorError> {
    match r {
        SupportedItemRef::Action(i) => {
            if i.0 >= model.action_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "ACTION" });
            }
        }
        SupportedItemRef::ActionDirective(i) => {
            if i.0 >= model.action_directive_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_DIRECTIVE",
                });
            }
        }
        SupportedItemRef::ActionMethod(i) => {
            if i.0 >= model.action_method_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ACTION_METHOD",
                });
            }
        }
        SupportedItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_surface_ref(model: &StepModel, r: &SurfaceRef) -> Result<(), AuthorError> {
    match r {
        SurfaceRef::BSplineSurface(i) => {
            if i.0 >= model.b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE",
                });
            }
        }
        SurfaceRef::BSplineSurfaceWithKnots(i) => {
            if i.0 >= model.b_spline_surface_with_knots_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "B_SPLINE_SURFACE_WITH_KNOTS",
                });
            }
        }
        SurfaceRef::BezierSurface(i) => {
            if i.0 >= model.bezier_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BEZIER_SURFACE",
                });
            }
        }
        SurfaceRef::BoundedSurface(i) => {
            if i.0 >= model.bounded_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "BOUNDED_SURFACE",
                });
            }
        }
        SurfaceRef::ConicalSurface(i) => {
            if i.0 >= model.conical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONICAL_SURFACE",
                });
            }
        }
        SurfaceRef::CylindricalSurface(i) => {
            if i.0 >= model.cylindrical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICAL_SURFACE",
                });
            }
        }
        SurfaceRef::DegenerateToroidalSurface(i) => {
            if i.0 >= model.degenerate_toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEGENERATE_TOROIDAL_SURFACE",
                });
            }
        }
        SurfaceRef::ElementarySurface(i) => {
            if i.0 >= model.elementary_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ELEMENTARY_SURFACE",
                });
            }
        }
        SurfaceRef::OffsetSurface(i) => {
            if i.0 >= model.offset_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "OFFSET_SURFACE",
                });
            }
        }
        SurfaceRef::Plane(i) => {
            if i.0 >= model.plane_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "PLANE" });
            }
        }
        SurfaceRef::QuasiUniformSurface(i) => {
            if i.0 >= model.quasi_uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "QUASI_UNIFORM_SURFACE",
                });
            }
        }
        SurfaceRef::RationalBSplineSurface(i) => {
            if i.0 >= model.rational_b_spline_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIONAL_B_SPLINE_SURFACE",
                });
            }
        }
        SurfaceRef::SphericalSurface(i) => {
            if i.0 >= model.spherical_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SPHERICAL_SURFACE",
                });
            }
        }
        SurfaceRef::Surface(i) => {
            if i.0 >= model.surface_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SURFACE" });
            }
        }
        SurfaceRef::SurfaceOfLinearExtrusion(i) => {
            if i.0 >= model.surface_of_linear_extrusion_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_LINEAR_EXTRUSION",
                });
            }
        }
        SurfaceRef::SurfaceOfRevolution(i) => {
            if i.0 >= model.surface_of_revolution_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_OF_REVOLUTION",
                });
            }
        }
        SurfaceRef::SweptSurface(i) => {
            if i.0 >= model.swept_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SWEPT_SURFACE",
                });
            }
        }
        SurfaceRef::ToroidalSurface(i) => {
            if i.0 >= model.toroidal_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOROIDAL_SURFACE",
                });
            }
        }
        SurfaceRef::UniformSurface(i) => {
            if i.0 >= model.uniform_surface_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNIFORM_SURFACE",
                });
            }
        }
        SurfaceRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_surface_rendering_properties_ref(
    model: &StepModel,
    r: &SurfaceRenderingPropertiesRef,
) -> Result<(), AuthorError> {
    match r {
        SurfaceRenderingPropertiesRef::SurfaceRenderingProperties(i) => {
            if i.0 >= model.surface_rendering_properties_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_RENDERING_PROPERTIES",
                });
            }
        }
    }
    Ok(())
}
fn check_surface_side_style_select_ref(
    model: &StepModel,
    r: &SurfaceSideStyleSelectRef,
) -> Result<(), AuthorError> {
    match r {
        SurfaceSideStyleSelectRef::PreDefinedSurfaceSideStyle(i) => {
            if i.0 >= model.pre_defined_surface_side_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRE_DEFINED_SURFACE_SIDE_STYLE",
                });
            }
        }
        SurfaceSideStyleSelectRef::SurfaceSideStyle(i) => {
            if i.0 >= model.surface_side_style_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_SIDE_STYLE",
                });
            }
        }
        SurfaceSideStyleSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_surface_style_element_select_ref(
    model: &StepModel,
    r: &SurfaceStyleElementSelectRef,
) -> Result<(), AuthorError> {
    match r {
        SurfaceStyleElementSelectRef::SurfaceStyleBoundary(i) => {
            if i.0 >= model.surface_style_boundary_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_STYLE_BOUNDARY",
                });
            }
        }
        SurfaceStyleElementSelectRef::SurfaceStyleControlGrid(i) => {
            if i.0 >= model.surface_style_control_grid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_STYLE_CONTROL_GRID",
                });
            }
        }
        SurfaceStyleElementSelectRef::SurfaceStyleFillArea(i) => {
            if i.0 >= model.surface_style_fill_area_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_STYLE_FILL_AREA",
                });
            }
        }
        SurfaceStyleElementSelectRef::SurfaceStyleParameterLine(i) => {
            if i.0 >= model.surface_style_parameter_line_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_STYLE_PARAMETER_LINE",
                });
            }
        }
        SurfaceStyleElementSelectRef::SurfaceStyleRendering(i) => {
            if i.0 >= model.surface_style_rendering_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_STYLE_RENDERING",
                });
            }
        }
        SurfaceStyleElementSelectRef::SurfaceStyleRenderingWithProperties(i) => {
            if i.0
                >= model
                    .surface_style_rendering_with_properties_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_STYLE_RENDERING_WITH_PROPERTIES",
                });
            }
        }
        SurfaceStyleElementSelectRef::SurfaceStyleSegmentationCurve(i) => {
            if i.0 >= model.surface_style_segmentation_curve_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_STYLE_SEGMENTATION_CURVE",
                });
            }
        }
        SurfaceStyleElementSelectRef::SurfaceStyleSilhouette(i) => {
            if i.0 >= model.surface_style_silhouette_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_STYLE_SILHOUETTE",
                });
            }
        }
        SurfaceStyleElementSelectRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_symbol_style_select_ref(
    model: &StepModel,
    r: &SymbolStyleSelectRef,
) -> Result<(), AuthorError> {
    match r {
        SymbolStyleSelectRef::SymbolColour(i) => {
            if i.0 >= model.symbol_colour_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_COLOUR",
                });
            }
        }
    }
    Ok(())
}
fn check_symbol_target_ref(model: &StepModel, r: &SymbolTargetRef) -> Result<(), AuthorError> {
    match r {
        SymbolTargetRef::SymbolTarget(i) => {
            if i.0 >= model.symbol_target_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMBOL_TARGET",
                });
            }
        }
    }
    Ok(())
}
fn check_tessellated_item_ref(
    model: &StepModel,
    r: &TessellatedItemRef,
) -> Result<(), AuthorError> {
    match r {
        TessellatedItemRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        TessellatedItemRef::ComplexTriangulatedSurfaceSet(i) => {
            if i.0 >= model.complex_triangulated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_SURFACE_SET",
                });
            }
        }
        TessellatedItemRef::CoordinatesList(i) => {
            if i.0 >= model.coordinates_list_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COORDINATES_LIST",
                });
            }
        }
        TessellatedItemRef::RepositionedTessellatedItem(i) => {
            if i.0 >= model.repositioned_tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "REPOSITIONED_TESSELLATED_ITEM",
                });
            }
        }
        TessellatedItemRef::TessellatedCurveSet(i) => {
            if i.0 >= model.tessellated_curve_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_CURVE_SET",
                });
            }
        }
        TessellatedItemRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        TessellatedItemRef::TessellatedGeometricSet(i) => {
            if i.0 >= model.tessellated_geometric_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_GEOMETRIC_SET",
                });
            }
        }
        TessellatedItemRef::TessellatedItem(i) => {
            if i.0 >= model.tessellated_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_ITEM",
                });
            }
        }
        TessellatedItemRef::TessellatedShell(i) => {
            if i.0 >= model.tessellated_shell_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SHELL",
                });
            }
        }
        TessellatedItemRef::TessellatedSolid(i) => {
            if i.0 >= model.tessellated_solid_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SOLID",
                });
            }
        }
        TessellatedItemRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        TessellatedItemRef::TessellatedSurfaceSet(i) => {
            if i.0 >= model.tessellated_surface_set_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_SURFACE_SET",
                });
            }
        }
        TessellatedItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_tessellated_structured_item_ref(
    model: &StepModel,
    r: &TessellatedStructuredItemRef,
) -> Result<(), AuthorError> {
    match r {
        TessellatedStructuredItemRef::ComplexTriangulatedFace(i) => {
            if i.0 >= model.complex_triangulated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPLEX_TRIANGULATED_FACE",
                });
            }
        }
        TessellatedStructuredItemRef::TessellatedFace(i) => {
            if i.0 >= model.tessellated_face_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_FACE",
                });
            }
        }
        TessellatedStructuredItemRef::TessellatedStructuredItem(i) => {
            if i.0 >= model.tessellated_structured_item_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TESSELLATED_STRUCTURED_ITEM",
                });
            }
        }
        TessellatedStructuredItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_text_or_character_ref(
    model: &StepModel,
    r: &TextOrCharacterRef,
) -> Result<(), AuthorError> {
    match r {
        TextOrCharacterRef::AnnotationText(i) => {
            if i.0 >= model.annotation_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT",
                });
            }
        }
        TextOrCharacterRef::AnnotationTextCharacter(i) => {
            if i.0 >= model.annotation_text_character_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANNOTATION_TEXT_CHARACTER",
                });
            }
        }
        TextOrCharacterRef::CompositeText(i) => {
            if i.0 >= model.composite_text_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COMPOSITE_TEXT",
                });
            }
        }
        TextOrCharacterRef::DefinedCharacterGlyph(i) => {
            if i.0 >= model.defined_character_glyph_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DEFINED_CHARACTER_GLYPH",
                });
            }
        }
        TextOrCharacterRef::TextLiteral(i) => {
            if i.0 >= model.text_literal_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TEXT_LITERAL",
                });
            }
        }
        TextOrCharacterRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_tolerance_method_definition_ref(
    model: &StepModel,
    r: &ToleranceMethodDefinitionRef,
) -> Result<(), AuthorError> {
    match r {
        ToleranceMethodDefinitionRef::LimitsAndFits(i) => {
            if i.0 >= model.limits_and_fits_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LIMITS_AND_FITS",
                });
            }
        }
        ToleranceMethodDefinitionRef::ToleranceValue(i) => {
            if i.0 >= model.tolerance_value_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_VALUE",
                });
            }
        }
    }
    Ok(())
}
fn check_tolerance_select_ref(
    model: &StepModel,
    r: &ToleranceSelectRef,
) -> Result<(), AuthorError> {
    match r {
        ToleranceSelectRef::ApproximationToleranceDeviation(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APPROXIMATION_TOLERANCE_DEVIATION",
            });
        }
        ToleranceSelectRef::ApproximationToleranceParameter(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APPROXIMATION_TOLERANCE_PARAMETER",
            });
        }
    }
    Ok(())
}
fn check_tolerance_zone_ref(model: &StepModel, r: &ToleranceZoneRef) -> Result<(), AuthorError> {
    match r {
        ToleranceZoneRef::ToleranceZone(i) => {
            if i.0 >= model.tolerance_zone_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE",
                });
            }
        }
        ToleranceZoneRef::ToleranceZoneWithDatum(i) => {
            if i.0 >= model.tolerance_zone_with_datum_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_WITH_DATUM",
                });
            }
        }
        ToleranceZoneRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_tolerance_zone_form_ref(
    model: &StepModel,
    r: &ToleranceZoneFormRef,
) -> Result<(), AuthorError> {
    match r {
        ToleranceZoneFormRef::ToleranceZoneForm(i) => {
            if i.0 >= model.tolerance_zone_form_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOLERANCE_ZONE_FORM",
                });
            }
        }
    }
    Ok(())
}
fn check_tolerance_zone_target_ref(
    model: &StepModel,
    r: &ToleranceZoneTargetRef,
) -> Result<(), AuthorError> {
    match r {
        ToleranceZoneTargetRef::AngularLocation(i) => {
            if i.0 >= model.angular_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_LOCATION",
                });
            }
        }
        ToleranceZoneTargetRef::AngularSize(i) => {
            if i.0 >= model.angular_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULAR_SIZE",
                });
            }
        }
        ToleranceZoneTargetRef::AngularityTolerance(i) => {
            if i.0 >= model.angularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ANGULARITY_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::CircularRunoutTolerance(i) => {
            if i.0 >= model.circular_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CIRCULAR_RUNOUT_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::CoaxialityTolerance(i) => {
            if i.0 >= model.coaxiality_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "COAXIALITY_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::ConcentricityTolerance(i) => {
            if i.0 >= model.concentricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONCENTRICITY_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::CylindricityTolerance(i) => {
            if i.0 >= model.cylindricity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CYLINDRICITY_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::DatumReferenceCompartment(i) => {
            if i.0 >= model.datum_reference_compartment_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_COMPARTMENT",
                });
            }
        }
        ToleranceZoneTargetRef::DatumReferenceElement(i) => {
            if i.0 >= model.datum_reference_element_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DATUM_REFERENCE_ELEMENT",
                });
            }
        }
        ToleranceZoneTargetRef::DimensionalLocation(i) => {
            if i.0 >= model.dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION",
                });
            }
        }
        ToleranceZoneTargetRef::DimensionalLocationWithPath(i) => {
            if i.0 >= model.dimensional_location_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_LOCATION_WITH_PATH",
                });
            }
        }
        ToleranceZoneTargetRef::DimensionalSize(i) => {
            if i.0 >= model.dimensional_size_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE",
                });
            }
        }
        ToleranceZoneTargetRef::DimensionalSizeWithDatumFeature(i) => {
            if i.0 >= model.dimensional_size_with_datum_feature_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_DATUM_FEATURE",
                });
            }
        }
        ToleranceZoneTargetRef::DimensionalSizeWithPath(i) => {
            if i.0 >= model.dimensional_size_with_path_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIMENSIONAL_SIZE_WITH_PATH",
                });
            }
        }
        ToleranceZoneTargetRef::DirectedDimensionalLocation(i) => {
            if i.0 >= model.directed_dimensional_location_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DIRECTED_DIMENSIONAL_LOCATION",
                });
            }
        }
        ToleranceZoneTargetRef::FlatnessTolerance(i) => {
            if i.0 >= model.flatness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FLATNESS_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::GeneralDatumReference(i) => {
            if i.0 >= model.general_datum_reference_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GENERAL_DATUM_REFERENCE",
                });
            }
        }
        ToleranceZoneTargetRef::GeometricTolerance(i) => {
            if i.0 >= model.geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::GeometricToleranceWithDatumReference(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_datum_reference_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
                });
            }
        }
        ToleranceZoneTargetRef::GeometricToleranceWithDefinedAreaUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_area_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT",
                });
            }
        }
        ToleranceZoneTargetRef::GeometricToleranceWithDefinedUnit(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_defined_unit_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT",
                });
            }
        }
        ToleranceZoneTargetRef::GeometricToleranceWithMaximumTolerance(i) => {
            if i.0
                >= model
                    .geometric_tolerance_with_maximum_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::GeometricToleranceWithModifiers(i) => {
            if i.0 >= model.geometric_tolerance_with_modifiers_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
                });
            }
        }
        ToleranceZoneTargetRef::LineProfileTolerance(i) => {
            if i.0 >= model.line_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LINE_PROFILE_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::ModifiedGeometricTolerance(i) => {
            if i.0 >= model.modified_geometric_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MODIFIED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::ParallelismTolerance(i) => {
            if i.0 >= model.parallelism_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PARALLELISM_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::PerpendicularityTolerance(i) => {
            if i.0 >= model.perpendicularity_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PERPENDICULARITY_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::PositionTolerance(i) => {
            if i.0 >= model.position_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "POSITION_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::RoundnessTolerance(i) => {
            if i.0 >= model.roundness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ROUNDNESS_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::StraightnessTolerance(i) => {
            if i.0 >= model.straightness_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "STRAIGHTNESS_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::SurfaceProfileTolerance(i) => {
            if i.0 >= model.surface_profile_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SURFACE_PROFILE_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::SymmetryTolerance(i) => {
            if i.0 >= model.symmetry_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SYMMETRY_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::TotalRunoutTolerance(i) => {
            if i.0 >= model.total_runout_tolerance_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TOTAL_RUNOUT_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::UnequallyDisposedGeometricTolerance(i) => {
            if i.0
                >= model
                    .unequally_disposed_geometric_tolerance_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE",
                });
            }
        }
        ToleranceZoneTargetRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_transformation_ref(model: &StepModel, r: &TransformationRef) -> Result<(), AuthorError> {
    match r {
        TransformationRef::FunctionallyDefinedTransformation(i) => {
            if i.0 >= model.functionally_defined_transformation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "FUNCTIONALLY_DEFINED_TRANSFORMATION",
                });
            }
        }
        TransformationRef::ItemDefinedTransformation(i) => {
            if i.0 >= model.item_defined_transformation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "ITEM_DEFINED_TRANSFORMATION",
                });
            }
        }
        TransformationRef::ListItemDefinedTransformation(v) => {
            for e in v {
                check_item_defined_transformation_ref(model, e)?;
            }
        }
        TransformationRef::SetItemDefinedTransformation(v) => {
            for e in v {
                check_item_defined_transformation_ref(model, e)?;
            }
        }
        TransformationRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_trimming_select_ref(model: &StepModel, r: &TrimmingSelectRef) -> Result<(), AuthorError> {
    match r {
        TrimmingSelectRef::ApllPoint(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT",
            });
        }
        TrimmingSelectRef::ApllPointWithSurface(_) => {
            return Err(AuthorError::NotAp242 {
                entity: "APLL_POINT_WITH_SURFACE",
            });
        }
        TrimmingSelectRef::CartesianPoint(i) => {
            if i.0 >= model.cartesian_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CARTESIAN_POINT",
                });
            }
        }
        TrimmingSelectRef::ParameterValue(_) => {}
    }
    Ok(())
}
fn check_two_direction_repeat_factor_ref(
    model: &StepModel,
    r: &TwoDirectionRepeatFactorRef,
) -> Result<(), AuthorError> {
    match r {
        TwoDirectionRepeatFactorRef::TwoDirectionRepeatFactor(i) => {
            if i.0 >= model.two_direction_repeat_factor_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TWO_DIRECTION_REPEAT_FACTOR",
                });
            }
        }
        TwoDirectionRepeatFactorRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_uncertainty_measure_with_unit_ref(
    model: &StepModel,
    r: &UncertaintyMeasureWithUnitRef,
) -> Result<(), AuthorError> {
    match r {
        UncertaintyMeasureWithUnitRef::UncertaintyMeasureWithUnit(i) => {
            if i.0 >= model.uncertainty_measure_with_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNCERTAINTY_MEASURE_WITH_UNIT",
                });
            }
        }
    }
    Ok(())
}
fn check_unit_ref(model: &StepModel, r: &UnitRef) -> Result<(), AuthorError> {
    match r {
        UnitRef::AreaUnit(i) => {
            if i.0 >= model.area_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "AREA_UNIT",
                });
            }
        }
        UnitRef::ContextDependentUnit(i) => {
            if i.0 >= model.context_dependent_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONTEXT_DEPENDENT_UNIT",
                });
            }
        }
        UnitRef::ConversionBasedUnit(i) => {
            if i.0 >= model.conversion_based_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "CONVERSION_BASED_UNIT",
                });
            }
        }
        UnitRef::DerivedUnit(i) => {
            if i.0 >= model.derived_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "DERIVED_UNIT",
                });
            }
        }
        UnitRef::LengthUnit(i) => {
            if i.0 >= model.length_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "LENGTH_UNIT",
                });
            }
        }
        UnitRef::MassUnit(i) => {
            if i.0 >= model.mass_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "MASS_UNIT",
                });
            }
        }
        UnitRef::NamedUnit(i) => {
            if i.0 >= model.named_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "NAMED_UNIT",
                });
            }
        }
        UnitRef::PlaneAngleUnit(i) => {
            if i.0 >= model.plane_angle_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PLANE_ANGLE_UNIT",
                });
            }
        }
        UnitRef::RatioUnit(i) => {
            if i.0 >= model.ratio_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "RATIO_UNIT",
                });
            }
        }
        UnitRef::SiUnit(i) => {
            if i.0 >= model.si_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "SI_UNIT" });
            }
        }
        UnitRef::SolidAngleUnit(i) => {
            if i.0 >= model.solid_angle_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "SOLID_ANGLE_UNIT",
                });
            }
        }
        UnitRef::TimeUnit(i) => {
            if i.0 >= model.time_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TIME_UNIT",
                });
            }
        }
        UnitRef::VolumeUnit(i) => {
            if i.0 >= model.volume_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VOLUME_UNIT",
                });
            }
        }
        UnitRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_value_qualifier_ref(model: &StepModel, r: &ValueQualifierRef) -> Result<(), AuthorError> {
    match r {
        ValueQualifierRef::PrecisionQualifier(i) => {
            if i.0 >= model.precision_qualifier_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRECISION_QUALIFIER",
                });
            }
        }
        ValueQualifierRef::TypeQualifier(i) => {
            if i.0 >= model.type_qualifier_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "TYPE_QUALIFIER",
                });
            }
        }
        ValueQualifierRef::UncertaintyQualifier(i) => {
            if i.0 >= model.uncertainty_qualifier_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "UNCERTAINTY_QUALIFIER",
                });
            }
        }
        ValueQualifierRef::ValueFormatTypeQualifier(i) => {
            if i.0 >= model.value_format_type_qualifier_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VALUE_FORMAT_TYPE_QUALIFIER",
                });
            }
        }
    }
    Ok(())
}
fn check_vector_ref(model: &StepModel, r: &VectorRef) -> Result<(), AuthorError> {
    match r {
        VectorRef::Vector(i) => {
            if i.0 >= model.vector_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VECTOR" });
            }
        }
        VectorRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_versioned_action_request_ref(
    model: &StepModel,
    r: &VersionedActionRequestRef,
) -> Result<(), AuthorError> {
    match r {
        VersionedActionRequestRef::VersionedActionRequest(i) => {
            if i.0 >= model.versioned_action_request_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERSIONED_ACTION_REQUEST",
                });
            }
        }
    }
    Ok(())
}
fn check_vertex_ref(model: &StepModel, r: &VertexRef) -> Result<(), AuthorError> {
    match r {
        VertexRef::Vertex(i) => {
            if i.0 >= model.vertex_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "VERTEX" });
            }
        }
        VertexRef::VertexPoint(i) => {
            if i.0 >= model.vertex_point_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_POINT",
                });
            }
        }
        VertexRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_vertex_loop_ref(model: &StepModel, r: &VertexLoopRef) -> Result<(), AuthorError> {
    match r {
        VertexLoopRef::VertexLoop(i) => {
            if i.0 >= model.vertex_loop_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VERTEX_LOOP",
                });
            }
        }
    }
    Ok(())
}
fn check_view_volume_ref(model: &StepModel, r: &ViewVolumeRef) -> Result<(), AuthorError> {
    match r {
        ViewVolumeRef::ViewVolume(i) => {
            if i.0 >= model.view_volume_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "VIEW_VOLUME",
                });
            }
        }
        ViewVolumeRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}
fn check_work_item_ref(model: &StepModel, r: &WorkItemRef) -> Result<(), AuthorError> {
    match r {
        WorkItemRef::ProductDefinitionFormation(i) => {
            if i.0 >= model.product_definition_formation_arena.items.len() {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION",
                });
            }
        }
        WorkItemRef::ProductDefinitionFormationWithSpecifiedSource(i) => {
            if i.0
                >= model
                    .product_definition_formation_with_specified_source_arena
                    .items
                    .len()
            {
                return Err(AuthorError::DanglingRef {
                    entity: "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE",
                });
            }
        }
        WorkItemRef::Complex(i) => {
            if i.0 >= model.complex_unit_arena.items.len() {
                return Err(AuthorError::DanglingRef { entity: "COMPLEX" });
            }
        }
    }
    Ok(())
}