ridl-syntax 0.10.0

//! The typed AST node structs, generated from `family.ungram`.
//!
//! @generated by `cargo xtask codegen` — do not edit by hand. The
//! xtask drift test regenerates this file into a buffer and fails
//! when the committed text differs.

use super::AstChildren;
use super::AstNode;
use super::Backing;
use super::Definition;
use super::Expr;
use super::FieldType;
use super::InterfaceMember;
use super::ParamType;
use super::StructMember;
use super::support;
use crate::syntax_kind::{SyntaxKind, SyntaxNode, SyntaxToken};
/// A `SourceFile` node (`family.ungram` rule `SourceFile`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SourceFile {
    syntax: SyntaxNode,
}
impl AstNode for SourceFile {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::SourceFile).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl SourceFile {
    pub fn package_decl(&self) -> Option<PackageDecl> {
        support::child(&self.syntax)
    }
    pub fn imports(&self) -> AstChildren<Import> {
        support::children(&self.syntax)
    }
    pub fn definitions(&self) -> AstChildren<Definition> {
        support::children(&self.syntax)
    }
    pub fn interfaces(&self) -> AstChildren<InterfaceDef> {
        support::children(&self.syntax)
    }
    pub fn services(&self) -> AstChildren<ServiceDef> {
        support::children(&self.syntax)
    }
    pub fn systems(&self) -> AstChildren<SystemDef> {
        support::children(&self.syntax)
    }
    pub fn components(&self) -> AstChildren<ComponentDef> {
        support::children(&self.syntax)
    }
    pub fn distributions(&self) -> AstChildren<DistributionDef> {
        support::children(&self.syntax)
    }
    pub fn deployments(&self) -> AstChildren<DeploymentDef> {
        support::children(&self.syntax)
    }
}
/// A `PackageDecl` node (`family.ungram` rule `PackageDecl`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PackageDecl {
    syntax: SyntaxNode,
}
impl AstNode for PackageDecl {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::PackageDecl).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl PackageDecl {
    pub fn qualified_name(&self) -> Option<QualifiedName> {
        support::child(&self.syntax)
    }
    pub fn package_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::PackageKw)
    }
}
/// A `Import` node (`family.ungram` rule `Import`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Import {
    syntax: SyntaxNode,
}
impl AstNode for Import {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::Import).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl Import {
    pub fn qualified_name(&self) -> Option<QualifiedName> {
        support::child(&self.syntax)
    }
    pub fn alias(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn import_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ImportKw)
    }
    pub fn as_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::AsKw)
    }
}
/// A `InterfaceDef` node (`family.ungram` rule `InterfaceDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct InterfaceDef {
    syntax: SyntaxNode,
}
impl AstNode for InterfaceDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::InterfaceDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl InterfaceDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn members(&self) -> AstChildren<InterfaceMember> {
        support::children(&self.syntax)
    }
    pub fn internal_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::InternalKw)
    }
    pub fn error_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ErrorKw)
    }
    pub fn interface_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::InterfaceKw)
    }
    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBrace)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBrace)
    }
}
/// A `ServiceDef` node (`family.ungram` rule `ServiceDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ServiceDef {
    syntax: SyntaxNode,
}
impl AstNode for ServiceDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ServiceDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl ServiceDef {
    pub fn name(&self) -> Option<DottedName> {
        support::child(&self.syntax)
    }
    pub fn shapes(&self) -> AstChildren<PathType> {
        support::children(&self.syntax)
    }
    pub fn inline_members(&self) -> AstChildren<InterfaceMember> {
        support::children(&self.syntax)
    }
    pub fn service_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ServiceKw)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBrace)
    }
    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBrace)
    }
}
/// A `SystemDef` node (`family.ungram` rule `SystemDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SystemDef {
    syntax: SyntaxNode,
}
impl AstNode for SystemDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::SystemDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl SystemDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn attr_block(&self) -> Option<AttrBlock> {
        support::child(&self.syntax)
    }
    pub fn lines(&self) -> AstChildren<MemberLine> {
        support::children(&self.syntax)
    }
    pub fn system_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::SystemKw)
    }
    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBrace)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBrace)
    }
}
/// A `ComponentDef` node (`family.ungram` rule `ComponentDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ComponentDef {
    syntax: SyntaxNode,
}
impl AstNode for ComponentDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ComponentDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl ComponentDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn attr_block(&self) -> Option<AttrBlock> {
        support::child(&self.syntax)
    }
    pub fn lines(&self) -> AstChildren<ComponentLine> {
        support::children(&self.syntax)
    }
    pub fn component_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ComponentKw)
    }
    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBrace)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBrace)
    }
}
/// A `DistributionDef` node (`family.ungram` rule `DistributionDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct DistributionDef {
    syntax: SyntaxNode,
}
impl AstNode for DistributionDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::DistributionDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl DistributionDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn attr_block(&self) -> Option<AttrBlock> {
        support::child(&self.syntax)
    }
    pub fn lines(&self) -> AstChildren<MemberLine> {
        support::children(&self.syntax)
    }
    pub fn distribution_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::DistributionKw)
    }
    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBrace)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBrace)
    }
}
/// A `DeploymentDef` node (`family.ungram` rule `DeploymentDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct DeploymentDef {
    syntax: SyntaxNode,
}
impl AstNode for DeploymentDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::DeploymentDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl DeploymentDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn system(&self) -> Option<Reference> {
        support::child(&self.syntax)
    }
    pub fn attr_block(&self) -> Option<AttrBlock> {
        support::child(&self.syntax)
    }
    pub fn machines(&self) -> AstChildren<MachineDef> {
        support::children(&self.syntax)
    }
    pub fn deployment_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::DeploymentKw)
    }
    pub fn for_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ForKw)
    }
    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBrace)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBrace)
    }
}
/// A `QualifiedName` node (`family.ungram` rule `QualifiedName`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct QualifiedName {
    syntax: SyntaxNode,
}
impl AstNode for QualifiedName {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::QualifiedName).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl QualifiedName {
    pub fn ident_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Ident)
    }
    pub fn boolean_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::BooleanKw)
    }
    pub fn integer_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::IntegerKw)
    }
    pub fn float_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::FloatKw)
    }
    pub fn string_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::StringKw)
    }
    pub fn bytes_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::BytesKw)
    }
    pub fn dot_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Dot)
    }
}
/// A `Name` node (`family.ungram` rule `Name`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Name {
    syntax: SyntaxNode,
}
impl AstNode for Name {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::Name).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl Name {
    pub fn ident_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Ident)
    }
}
/// A `TypeDef` node (`family.ungram` rule `TypeDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TypeDef {
    syntax: SyntaxNode,
}
impl AstNode for TypeDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::TypeDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl TypeDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn backing(&self) -> Option<Backing> {
        support::child(&self.syntax)
    }
    pub fn constraint(&self) -> Option<Constraint> {
        support::child(&self.syntax)
    }
    pub fn init_value(&self) -> Option<InitValue> {
        support::child(&self.syntax)
    }
    pub fn internal_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::InternalKw)
    }
    pub fn error_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ErrorKw)
    }
    pub fn type_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::TypeKw)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
}
/// A `ConstDef` node (`family.ungram` rule `ConstDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ConstDef {
    syntax: SyntaxNode,
}
impl AstNode for ConstDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ConstDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl ConstDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn type_ref(&self) -> Option<PathType> {
        support::child(&self.syntax)
    }
    pub fn value(&self) -> Option<Literal> {
        support::child(&self.syntax)
    }
    pub fn internal_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::InternalKw)
    }
    pub fn error_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ErrorKw)
    }
    pub fn const_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ConstKw)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
    pub fn eq_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Eq)
    }
}
/// A `StructDef` node (`family.ungram` rule `StructDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct StructDef {
    syntax: SyntaxNode,
}
impl AstNode for StructDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::StructDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl StructDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn members(&self) -> AstChildren<StructMember> {
        support::children(&self.syntax)
    }
    pub fn internal_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::InternalKw)
    }
    pub fn error_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ErrorKw)
    }
    pub fn struct_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::StructKw)
    }
    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBrace)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBrace)
    }
}
/// A `EnumDef` node (`family.ungram` rule `EnumDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct EnumDef {
    syntax: SyntaxNode,
}
impl AstNode for EnumDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::EnumDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl EnumDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn values(&self) -> AstChildren<EnumValue> {
        support::children(&self.syntax)
    }
    pub fn reserved(&self) -> AstChildren<ReservedEntry> {
        support::children(&self.syntax)
    }
    pub fn internal_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::InternalKw)
    }
    pub fn error_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ErrorKw)
    }
    pub fn enum_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::EnumKw)
    }
    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBrace)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBrace)
    }
}
/// A `EnumSetDef` node (`family.ungram` rule `EnumSetDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct EnumSetDef {
    syntax: SyntaxNode,
}
impl AstNode for EnumSetDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::EnumSetDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl EnumSetDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn bits(&self) -> AstChildren<EnumSetBit> {
        support::children(&self.syntax)
    }
    pub fn backing_ref(&self) -> Option<PathType> {
        support::child(&self.syntax)
    }
    pub fn internal_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::InternalKw)
    }
    pub fn error_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ErrorKw)
    }
    pub fn enumset_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::EnumsetKw)
    }
    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBrace)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBrace)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
}
/// A `UnionDef` node (`family.ungram` rule `UnionDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UnionDef {
    syntax: SyntaxNode,
}
impl AstNode for UnionDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::UnionDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl UnionDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn arms(&self) -> AstChildren<UnionArm> {
        support::children(&self.syntax)
    }
    pub fn reserved(&self) -> AstChildren<ReservedEntry> {
        support::children(&self.syntax)
    }
    pub fn internal_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::InternalKw)
    }
    pub fn error_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ErrorKw)
    }
    pub fn union_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::UnionKw)
    }
    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBrace)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBrace)
    }
}
/// A `Constraint` node (`family.ungram` rule `Constraint`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Constraint {
    syntax: SyntaxNode,
}
impl AstNode for Constraint {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::Constraint).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl Constraint {
    pub fn len(&self) -> Option<Bound> {
        support::child(&self.syntax)
    }
    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBracket)
    }
    pub fn dotdot_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::DotDot)
    }
    pub fn step_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::StepKw)
    }
    pub fn match_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::MatchKw)
    }
    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBracket)
    }
}
/// A `InitValue` node (`family.ungram` rule `InitValue`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct InitValue {
    syntax: SyntaxNode,
}
impl AstNode for InitValue {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::InitValue).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl InitValue {
    pub fn literal(&self) -> Option<Literal> {
        support::child(&self.syntax)
    }
    pub fn eq_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Eq)
    }
}
/// A `PrimitiveType` node (`family.ungram` rule `PrimitiveType`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PrimitiveType {
    syntax: SyntaxNode,
}
impl AstNode for PrimitiveType {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::PrimitiveType).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl PrimitiveType {
    pub fn constraint(&self) -> Option<Constraint> {
        support::child(&self.syntax)
    }
    pub fn boolean_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::BooleanKw)
    }
    pub fn integer_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::IntegerKw)
    }
    pub fn float_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::FloatKw)
    }
    pub fn string_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::StringKw)
    }
    pub fn bytes_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::BytesKw)
    }
}
/// A `UnitExpr` node (`family.ungram` rule `UnitExpr`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UnitExpr {
    syntax: SyntaxNode,
}
impl AstNode for UnitExpr {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::UnitExpr).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl UnitExpr {
    pub fn ident_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Ident)
    }
    pub fn slash_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Slash)
    }
    pub fn dot_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Dot)
    }
    pub fn percent_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Percent)
    }
}
/// A `Literal` node (`family.ungram` rule `Literal`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Literal {
    syntax: SyntaxNode,
}
impl AstNode for Literal {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::Literal).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl Literal {
    pub fn minus_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Minus)
    }
    pub fn int_number_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::IntNumber)
    }
    pub fn float_number_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::FloatNumber)
    }
    pub fn string_lit_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::String)
    }
    pub fn true_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::TrueKw)
    }
    pub fn false_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::FalseKw)
    }
    pub fn regex_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Regex)
    }
    pub fn ident_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Ident)
    }
}
/// A `Bound` node (`family.ungram` rule `Bound`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Bound {
    syntax: SyntaxNode,
}
impl AstNode for Bound {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::Bound).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl Bound {
    pub fn min(&self) -> Option<Literal> {
        support::nth_child(&self.syntax, 0usize)
    }
    pub fn max(&self) -> Option<Literal> {
        support::nth_child(&self.syntax, 1usize)
    }
    pub fn dotdot_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::DotDot)
    }
}
/// A `PathType` node (`family.ungram` rule `PathType`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PathType {
    syntax: SyntaxNode,
}
impl AstNode for PathType {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::PathType).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl PathType {
    pub fn qualified_name(&self) -> Option<QualifiedName> {
        support::child(&self.syntax)
    }
}
/// A `FieldDef` node (`family.ungram` rule `FieldDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct FieldDef {
    syntax: SyntaxNode,
}
impl AstNode for FieldDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::FieldDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl FieldDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn field_type(&self) -> Option<FieldType> {
        support::child(&self.syntax)
    }
    pub fn init_value(&self) -> Option<InitValue> {
        support::child(&self.syntax)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
}
/// A `ReservedEntry` node (`family.ungram` rule `ReservedEntry`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ReservedEntry {
    syntax: SyntaxNode,
}
impl AstNode for ReservedEntry {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ReservedEntry).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl ReservedEntry {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn literal(&self) -> Option<Literal> {
        support::child(&self.syntax)
    }
    pub fn reserved_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::ReservedKw)
    }
}
/// A `TupleType` node (`family.ungram` rule `TupleType`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TupleType {
    syntax: SyntaxNode,
}
impl AstNode for TupleType {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::TupleType).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl TupleType {
    pub fn fields(&self) -> AstChildren<TupleField> {
        support::children(&self.syntax)
    }
    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LParen)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RParen)
    }
}
/// A `ArrayType` node (`family.ungram` rule `ArrayType`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ArrayType {
    syntax: SyntaxNode,
}
impl AstNode for ArrayType {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ArrayType).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl ArrayType {
    pub fn element(&self) -> Option<FieldType> {
        support::child(&self.syntax)
    }
    pub fn bound(&self) -> Option<Bound> {
        support::child(&self.syntax)
    }
    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBracket)
    }
    pub fn semicolon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Semicolon)
    }
    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBracket)
    }
}
/// A `MapType` node (`family.ungram` rule `MapType`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MapType {
    syntax: SyntaxNode,
}
impl AstNode for MapType {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::MapType).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl MapType {
    pub fn key(&self) -> Option<FieldType> {
        support::nth_child(&self.syntax, 0usize)
    }
    pub fn value(&self) -> Option<FieldType> {
        support::nth_child(&self.syntax, 1usize)
    }
    pub fn bound(&self) -> Option<Bound> {
        support::child(&self.syntax)
    }
    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBracket)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
    pub fn semicolon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Semicolon)
    }
    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBracket)
    }
}
/// A `OptionalType` node (`family.ungram` rule `OptionalType`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct OptionalType {
    syntax: SyntaxNode,
}
impl AstNode for OptionalType {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::OptionalType).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl OptionalType {
    pub fn field_type(&self) -> Option<FieldType> {
        support::child(&self.syntax)
    }
    pub fn question_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Question)
    }
}
/// A `TupleField` node (`family.ungram` rule `TupleField`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TupleField {
    syntax: SyntaxNode,
}
impl AstNode for TupleField {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::TupleField).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl TupleField {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn field_type(&self) -> Option<FieldType> {
        support::child(&self.syntax)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
}
/// A `EnumValue` node (`family.ungram` rule `EnumValue`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct EnumValue {
    syntax: SyntaxNode,
}
impl AstNode for EnumValue {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::EnumValue).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl EnumValue {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn value(&self) -> Option<Literal> {
        support::child(&self.syntax)
    }
    pub fn eq_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Eq)
    }
}
/// A `EnumSetBit` node (`family.ungram` rule `EnumSetBit`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct EnumSetBit {
    syntax: SyntaxNode,
}
impl AstNode for EnumSetBit {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::EnumSetBit).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl EnumSetBit {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn value(&self) -> Option<Literal> {
        support::child(&self.syntax)
    }
    pub fn eq_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Eq)
    }
}
/// A `UnionArm` node (`family.ungram` rule `UnionArm`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UnionArm {
    syntax: SyntaxNode,
}
impl AstNode for UnionArm {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::UnionArm).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl UnionArm {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn type_ref(&self) -> Option<PathType> {
        support::child(&self.syntax)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
}
/// A `SignalDef` node (`family.ungram` rule `SignalDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SignalDef {
    syntax: SyntaxNode,
}
impl AstNode for SignalDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::SignalDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl SignalDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn payload(&self) -> Option<FieldType> {
        support::child(&self.syntax)
    }
    pub fn init_value(&self) -> Option<InitValue> {
        support::child(&self.syntax)
    }
    pub fn timing(&self) -> Option<Timing> {
        support::child(&self.syntax)
    }
    pub fn signal_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::SignalKw)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
}
/// A `EventDef` node (`family.ungram` rule `EventDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct EventDef {
    syntax: SyntaxNode,
}
impl AstNode for EventDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::EventDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl EventDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn payload(&self) -> Option<FieldType> {
        support::child(&self.syntax)
    }
    pub fn timing(&self) -> Option<Timing> {
        support::child(&self.syntax)
    }
    pub fn event_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::EventKw)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
}
/// A `CommandDef` node (`family.ungram` rule `CommandDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CommandDef {
    syntax: SyntaxNode,
}
impl AstNode for CommandDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::CommandDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl CommandDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn params(&self) -> Option<ParamList> {
        support::child(&self.syntax)
    }
    pub fn return_type(&self) -> Option<ReturnType> {
        support::child(&self.syntax)
    }
    pub fn timing(&self) -> Option<Timing> {
        support::child(&self.syntax)
    }
    pub fn attr_block(&self) -> Option<AttrBlock> {
        support::child(&self.syntax)
    }
    pub fn command_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::CommandKw)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
}
/// A `QueryDef` node (`family.ungram` rule `QueryDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct QueryDef {
    syntax: SyntaxNode,
}
impl AstNode for QueryDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::QueryDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl QueryDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn params(&self) -> Option<ParamList> {
        support::child(&self.syntax)
    }
    pub fn return_type(&self) -> Option<ReturnType> {
        support::child(&self.syntax)
    }
    pub fn timing(&self) -> Option<Timing> {
        support::child(&self.syntax)
    }
    pub fn attr_block(&self) -> Option<AttrBlock> {
        support::child(&self.syntax)
    }
    pub fn query_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::QueryKw)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
}
/// A `FixedDef` node (`family.ungram` rule `FixedDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct FixedDef {
    syntax: SyntaxNode,
}
impl AstNode for FixedDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::FixedDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl FixedDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn payload(&self) -> Option<FieldType> {
        support::child(&self.syntax)
    }
    pub fn timing(&self) -> Option<Timing> {
        support::child(&self.syntax)
    }
    pub fn attr_block(&self) -> Option<AttrBlock> {
        support::child(&self.syntax)
    }
    pub fn fixed_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::FixedKw)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
}
/// A `Timing` node (`family.ungram` rule `Timing`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Timing {
    syntax: SyntaxNode,
}
impl AstNode for Timing {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::Timing).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl Timing {
    pub fn range(&self) -> Option<TimingRange> {
        support::child(&self.syntax)
    }
    pub fn at_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::At)
    }
    pub fn duration_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Duration)
    }
    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBracket)
    }
    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBracket)
    }
}
/// A `ParamList` node (`family.ungram` rule `ParamList`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ParamList {
    syntax: SyntaxNode,
}
impl AstNode for ParamList {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ParamList).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl ParamList {
    pub fn params(&self) -> AstChildren<Param> {
        support::children(&self.syntax)
    }
    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LParen)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RParen)
    }
}
/// A `ReturnType` node (`family.ungram` rule `ReturnType`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ReturnType {
    syntax: SyntaxNode,
}
impl AstNode for ReturnType {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ReturnType).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl ReturnType {
    pub fn type_ref(&self) -> Option<PathType> {
        support::child(&self.syntax)
    }
    pub fn tuple_type(&self) -> Option<TupleType> {
        support::child(&self.syntax)
    }
    pub fn stream_type(&self) -> Option<StreamType> {
        support::child(&self.syntax)
    }
    pub fn fallible_type(&self) -> Option<FallibleType> {
        support::child(&self.syntax)
    }
}
/// A `AttrBlock` node (`family.ungram` rule `AttrBlock`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AttrBlock {
    syntax: SyntaxNode,
}
impl AstNode for AttrBlock {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::AttrBlock).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl AttrBlock {
    pub fn attributes(&self) -> AstChildren<Attribute> {
        support::children(&self.syntax)
    }
    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBracket)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBracket)
    }
}
/// A `Param` node (`family.ungram` rule `Param`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Param {
    syntax: SyntaxNode,
}
impl AstNode for Param {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::Param).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl Param {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn param_type(&self) -> Option<ParamType> {
        support::child(&self.syntax)
    }
    pub fn colon_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Colon)
    }
}
/// A `StreamType` node (`family.ungram` rule `StreamType`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct StreamType {
    syntax: SyntaxNode,
}
impl AstNode for StreamType {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::StreamType).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl StreamType {
    pub fn element_type(&self) -> Option<PathType> {
        support::child(&self.syntax)
    }
    pub fn lt_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Lt)
    }
    pub fn string_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::StringKw)
    }
    pub fn bytes_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::BytesKw)
    }
    pub fn gt_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Gt)
    }
}
/// A `FallibleType` node (`family.ungram` rule `FallibleType`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct FallibleType {
    syntax: SyntaxNode,
}
impl AstNode for FallibleType {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::FallibleType).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl FallibleType {
    pub fn ok(&self) -> Option<PathType> {
        support::nth_child(&self.syntax, 0usize)
    }
    pub fn err(&self) -> Option<PathType> {
        support::nth_child(&self.syntax, 1usize)
    }
    pub fn pipe_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Pipe)
    }
}
/// A `TimingRange` node (`family.ungram` rule `TimingRange`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct TimingRange {
    syntax: SyntaxNode,
}
impl AstNode for TimingRange {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::TimingRange).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl TimingRange {
    pub fn duration_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Duration)
    }
    pub fn dotdot_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::DotDot)
    }
}
/// A `DottedName` node (`family.ungram` rule `DottedName`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct DottedName {
    syntax: SyntaxNode,
}
impl AstNode for DottedName {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::DottedName).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl DottedName {
    pub fn ident_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Ident)
    }
    pub fn dot_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Dot)
    }
}
/// A `Attribute` node (`family.ungram` rule `Attribute`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Attribute {
    syntax: SyntaxNode,
}
impl AstNode for Attribute {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::Attribute).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl Attribute {
    pub fn key(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn value(&self) -> Option<AttrValue> {
        support::child(&self.syntax)
    }
    pub fn expr(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
    pub fn dot_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Dot)
    }
    pub fn eq_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Eq)
    }
    pub fn require_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RequireKw)
    }
    pub fn ensure_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::EnsureKw)
    }
}
/// A `AttrValue` node (`family.ungram` rule `AttrValue`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct AttrValue {
    syntax: SyntaxNode,
}
impl AstNode for AttrValue {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::AttrValue).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl AttrValue {
    pub fn literal(&self) -> Option<Literal> {
        support::child(&self.syntax)
    }
    pub fn values(&self) -> AstChildren<AttrValue> {
        support::children(&self.syntax)
    }
    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LParen)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RParen)
    }
}
/// A `MemberLine` node (`family.ungram` rule `MemberLine`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MemberLine {
    syntax: SyntaxNode,
}
impl AstNode for MemberLine {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::MemberLine).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl MemberLine {
    pub fn reference(&self) -> Option<Reference> {
        support::child(&self.syntax)
    }
    pub fn attr_block(&self) -> Option<AttrBlock> {
        support::child(&self.syntax)
    }
}
/// A `ComponentLine` node (`family.ungram` rule `ComponentLine`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ComponentLine {
    syntax: SyntaxNode,
}
impl AstNode for ComponentLine {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ComponentLine).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl ComponentLine {
    pub fn reference(&self) -> Option<Reference> {
        support::child(&self.syntax)
    }
    pub fn attr_block(&self) -> Option<AttrBlock> {
        support::child(&self.syntax)
    }
    pub fn offers_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::OffersKw)
    }
    pub fn requires_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RequiresKw)
    }
}
/// A `Reference` node (`family.ungram` rule `Reference`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Reference {
    syntax: SyntaxNode,
}
impl AstNode for Reference {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::Reference).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl Reference {
    pub fn qualified_name(&self) -> Option<QualifiedName> {
        support::child(&self.syntax)
    }
}
/// A `MachineDef` node (`family.ungram` rule `MachineDef`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MachineDef {
    syntax: SyntaxNode,
}
impl AstNode for MachineDef {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::MachineDef).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl MachineDef {
    pub fn name(&self) -> Option<Name> {
        support::child(&self.syntax)
    }
    pub fn attr_block(&self) -> Option<AttrBlock> {
        support::child(&self.syntax)
    }
    pub fn lines(&self) -> AstChildren<MemberLine> {
        support::children(&self.syntax)
    }
    pub fn machine_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::MachineKw)
    }
    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LBrace)
    }
    pub fn comma_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Comma)
    }
    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RBrace)
    }
}
/// A `BinaryExpr` node (`family.ungram` rule `BinaryExpr`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct BinaryExpr {
    syntax: SyntaxNode,
}
impl AstNode for BinaryExpr {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::BinaryExpr).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl BinaryExpr {
    pub fn lhs(&self) -> Option<Expr> {
        support::nth_child(&self.syntax, 0usize)
    }
    pub fn rhs(&self) -> Option<Expr> {
        support::nth_child(&self.syntax, 1usize)
    }
    pub fn pipepipe_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::PipePipe)
    }
    pub fn ampamp_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::AmpAmp)
    }
    pub fn eqeq_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::EqEq)
    }
    pub fn neq_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Neq)
    }
    pub fn lt_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Lt)
    }
    pub fn le_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Le)
    }
    pub fn gt_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Gt)
    }
    pub fn ge_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Ge)
    }
    pub fn plus_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Plus)
    }
    pub fn minus_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Minus)
    }
    pub fn star_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Star)
    }
    pub fn slash_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Slash)
    }
    pub fn percent_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Percent)
    }
}
/// A `PrefixExpr` node (`family.ungram` rule `PrefixExpr`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PrefixExpr {
    syntax: SyntaxNode,
}
impl AstNode for PrefixExpr {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::PrefixExpr).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl PrefixExpr {
    pub fn operand(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
    pub fn bang_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Bang)
    }
    pub fn minus_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Minus)
    }
}
/// A `MemberExpr` node (`family.ungram` rule `MemberExpr`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MemberExpr {
    syntax: SyntaxNode,
}
impl AstNode for MemberExpr {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::MemberExpr).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl MemberExpr {
    pub fn base(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
    pub fn dot_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Dot)
    }
    pub fn ident_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Ident)
    }
}
/// A `PathExpr` node (`family.ungram` rule `PathExpr`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PathExpr {
    syntax: SyntaxNode,
}
impl AstNode for PathExpr {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::PathExpr).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl PathExpr {
    pub fn ident_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Ident)
    }
}
/// A `ParenExpr` node (`family.ungram` rule `ParenExpr`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ParenExpr {
    syntax: SyntaxNode,
}
impl AstNode for ParenExpr {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ParenExpr).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl ParenExpr {
    pub fn inner(&self) -> Option<Expr> {
        support::child(&self.syntax)
    }
    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::LParen)
    }
    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::RParen)
    }
}
/// A `LiteralExpr` node (`family.ungram` rule `LiteralExpr`).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct LiteralExpr {
    syntax: SyntaxNode,
}
impl AstNode for LiteralExpr {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::LiteralExpr).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}
impl LiteralExpr {
    pub fn int_number_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::IntNumber)
    }
    pub fn float_number_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::FloatNumber)
    }
    pub fn string_lit_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::String)
    }
    pub fn true_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::TrueKw)
    }
    pub fn false_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::FalseKw)
    }
    pub fn duration_token(&self) -> Option<SyntaxToken> {
        support::token(&self.syntax, SyntaxKind::Duration)
    }
}
/// An error-recovery node wrapping the tokens the parser skipped.
/// The one node kind with no rule in `family.ungram`.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ErrorNode {
    syntax: SyntaxNode,
}
impl AstNode for ErrorNode {
    fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ErrorNode).then_some(Self { syntax })
    }
    fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}