treesitter-types-typescript 0.1.0

#[derive(Debug, Clone)]
pub enum Declaration<'tree> {
    AbstractClassDeclaration(::std::boxed::Box<AbstractClassDeclaration<'tree>>),
    AmbientDeclaration(::std::boxed::Box<AmbientDeclaration<'tree>>),
    ClassDeclaration(::std::boxed::Box<ClassDeclaration<'tree>>),
    EnumDeclaration(::std::boxed::Box<EnumDeclaration<'tree>>),
    FunctionDeclaration(::std::boxed::Box<FunctionDeclaration<'tree>>),
    FunctionSignature(::std::boxed::Box<FunctionSignature<'tree>>),
    GeneratorFunctionDeclaration(::std::boxed::Box<GeneratorFunctionDeclaration<'tree>>),
    ImportAlias(::std::boxed::Box<ImportAlias<'tree>>),
    InterfaceDeclaration(::std::boxed::Box<InterfaceDeclaration<'tree>>),
    InternalModule(::std::boxed::Box<InternalModule<'tree>>),
    LexicalDeclaration(::std::boxed::Box<LexicalDeclaration<'tree>>),
    Module(::std::boxed::Box<Module<'tree>>),
    TypeAliasDeclaration(::std::boxed::Box<TypeAliasDeclaration<'tree>>),
    VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Declaration<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "abstract_class_declaration" => {
                Ok(Self::AbstractClassDeclaration(::std::boxed::Box::new(
                    <AbstractClassDeclaration as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "ambient_declaration" => Ok(Self::AmbientDeclaration(::std::boxed::Box::new(
                <AmbientDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "class_declaration" => Ok(Self::ClassDeclaration(::std::boxed::Box::new(
                <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "enum_declaration" => Ok(Self::EnumDeclaration(::std::boxed::Box::new(
                <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "function_declaration" => Ok(Self::FunctionDeclaration(::std::boxed::Box::new(
                <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "function_signature" => Ok(Self::FunctionSignature(::std::boxed::Box::new(
                <FunctionSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "generator_function_declaration" => {
                Ok(Self::GeneratorFunctionDeclaration(::std::boxed::Box::new(
                    <GeneratorFunctionDeclaration as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "import_alias" => Ok(Self::ImportAlias(::std::boxed::Box::new(
                <ImportAlias as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "interface_declaration" => Ok(Self::InterfaceDeclaration(::std::boxed::Box::new(
                <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "internal_module" => Ok(Self::InternalModule(::std::boxed::Box::new(
                <InternalModule as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "lexical_declaration" => Ok(Self::LexicalDeclaration(::std::boxed::Box::new(
                <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "module" => Ok(Self::Module(::std::boxed::Box::new(
                <Module as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_alias_declaration" => Ok(Self::TypeAliasDeclaration(::std::boxed::Box::new(
                <TypeAliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
                <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for Declaration<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AbstractClassDeclaration(inner) => inner.span(),
            Self::AmbientDeclaration(inner) => inner.span(),
            Self::ClassDeclaration(inner) => inner.span(),
            Self::EnumDeclaration(inner) => inner.span(),
            Self::FunctionDeclaration(inner) => inner.span(),
            Self::FunctionSignature(inner) => inner.span(),
            Self::GeneratorFunctionDeclaration(inner) => inner.span(),
            Self::ImportAlias(inner) => inner.span(),
            Self::InterfaceDeclaration(inner) => inner.span(),
            Self::InternalModule(inner) => inner.span(),
            Self::LexicalDeclaration(inner) => inner.span(),
            Self::Module(inner) => inner.span(),
            Self::TypeAliasDeclaration(inner) => inner.span(),
            Self::VariableDeclaration(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum Expression<'tree> {
    AsExpression(::std::boxed::Box<AsExpression<'tree>>),
    AssignmentExpression(::std::boxed::Box<AssignmentExpression<'tree>>),
    AugmentedAssignmentExpression(::std::boxed::Box<AugmentedAssignmentExpression<'tree>>),
    AwaitExpression(::std::boxed::Box<AwaitExpression<'tree>>),
    BinaryExpression(::std::boxed::Box<BinaryExpression<'tree>>),
    InstantiationExpression(::std::boxed::Box<InstantiationExpression<'tree>>),
    InternalModule(::std::boxed::Box<InternalModule<'tree>>),
    NewExpression(::std::boxed::Box<NewExpression<'tree>>),
    PrimaryExpression(::std::boxed::Box<PrimaryExpression<'tree>>),
    SatisfiesExpression(::std::boxed::Box<SatisfiesExpression<'tree>>),
    TernaryExpression(::std::boxed::Box<TernaryExpression<'tree>>),
    TypeAssertion(::std::boxed::Box<TypeAssertion<'tree>>),
    UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
    UpdateExpression(::std::boxed::Box<UpdateExpression<'tree>>),
    YieldExpression(::std::boxed::Box<YieldExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Expression<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "as_expression" => Ok(Self::AsExpression(::std::boxed::Box::new(
                <AsExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "assignment_expression" => Ok(Self::AssignmentExpression(::std::boxed::Box::new(
                <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "augmented_assignment_expression" => {
                Ok(Self::AugmentedAssignmentExpression(::std::boxed::Box::new(
                    <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "await_expression" => Ok(Self::AwaitExpression(::std::boxed::Box::new(
                <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "binary_expression" => Ok(Self::BinaryExpression(::std::boxed::Box::new(
                <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "instantiation_expression" => {
                Ok(Self::InstantiationExpression(::std::boxed::Box::new(
                    <InstantiationExpression as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "internal_module" => Ok(Self::InternalModule(::std::boxed::Box::new(
                <InternalModule as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "new_expression" => Ok(Self::NewExpression(::std::boxed::Box::new(
                <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "satisfies_expression" => Ok(Self::SatisfiesExpression(::std::boxed::Box::new(
                <SatisfiesExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "ternary_expression" => Ok(Self::TernaryExpression(::std::boxed::Box::new(
                <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_assertion" => Ok(Self::TypeAssertion(::std::boxed::Box::new(
                <TypeAssertion as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
                <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "update_expression" => Ok(Self::UpdateExpression(::std::boxed::Box::new(
                <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "yield_expression" => Ok(Self::YieldExpression(::std::boxed::Box::new(
                <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) =
                    <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
                {
                    Ok(Self::PrimaryExpression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for Expression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AsExpression(inner) => inner.span(),
            Self::AssignmentExpression(inner) => inner.span(),
            Self::AugmentedAssignmentExpression(inner) => inner.span(),
            Self::AwaitExpression(inner) => inner.span(),
            Self::BinaryExpression(inner) => inner.span(),
            Self::InstantiationExpression(inner) => inner.span(),
            Self::InternalModule(inner) => inner.span(),
            Self::NewExpression(inner) => inner.span(),
            Self::PrimaryExpression(inner) => inner.span(),
            Self::SatisfiesExpression(inner) => inner.span(),
            Self::TernaryExpression(inner) => inner.span(),
            Self::TypeAssertion(inner) => inner.span(),
            Self::UnaryExpression(inner) => inner.span(),
            Self::UpdateExpression(inner) => inner.span(),
            Self::YieldExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum Pattern<'tree> {
    ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
    NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
    ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
    RestPattern(::std::boxed::Box<RestPattern<'tree>>),
    SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
    Undefined(::std::boxed::Box<Undefined<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Pattern<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
                <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
                <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
                <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "rest_pattern" => Ok(Self::RestPattern(::std::boxed::Box::new(
                <RestPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
                <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
                <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for Pattern<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ArrayPattern(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::NonNullExpression(inner) => inner.span(),
            Self::ObjectPattern(inner) => inner.span(),
            Self::RestPattern(inner) => inner.span(),
            Self::SubscriptExpression(inner) => inner.span(),
            Self::Undefined(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum PrimaryExpression<'tree> {
    Array(::std::boxed::Box<Array<'tree>>),
    ArrowFunction(::std::boxed::Box<ArrowFunction<'tree>>),
    CallExpression(::std::boxed::Box<CallExpression<'tree>>),
    Class(::std::boxed::Box<Class<'tree>>),
    False(::std::boxed::Box<False<'tree>>),
    FunctionExpression(::std::boxed::Box<FunctionExpression<'tree>>),
    GeneratorFunction(::std::boxed::Box<GeneratorFunction<'tree>>),
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
    MetaProperty(::std::boxed::Box<MetaProperty<'tree>>),
    NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
    Null(::std::boxed::Box<Null<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    Object(::std::boxed::Box<Object<'tree>>),
    ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
    Regex(::std::boxed::Box<Regex<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
    SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
    Super(::std::boxed::Box<Super<'tree>>),
    TemplateString(::std::boxed::Box<TemplateString<'tree>>),
    This(::std::boxed::Box<This<'tree>>),
    True(::std::boxed::Box<True<'tree>>),
    Undefined(::std::boxed::Box<Undefined<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryExpression<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "array" => Ok(Self::Array(::std::boxed::Box::new(
                <Array as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "arrow_function" => Ok(Self::ArrowFunction(::std::boxed::Box::new(
                <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
                <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "class" => Ok(Self::Class(::std::boxed::Box::new(
                <Class as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "false" => Ok(Self::False(::std::boxed::Box::new(
                <False as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "function_expression" => Ok(Self::FunctionExpression(::std::boxed::Box::new(
                <FunctionExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "generator_function" => Ok(Self::GeneratorFunction(::std::boxed::Box::new(
                <GeneratorFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "meta_property" => Ok(Self::MetaProperty(::std::boxed::Box::new(
                <MetaProperty as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
                <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "null" => Ok(Self::Null(::std::boxed::Box::new(
                <Null as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "object" => Ok(Self::Object(::std::boxed::Box::new(
                <Object as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "parenthesized_expression" => {
                Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
                    <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "regex" => Ok(Self::Regex(::std::boxed::Box::new(
                <Regex as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
                <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "super" => Ok(Self::Super(::std::boxed::Box::new(
                <Super as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "template_string" => Ok(Self::TemplateString(::std::boxed::Box::new(
                <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "this" => Ok(Self::This(::std::boxed::Box::new(
                <This as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "true" => Ok(Self::True(::std::boxed::Box::new(
                <True as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
                <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for PrimaryExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Array(inner) => inner.span(),
            Self::ArrowFunction(inner) => inner.span(),
            Self::CallExpression(inner) => inner.span(),
            Self::Class(inner) => inner.span(),
            Self::False(inner) => inner.span(),
            Self::FunctionExpression(inner) => inner.span(),
            Self::GeneratorFunction(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::MetaProperty(inner) => inner.span(),
            Self::NonNullExpression(inner) => inner.span(),
            Self::Null(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::Object(inner) => inner.span(),
            Self::ParenthesizedExpression(inner) => inner.span(),
            Self::Regex(inner) => inner.span(),
            Self::String(inner) => inner.span(),
            Self::SubscriptExpression(inner) => inner.span(),
            Self::Super(inner) => inner.span(),
            Self::TemplateString(inner) => inner.span(),
            Self::This(inner) => inner.span(),
            Self::True(inner) => inner.span(),
            Self::Undefined(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum PrimaryType<'tree> {
    ArrayType(::std::boxed::Box<ArrayType<'tree>>),
    ConditionalType(::std::boxed::Box<ConditionalType<'tree>>),
    Const(::treesitter_types::Span),
    ExistentialType(::std::boxed::Box<ExistentialType<'tree>>),
    FlowMaybeType(::std::boxed::Box<FlowMaybeType<'tree>>),
    GenericType(::std::boxed::Box<GenericType<'tree>>),
    IndexTypeQuery(::std::boxed::Box<IndexTypeQuery<'tree>>),
    IntersectionType(::std::boxed::Box<IntersectionType<'tree>>),
    LiteralType(::std::boxed::Box<LiteralType<'tree>>),
    LookupType(::std::boxed::Box<LookupType<'tree>>),
    NestedTypeIdentifier(::std::boxed::Box<NestedTypeIdentifier<'tree>>),
    ObjectType(::std::boxed::Box<ObjectType<'tree>>),
    ParenthesizedType(::std::boxed::Box<ParenthesizedType<'tree>>),
    PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
    TemplateLiteralType(::std::boxed::Box<TemplateLiteralType<'tree>>),
    ThisType(::std::boxed::Box<ThisType<'tree>>),
    TupleType(::std::boxed::Box<TupleType<'tree>>),
    TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
    TypeQuery(::std::boxed::Box<TypeQuery<'tree>>),
    UnionType(::std::boxed::Box<UnionType<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PrimaryType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "array_type" => Ok(Self::ArrayType(::std::boxed::Box::new(
                <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "conditional_type" => Ok(Self::ConditionalType(::std::boxed::Box::new(
                <ConditionalType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
            "existential_type" => Ok(Self::ExistentialType(::std::boxed::Box::new(
                <ExistentialType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "flow_maybe_type" => Ok(Self::FlowMaybeType(::std::boxed::Box::new(
                <FlowMaybeType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
                <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "index_type_query" => Ok(Self::IndexTypeQuery(::std::boxed::Box::new(
                <IndexTypeQuery as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "intersection_type" => Ok(Self::IntersectionType(::std::boxed::Box::new(
                <IntersectionType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "literal_type" => Ok(Self::LiteralType(::std::boxed::Box::new(
                <LiteralType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "lookup_type" => Ok(Self::LookupType(::std::boxed::Box::new(
                <LookupType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "nested_type_identifier" => Ok(Self::NestedTypeIdentifier(::std::boxed::Box::new(
                <NestedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "object_type" => Ok(Self::ObjectType(::std::boxed::Box::new(
                <ObjectType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "parenthesized_type" => Ok(Self::ParenthesizedType(::std::boxed::Box::new(
                <ParenthesizedType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
                <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "template_literal_type" => Ok(Self::TemplateLiteralType(::std::boxed::Box::new(
                <TemplateLiteralType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "this_type" => Ok(Self::ThisType(::std::boxed::Box::new(
                <ThisType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "tuple_type" => Ok(Self::TupleType(::std::boxed::Box::new(
                <TupleType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_query" => Ok(Self::TypeQuery(::std::boxed::Box::new(
                <TypeQuery as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "union_type" => Ok(Self::UnionType(::std::boxed::Box::new(
                <UnionType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for PrimaryType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ArrayType(inner) => inner.span(),
            Self::ConditionalType(inner) => inner.span(),
            Self::Const(span) => *span,
            Self::ExistentialType(inner) => inner.span(),
            Self::FlowMaybeType(inner) => inner.span(),
            Self::GenericType(inner) => inner.span(),
            Self::IndexTypeQuery(inner) => inner.span(),
            Self::IntersectionType(inner) => inner.span(),
            Self::LiteralType(inner) => inner.span(),
            Self::LookupType(inner) => inner.span(),
            Self::NestedTypeIdentifier(inner) => inner.span(),
            Self::ObjectType(inner) => inner.span(),
            Self::ParenthesizedType(inner) => inner.span(),
            Self::PredefinedType(inner) => inner.span(),
            Self::TemplateLiteralType(inner) => inner.span(),
            Self::ThisType(inner) => inner.span(),
            Self::TupleType(inner) => inner.span(),
            Self::TypeIdentifier(inner) => inner.span(),
            Self::TypeQuery(inner) => inner.span(),
            Self::UnionType(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum Statement<'tree> {
    BreakStatement(::std::boxed::Box<BreakStatement<'tree>>),
    ContinueStatement(::std::boxed::Box<ContinueStatement<'tree>>),
    DebuggerStatement(::std::boxed::Box<DebuggerStatement<'tree>>),
    Declaration(::std::boxed::Box<Declaration<'tree>>),
    DoStatement(::std::boxed::Box<DoStatement<'tree>>),
    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
    ExportStatement(::std::boxed::Box<ExportStatement<'tree>>),
    ExpressionStatement(::std::boxed::Box<ExpressionStatement<'tree>>),
    ForInStatement(::std::boxed::Box<ForInStatement<'tree>>),
    ForStatement(::std::boxed::Box<ForStatement<'tree>>),
    IfStatement(::std::boxed::Box<IfStatement<'tree>>),
    ImportStatement(::std::boxed::Box<ImportStatement<'tree>>),
    LabeledStatement(::std::boxed::Box<LabeledStatement<'tree>>),
    ReturnStatement(::std::boxed::Box<ReturnStatement<'tree>>),
    StatementBlock(::std::boxed::Box<StatementBlock<'tree>>),
    SwitchStatement(::std::boxed::Box<SwitchStatement<'tree>>),
    ThrowStatement(::std::boxed::Box<ThrowStatement<'tree>>),
    TryStatement(::std::boxed::Box<TryStatement<'tree>>),
    WhileStatement(::std::boxed::Box<WhileStatement<'tree>>),
    WithStatement(::std::boxed::Box<WithStatement<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Statement<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "break_statement" => Ok(Self::BreakStatement(::std::boxed::Box::new(
                <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "continue_statement" => Ok(Self::ContinueStatement(::std::boxed::Box::new(
                <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "debugger_statement" => Ok(Self::DebuggerStatement(::std::boxed::Box::new(
                <DebuggerStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "do_statement" => Ok(Self::DoStatement(::std::boxed::Box::new(
                <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
                <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "export_statement" => Ok(Self::ExportStatement(::std::boxed::Box::new(
                <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "expression_statement" => Ok(Self::ExpressionStatement(::std::boxed::Box::new(
                <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "for_in_statement" => Ok(Self::ForInStatement(::std::boxed::Box::new(
                <ForInStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "for_statement" => Ok(Self::ForStatement(::std::boxed::Box::new(
                <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "if_statement" => Ok(Self::IfStatement(::std::boxed::Box::new(
                <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "import_statement" => Ok(Self::ImportStatement(::std::boxed::Box::new(
                <ImportStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "labeled_statement" => Ok(Self::LabeledStatement(::std::boxed::Box::new(
                <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "return_statement" => Ok(Self::ReturnStatement(::std::boxed::Box::new(
                <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "statement_block" => Ok(Self::StatementBlock(::std::boxed::Box::new(
                <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "switch_statement" => Ok(Self::SwitchStatement(::std::boxed::Box::new(
                <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "throw_statement" => Ok(Self::ThrowStatement(::std::boxed::Box::new(
                <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "try_statement" => Ok(Self::TryStatement(::std::boxed::Box::new(
                <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "while_statement" => Ok(Self::WhileStatement(::std::boxed::Box::new(
                <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "with_statement" => Ok(Self::WithStatement(::std::boxed::Box::new(
                <WithStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Declaration as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Declaration(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for Statement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::BreakStatement(inner) => inner.span(),
            Self::ContinueStatement(inner) => inner.span(),
            Self::DebuggerStatement(inner) => inner.span(),
            Self::Declaration(inner) => inner.span(),
            Self::DoStatement(inner) => inner.span(),
            Self::EmptyStatement(inner) => inner.span(),
            Self::ExportStatement(inner) => inner.span(),
            Self::ExpressionStatement(inner) => inner.span(),
            Self::ForInStatement(inner) => inner.span(),
            Self::ForStatement(inner) => inner.span(),
            Self::IfStatement(inner) => inner.span(),
            Self::ImportStatement(inner) => inner.span(),
            Self::LabeledStatement(inner) => inner.span(),
            Self::ReturnStatement(inner) => inner.span(),
            Self::StatementBlock(inner) => inner.span(),
            Self::SwitchStatement(inner) => inner.span(),
            Self::ThrowStatement(inner) => inner.span(),
            Self::TryStatement(inner) => inner.span(),
            Self::WhileStatement(inner) => inner.span(),
            Self::WithStatement(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum Type<'tree> {
    CallExpression(::std::boxed::Box<CallExpression<'tree>>),
    ConstructorType(::std::boxed::Box<ConstructorType<'tree>>),
    FunctionType(::std::boxed::Box<FunctionType<'tree>>),
    InferType(::std::boxed::Box<InferType<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
    PrimaryType(::std::boxed::Box<PrimaryType<'tree>>),
    ReadonlyType(::std::boxed::Box<ReadonlyType<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Type<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
                <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "constructor_type" => Ok(Self::ConstructorType(::std::boxed::Box::new(
                <ConstructorType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "function_type" => Ok(Self::FunctionType(::std::boxed::Box::new(
                <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "infer_type" => Ok(Self::InferType(::std::boxed::Box::new(
                <InferType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "readonly_type" => Ok(Self::ReadonlyType(::std::boxed::Box::new(
                <ReadonlyType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <PrimaryType as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::PrimaryType(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for Type<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::CallExpression(inner) => inner.span(),
            Self::ConstructorType(inner) => inner.span(),
            Self::FunctionType(inner) => inner.span(),
            Self::InferType(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::PrimaryType(inner) => inner.span(),
            Self::ReadonlyType(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub struct AbstractClassDeclaration<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: ClassBody<'tree>,
    pub decorator: ::std::vec::Vec<Decorator<'tree>>,
    pub name: TypeIdentifier<'tree>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
    pub children: ::core::option::Option<ClassHeritage<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractClassDeclaration<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "abstract_class_declaration");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            decorator: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("decorator", &mut cursor) {
                    items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                match non_field_children.first() {
                    Some(&child) => Some(
                        <ClassHeritage as ::treesitter_types::FromNode>::from_node(child, src)?,
                    ),
                    None => None,
                }
            },
        })
    }
}
impl ::treesitter_types::Spanned for AbstractClassDeclaration<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct AbstractMethodSignature<'tree> {
    pub span: ::treesitter_types::Span,
    pub name: AbstractMethodSignatureName<'tree>,
    pub parameters: FormalParameters<'tree>,
    pub return_type: ::core::option::Option<AbstractMethodSignatureReturnType<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
    pub children: ::std::vec::Vec<AbstractMethodSignatureChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractMethodSignature<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "abstract_method_signature");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <AbstractMethodSignatureName as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?
            },
            parameters: {
                let child = node.child_by_field_name("parameters").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("parameters", node)
                })?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            return_type: match node.child_by_field_name("return_type") {
                Some(child) => Some(
                    <AbstractMethodSignatureReturnType as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items
                        .push(
                            <AbstractMethodSignatureChildren as ::treesitter_types::FromNode>::from_node(
                                child,
                                src,
                            )?,
                        );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for AbstractMethodSignature<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct AccessibilityModifier<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AccessibilityModifier<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "accessibility_modifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for AccessibilityModifier<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for AccessibilityModifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct AddingTypeAnnotation<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AddingTypeAnnotation<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "adding_type_annotation");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for AddingTypeAnnotation<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct AmbientDeclaration<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<AmbientDeclarationChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AmbientDeclaration<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "ambient_declaration");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <AmbientDeclarationChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for AmbientDeclaration<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Arguments<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ArgumentsChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Arguments<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "arguments");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ArgumentsChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for Arguments<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Array<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ArrayChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Array<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "array");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<ArrayChildren as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for Array<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ArrayPattern<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ArrayPatternChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPattern<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "array_pattern");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ArrayPatternChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ArrayPattern<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ArrayType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: PrimaryType<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "array_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <PrimaryType as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ArrayType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ArrowFunction<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: ArrowFunctionBody<'tree>,
    pub parameter: ::core::option::Option<Identifier<'tree>>,
    pub parameters: ::core::option::Option<FormalParameters<'tree>>,
    pub return_type: ::core::option::Option<ArrowFunctionReturnType<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunction<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "arrow_function");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <ArrowFunctionBody as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            parameter: match node.child_by_field_name("parameter") {
                Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            parameters: match node.child_by_field_name("parameters") {
                Some(child) => {
                    Some(<FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?)
                }
                None => None,
            },
            return_type: match node.child_by_field_name("return_type") {
                Some(child) => Some(
                    <ArrowFunctionReturnType as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for ArrowFunction<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct AsExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<AsExpressionChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AsExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "as_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <AsExpressionChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for AsExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Asserts<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: AssertsChildren<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Asserts<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "asserts");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <AssertsChildren as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for Asserts<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct AssertsAnnotation<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Asserts<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AssertsAnnotation<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "asserts_annotation");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Asserts as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for AssertsAnnotation<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct AssignmentExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub left: AssignmentExpressionLeft<'tree>,
    pub right: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "assignment_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            left: {
                let child = node
                    .child_by_field_name("left")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
                <AssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            right: {
                let child = node
                    .child_by_field_name("right")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for AssignmentExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct AssignmentPattern<'tree> {
    pub span: ::treesitter_types::Span,
    pub left: Pattern<'tree>,
    pub right: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentPattern<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "assignment_pattern");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            left: {
                let child = node
                    .child_by_field_name("left")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
                <Pattern as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            right: {
                let child = node
                    .child_by_field_name("right")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for AssignmentPattern<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct AugmentedAssignmentExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub left: AugmentedAssignmentExpressionLeft<'tree>,
    pub operator: AugmentedAssignmentExpressionOperator,
    pub right: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "augmented_assignment_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            left: {
                let child = node
                    .child_by_field_name("left")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
                <AugmentedAssignmentExpressionLeft as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?
            },
            operator: {
                let child = node.child_by_field_name("operator").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("operator", node)
                })?;
                <AugmentedAssignmentExpressionOperator as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?
            },
            right: {
                let child = node
                    .child_by_field_name("right")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for AugmentedAssignmentExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct AwaitExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AwaitExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "await_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for AwaitExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct BinaryExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub left: BinaryExpressionLeft<'tree>,
    pub operator: BinaryExpressionOperator,
    pub right: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "binary_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            left: {
                let child = node
                    .child_by_field_name("left")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
                <BinaryExpressionLeft as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            operator: {
                let child = node.child_by_field_name("operator").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("operator", node)
                })?;
                <BinaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            right: {
                let child = node
                    .child_by_field_name("right")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for BinaryExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct BreakStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub label: ::core::option::Option<StatementIdentifier<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for BreakStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "break_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            label: match node.child_by_field_name("label") {
                Some(child) => Some(
                    <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?,
                ),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for BreakStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct CallExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub arguments: CallExpressionArguments<'tree>,
    pub function: CallExpressionFunction<'tree>,
    pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "call_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            arguments: {
                let child = node.child_by_field_name("arguments").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("arguments", node)
                })?;
                <CallExpressionArguments as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            function: {
                let child = node.child_by_field_name("function").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("function", node)
                })?;
                <CallExpressionFunction as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            type_arguments: match node.child_by_field_name("type_arguments") {
                Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for CallExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct CallSignature<'tree> {
    pub span: ::treesitter_types::Span,
    pub parameters: FormalParameters<'tree>,
    pub return_type: ::core::option::Option<CallSignatureReturnType<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for CallSignature<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "call_signature");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            parameters: {
                let child = node.child_by_field_name("parameters").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("parameters", node)
                })?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            return_type: match node.child_by_field_name("return_type") {
                Some(child) => Some(
                    <CallSignatureReturnType as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for CallSignature<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct CatchClause<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: StatementBlock<'tree>,
    pub parameter: ::core::option::Option<CatchClauseParameter<'tree>>,
    pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClause<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "catch_clause");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            parameter: match node.child_by_field_name("parameter") {
                Some(child) => Some(
                    <CatchClauseParameter as ::treesitter_types::FromNode>::from_node(child, src)?,
                ),
                None => None,
            },
            r#type: match node.child_by_field_name("type") {
                Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for CatchClause<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Class<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: ClassBody<'tree>,
    pub decorator: ::std::vec::Vec<Decorator<'tree>>,
    pub name: ::core::option::Option<TypeIdentifier<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
    pub children: ::core::option::Option<ClassHeritage<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Class<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "class");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            decorator: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("decorator", &mut cursor) {
                    items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
            name: match node.child_by_field_name("name") {
                Some(child) => Some(<TypeIdentifier as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                match non_field_children.first() {
                    Some(&child) => Some(
                        <ClassHeritage as ::treesitter_types::FromNode>::from_node(child, src)?,
                    ),
                    None => None,
                }
            },
        })
    }
}
impl ::treesitter_types::Spanned for Class<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ClassBody<'tree> {
    pub span: ::treesitter_types::Span,
    pub decorator: ::std::vec::Vec<Decorator<'tree>>,
    pub children: ::std::vec::Vec<ClassBodyChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBody<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "class_body");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            decorator: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("decorator", &mut cursor) {
                    items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ClassBodyChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ClassBody<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ClassDeclaration<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: ClassBody<'tree>,
    pub decorator: ::std::vec::Vec<Decorator<'tree>>,
    pub name: TypeIdentifier<'tree>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
    pub children: ::core::option::Option<ClassHeritage<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ClassDeclaration<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "class_declaration");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <ClassBody as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            decorator: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("decorator", &mut cursor) {
                    items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                match non_field_children.first() {
                    Some(&child) => Some(
                        <ClassHeritage as ::treesitter_types::FromNode>::from_node(child, src)?,
                    ),
                    None => None,
                }
            },
        })
    }
}
impl ::treesitter_types::Spanned for ClassDeclaration<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ClassHeritage<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ClassHeritageChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ClassHeritage<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "class_heritage");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ClassHeritageChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ClassHeritage<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ClassStaticBlock<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: StatementBlock<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ClassStaticBlock<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "class_static_block");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ClassStaticBlock<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ComputedPropertyName<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ComputedPropertyName<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "computed_property_name");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ComputedPropertyName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ConditionalType<'tree> {
    pub span: ::treesitter_types::Span,
    pub alternative: Type<'tree>,
    pub consequence: Type<'tree>,
    pub left: Type<'tree>,
    pub right: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ConditionalType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "conditional_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            alternative: {
                let child = node.child_by_field_name("alternative").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("alternative", node)
                })?;
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            consequence: {
                let child = node.child_by_field_name("consequence").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("consequence", node)
                })?;
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            left: {
                let child = node
                    .child_by_field_name("left")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            right: {
                let child = node
                    .child_by_field_name("right")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ConditionalType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Constraint<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Constraint<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "constraint");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for Constraint<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ConstructSignature<'tree> {
    pub span: ::treesitter_types::Span,
    pub parameters: FormalParameters<'tree>,
    pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructSignature<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "construct_signature");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            parameters: {
                let child = node.child_by_field_name("parameters").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("parameters", node)
                })?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            r#type: match node.child_by_field_name("type") {
                Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for ConstructSignature<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ConstructorType<'tree> {
    pub span: ::treesitter_types::Span,
    pub parameters: FormalParameters<'tree>,
    pub r#type: Type<'tree>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ConstructorType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "constructor_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            parameters: {
                let child = node.child_by_field_name("parameters").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("parameters", node)
                })?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            r#type: {
                let child = node
                    .child_by_field_name("type")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for ConstructorType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ContinueStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub label: ::core::option::Option<StatementIdentifier<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ContinueStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "continue_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            label: match node.child_by_field_name("label") {
                Some(child) => Some(
                    <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?,
                ),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for ContinueStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct DebuggerStatement<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for DebuggerStatement<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "debugger_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for DebuggerStatement<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for DebuggerStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Decorator<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: DecoratorChildren<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Decorator<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "decorator");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <DecoratorChildren as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for Decorator<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct DefaultType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for DefaultType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "default_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for DefaultType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct DoStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: Statement<'tree>,
    pub condition: ParenthesizedExpression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for DoStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "do_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            condition: {
                let child = node.child_by_field_name("condition").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("condition", node)
                })?;
                <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for DoStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ElseClause<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Statement<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ElseClause<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "else_clause");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ElseClause<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct EmptyStatement<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for EmptyStatement<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "empty_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for EmptyStatement<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for EmptyStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct EnumAssignment<'tree> {
    pub span: ::treesitter_types::Span,
    pub name: EnumAssignmentName<'tree>,
    pub value: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for EnumAssignment<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "enum_assignment");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <EnumAssignmentName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            value: {
                let child = node
                    .child_by_field_name("value")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for EnumAssignment<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct EnumBody<'tree> {
    pub span: ::treesitter_types::Span,
    pub name: ::std::vec::Vec<EnumBodyName<'tree>>,
    pub children: ::std::vec::Vec<EnumAssignment<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBody<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "enum_body");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            name: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("name", &mut cursor) {
                    items.push(<EnumBodyName as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<EnumAssignment as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for EnumBody<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct EnumDeclaration<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: EnumBody<'tree>,
    pub name: Identifier<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for EnumDeclaration<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "enum_declaration");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <EnumBody as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for EnumDeclaration<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ExistentialType<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExistentialType<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "existential_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for ExistentialType<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for ExistentialType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ExportClause<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ExportSpecifier<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExportClause<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "export_clause");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ExportSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ExportClause<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ExportSpecifier<'tree> {
    pub span: ::treesitter_types::Span,
    pub alias: ::core::option::Option<ExportSpecifierAlias<'tree>>,
    pub name: ExportSpecifierName<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifier<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "export_specifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            alias: match node.child_by_field_name("alias") {
                Some(child) => Some(
                    <ExportSpecifierAlias as ::treesitter_types::FromNode>::from_node(child, src)?,
                ),
                None => None,
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <ExportSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ExportSpecifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ExportStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub declaration: ::core::option::Option<Declaration<'tree>>,
    pub decorator: ::std::vec::Vec<Decorator<'tree>>,
    pub source: ::core::option::Option<String<'tree>>,
    pub value: ::core::option::Option<Expression<'tree>>,
    pub children: ::core::option::Option<ExportStatementChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExportStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "export_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            declaration: match node.child_by_field_name("declaration") {
                Some(child) => Some(<Declaration as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            decorator: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("decorator", &mut cursor) {
                    items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
            source: match node.child_by_field_name("source") {
                Some(child) => Some(<String as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            value: match node.child_by_field_name("value") {
                Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                match non_field_children.first() {
                    Some(&child) => Some(
                        <ExportStatementChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    ),
                    None => None,
                }
            },
        })
    }
}
impl ::treesitter_types::Spanned for ExportStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ExpressionStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ExpressionStatementChildren<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "expression_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <ExpressionStatementChildren as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ExpressionStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ExtendsClause<'tree> {
    pub span: ::treesitter_types::Span,
    pub type_arguments: ::std::vec::Vec<TypeArguments<'tree>>,
    pub value: ::std::vec::Vec<Expression<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExtendsClause<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "extends_clause");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            type_arguments: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("type_arguments", &mut cursor) {
                    items.push(<TypeArguments as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
            value: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("value", &mut cursor) {
                    items.push(<Expression as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ExtendsClause<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ExtendsTypeClause<'tree> {
    pub span: ::treesitter_types::Span,
    pub r#type: ::std::vec::Vec<ExtendsTypeClauseType<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExtendsTypeClause<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "extends_type_clause");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            r#type: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("type", &mut cursor) {
                    items.push(
                        <ExtendsTypeClauseType as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ExtendsTypeClause<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct FinallyClause<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: StatementBlock<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FinallyClause<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "finally_clause");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for FinallyClause<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct FlowMaybeType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: PrimaryType<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FlowMaybeType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "flow_maybe_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <PrimaryType as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for FlowMaybeType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ForInStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: Statement<'tree>,
    pub kind: ::core::option::Option<ForInStatementKind>,
    pub left: ForInStatementLeft<'tree>,
    pub operator: ForInStatementOperator,
    pub right: ForInStatementRight<'tree>,
    pub value: ::core::option::Option<Expression<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "for_in_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            kind: match node.child_by_field_name("kind") {
                Some(child) => Some(
                    <ForInStatementKind as ::treesitter_types::FromNode>::from_node(child, src)?,
                ),
                None => None,
            },
            left: {
                let child = node
                    .child_by_field_name("left")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
                <ForInStatementLeft as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            operator: {
                let child = node.child_by_field_name("operator").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("operator", node)
                })?;
                <ForInStatementOperator as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            right: {
                let child = node
                    .child_by_field_name("right")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
                <ForInStatementRight as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            value: match node.child_by_field_name("value") {
                Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for ForInStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ForStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: Statement<'tree>,
    pub condition: ::std::vec::Vec<ForStatementCondition<'tree>>,
    pub increment: ::core::option::Option<ForStatementIncrement<'tree>>,
    pub initializer: ForStatementInitializer<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "for_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            condition: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("condition", &mut cursor) {
                    items.push(
                        <ForStatementCondition as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
            increment: match node.child_by_field_name("increment") {
                Some(child) => Some(
                    <ForStatementIncrement as ::treesitter_types::FromNode>::from_node(child, src)?,
                ),
                None => None,
            },
            initializer: {
                let child = node.child_by_field_name("initializer").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("initializer", node)
                })?;
                <ForStatementInitializer as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ForStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct FormalParameters<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<FormalParametersChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParameters<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "formal_parameters");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <FormalParametersChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for FormalParameters<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct FunctionDeclaration<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: StatementBlock<'tree>,
    pub name: Identifier<'tree>,
    pub parameters: FormalParameters<'tree>,
    pub return_type: ::core::option::Option<FunctionDeclarationReturnType<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclaration<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "function_declaration");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            parameters: {
                let child = node.child_by_field_name("parameters").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("parameters", node)
                })?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            return_type: match node.child_by_field_name("return_type") {
                Some(child) => Some(
                    <FunctionDeclarationReturnType as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for FunctionDeclaration<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct FunctionExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: StatementBlock<'tree>,
    pub name: ::core::option::Option<Identifier<'tree>>,
    pub parameters: FormalParameters<'tree>,
    pub return_type: ::core::option::Option<FunctionExpressionReturnType<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "function_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            name: match node.child_by_field_name("name") {
                Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            parameters: {
                let child = node.child_by_field_name("parameters").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("parameters", node)
                })?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            return_type: match node.child_by_field_name("return_type") {
                Some(child) => Some(
                    <FunctionExpressionReturnType as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for FunctionExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct FunctionSignature<'tree> {
    pub span: ::treesitter_types::Span,
    pub name: Identifier<'tree>,
    pub parameters: FormalParameters<'tree>,
    pub return_type: ::core::option::Option<FunctionSignatureReturnType<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignature<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "function_signature");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            parameters: {
                let child = node.child_by_field_name("parameters").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("parameters", node)
                })?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            return_type: match node.child_by_field_name("return_type") {
                Some(child) => Some(
                    <FunctionSignatureReturnType as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for FunctionSignature<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct FunctionType<'tree> {
    pub span: ::treesitter_types::Span,
    pub parameters: FormalParameters<'tree>,
    pub return_type: FunctionTypeReturnType<'tree>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "function_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            parameters: {
                let child = node.child_by_field_name("parameters").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("parameters", node)
                })?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            return_type: {
                let child = node.child_by_field_name("return_type").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("return_type", node)
                })?;
                <FunctionTypeReturnType as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for FunctionType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct GeneratorFunction<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: StatementBlock<'tree>,
    pub name: ::core::option::Option<Identifier<'tree>>,
    pub parameters: FormalParameters<'tree>,
    pub return_type: ::core::option::Option<GeneratorFunctionReturnType<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunction<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "generator_function");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            name: match node.child_by_field_name("name") {
                Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            parameters: {
                let child = node.child_by_field_name("parameters").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("parameters", node)
                })?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            return_type: match node.child_by_field_name("return_type") {
                Some(child) => Some(
                    <GeneratorFunctionReturnType as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for GeneratorFunction<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct GeneratorFunctionDeclaration<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: StatementBlock<'tree>,
    pub name: Identifier<'tree>,
    pub parameters: FormalParameters<'tree>,
    pub return_type: ::core::option::Option<GeneratorFunctionDeclarationReturnType<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunctionDeclaration<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "generator_function_declaration");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field(
                        "body",
                        node,
                    ))?;
                <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field(
                        "name",
                        node,
                    ))?;
                <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            parameters: {
                let child = node
                    .child_by_field_name("parameters")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field(
                        "parameters",
                        node,
                    ))?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(
                    child,
                    src,
                )?
            },
            return_type: match node.child_by_field_name("return_type") {
                Some(child) => {
                    Some(
                        <GeneratorFunctionDeclarationReturnType as ::treesitter_types::FromNode>::from_node(
                            child,
                            src,
                        )?,
                    )
                }
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => {
                    Some(
                        <TypeParameters as ::treesitter_types::FromNode>::from_node(
                            child,
                            src,
                        )?,
                    )
                }
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for GeneratorFunctionDeclaration<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct GenericType<'tree> {
    pub span: ::treesitter_types::Span,
    pub name: GenericTypeName<'tree>,
    pub type_arguments: TypeArguments<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for GenericType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "generic_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <GenericTypeName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            type_arguments: {
                let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("type_arguments", node)
                })?;
                <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for GenericType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Identifier<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "identifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for Identifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct IfStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub alternative: ::core::option::Option<ElseClause<'tree>>,
    pub condition: ParenthesizedExpression<'tree>,
    pub consequence: Statement<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for IfStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "if_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            alternative: match node.child_by_field_name("alternative") {
                Some(child) => Some(<ElseClause as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            condition: {
                let child = node.child_by_field_name("condition").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("condition", node)
                })?;
                <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            consequence: {
                let child = node.child_by_field_name("consequence").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("consequence", node)
                })?;
                <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for IfStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ImplementsClause<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<Type<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ImplementsClause<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "implements_clause");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<Type as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ImplementsClause<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Import<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Import<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "import");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for Import<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for Import<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ImportAlias<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ImportAliasChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ImportAlias<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "import_alias");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ImportAliasChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ImportAlias<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ImportAttribute<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Object<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ImportAttribute<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "import_attribute");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Object as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ImportAttribute<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ImportClause<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ImportClauseChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ImportClause<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "import_clause");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ImportClauseChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ImportClause<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ImportRequireClause<'tree> {
    pub span: ::treesitter_types::Span,
    pub source: String<'tree>,
    pub children: Identifier<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ImportRequireClause<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "import_require_clause");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            source: {
                let child = node
                    .child_by_field_name("source")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("source", node))?;
                <String as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ImportRequireClause<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ImportSpecifier<'tree> {
    pub span: ::treesitter_types::Span,
    pub alias: ::core::option::Option<Identifier<'tree>>,
    pub name: ImportSpecifierName<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpecifier<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "import_specifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            alias: match node.child_by_field_name("alias") {
                Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <ImportSpecifierName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ImportSpecifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ImportStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub source: ::core::option::Option<String<'tree>>,
    pub children: ::std::vec::Vec<ImportStatementChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ImportStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "import_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            source: match node.child_by_field_name("source") {
                Some(child) => Some(<String as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ImportStatementChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ImportStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct IndexSignature<'tree> {
    pub span: ::treesitter_types::Span,
    pub index_type: ::core::option::Option<Type<'tree>>,
    pub name: ::core::option::Option<Identifier<'tree>>,
    pub sign: ::core::option::Option<IndexSignatureSign>,
    pub r#type: IndexSignatureType<'tree>,
    pub children: ::core::option::Option<MappedTypeClause<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for IndexSignature<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "index_signature");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            index_type: match node.child_by_field_name("index_type") {
                Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            name: match node.child_by_field_name("name") {
                Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            sign: match node.child_by_field_name("sign") {
                Some(child) => Some(
                    <IndexSignatureSign as ::treesitter_types::FromNode>::from_node(child, src)?,
                ),
                None => None,
            },
            r#type: {
                let child = node
                    .child_by_field_name("type")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
                <IndexSignatureType as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                match non_field_children.first() {
                    Some(&child) => Some(
                        <MappedTypeClause as ::treesitter_types::FromNode>::from_node(child, src)?,
                    ),
                    None => None,
                }
            },
        })
    }
}
impl ::treesitter_types::Spanned for IndexSignature<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct IndexTypeQuery<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: PrimaryType<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for IndexTypeQuery<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "index_type_query");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <PrimaryType as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for IndexTypeQuery<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct InferType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<InferTypeChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for InferType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "infer_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <InferTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for InferType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct InstantiationExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub function: ::core::option::Option<InstantiationExpressionFunction<'tree>>,
    pub type_arguments: TypeArguments<'tree>,
    pub children: ::core::option::Option<Expression<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for InstantiationExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "instantiation_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            function: match node.child_by_field_name("function") {
                Some(child) => Some(
                    <InstantiationExpressionFunction as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            type_arguments: {
                let child = node.child_by_field_name("type_arguments").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("type_arguments", node)
                })?;
                <TypeArguments as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                match non_field_children.first() {
                    Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?),
                    None => None,
                }
            },
        })
    }
}
impl ::treesitter_types::Spanned for InstantiationExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct InterfaceBody<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<InterfaceBodyChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceBody<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "interface_body");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <InterfaceBodyChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for InterfaceBody<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct InterfaceDeclaration<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: InterfaceBody<'tree>,
    pub name: TypeIdentifier<'tree>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
    pub children: ::core::option::Option<ExtendsTypeClause<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceDeclaration<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "interface_declaration");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <InterfaceBody as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                match non_field_children.first() {
                    Some(&child) => Some(
                        <ExtendsTypeClause as ::treesitter_types::FromNode>::from_node(child, src)?,
                    ),
                    None => None,
                }
            },
        })
    }
}
impl ::treesitter_types::Spanned for InterfaceDeclaration<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct InternalModule<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: ::core::option::Option<StatementBlock<'tree>>,
    pub name: InternalModuleName<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for InternalModule<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "internal_module");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: match node.child_by_field_name("body") {
                Some(child) => Some(<StatementBlock as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <InternalModuleName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for InternalModule<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct IntersectionType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<Type<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for IntersectionType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "intersection_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<Type as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for IntersectionType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct LabeledStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: Statement<'tree>,
    pub label: StatementIdentifier<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for LabeledStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "labeled_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            label: {
                let child = node
                    .child_by_field_name("label")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("label", node))?;
                <StatementIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for LabeledStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct LexicalDeclaration<'tree> {
    pub span: ::treesitter_types::Span,
    pub kind: LexicalDeclarationKind,
    pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for LexicalDeclaration<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "lexical_declaration");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            kind: {
                let child = node
                    .child_by_field_name("kind")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("kind", node))?;
                <LexicalDeclarationKind as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for LexicalDeclaration<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct LiteralType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: LiteralTypeChildren<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "literal_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <LiteralTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for LiteralType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct LookupType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<Type<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for LookupType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "lookup_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<Type as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for LookupType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct MappedTypeClause<'tree> {
    pub span: ::treesitter_types::Span,
    pub alias: ::core::option::Option<Type<'tree>>,
    pub name: TypeIdentifier<'tree>,
    pub r#type: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MappedTypeClause<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "mapped_type_clause");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            alias: match node.child_by_field_name("alias") {
                Some(child) => Some(<Type as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            r#type: {
                let child = node
                    .child_by_field_name("type")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for MappedTypeClause<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct MemberExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub object: MemberExpressionObject<'tree>,
    pub optional_chain: ::core::option::Option<OptionalChain<'tree>>,
    pub property: MemberExpressionProperty<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "member_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            object: {
                let child = node
                    .child_by_field_name("object")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
                <MemberExpressionObject as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            optional_chain: match node.child_by_field_name("optional_chain") {
                Some(child) => Some(<OptionalChain as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            property: {
                let child = node.child_by_field_name("property").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("property", node)
                })?;
                <MemberExpressionProperty as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for MemberExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct MetaProperty<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MetaProperty<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "meta_property");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for MetaProperty<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for MetaProperty<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct MethodDefinition<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: StatementBlock<'tree>,
    pub name: MethodDefinitionName<'tree>,
    pub parameters: FormalParameters<'tree>,
    pub return_type: ::core::option::Option<MethodDefinitionReturnType<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
    pub children: ::std::vec::Vec<MethodDefinitionChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinition<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "method_definition");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <MethodDefinitionName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            parameters: {
                let child = node.child_by_field_name("parameters").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("parameters", node)
                })?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            return_type: match node.child_by_field_name("return_type") {
                Some(child) => Some(
                    <MethodDefinitionReturnType as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <MethodDefinitionChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for MethodDefinition<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct MethodSignature<'tree> {
    pub span: ::treesitter_types::Span,
    pub name: MethodSignatureName<'tree>,
    pub parameters: FormalParameters<'tree>,
    pub return_type: ::core::option::Option<MethodSignatureReturnType<'tree>>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
    pub children: ::std::vec::Vec<MethodSignatureChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MethodSignature<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "method_signature");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <MethodSignatureName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            parameters: {
                let child = node.child_by_field_name("parameters").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("parameters", node)
                })?;
                <FormalParameters as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            return_type: match node.child_by_field_name("return_type") {
                Some(child) => Some(
                    <MethodSignatureReturnType as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <MethodSignatureChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for MethodSignature<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Module<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: ::core::option::Option<StatementBlock<'tree>>,
    pub name: ModuleName<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Module<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "module");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: match node.child_by_field_name("body") {
                Some(child) => Some(<StatementBlock as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <ModuleName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for Module<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct NamedImports<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ImportSpecifier<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for NamedImports<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "named_imports");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ImportSpecifier as ::treesitter_types::FromNode>::from_node(child, src)?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for NamedImports<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct NamespaceExport<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: NamespaceExportChildren<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceExport<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "namespace_export");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <NamespaceExportChildren as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for NamespaceExport<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct NamespaceImport<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Identifier<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceImport<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "namespace_import");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Identifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for NamespaceImport<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct NestedIdentifier<'tree> {
    pub span: ::treesitter_types::Span,
    pub object: NestedIdentifierObject<'tree>,
    pub property: PropertyIdentifier<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for NestedIdentifier<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "nested_identifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            object: {
                let child = node
                    .child_by_field_name("object")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
                <NestedIdentifierObject as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            property: {
                let child = node.child_by_field_name("property").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("property", node)
                })?;
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for NestedIdentifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct NestedTypeIdentifier<'tree> {
    pub span: ::treesitter_types::Span,
    pub module: NestedTypeIdentifierModule<'tree>,
    pub name: TypeIdentifier<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for NestedTypeIdentifier<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "nested_type_identifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            module: {
                let child = node
                    .child_by_field_name("module")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("module", node))?;
                <NestedTypeIdentifierModule as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for NestedTypeIdentifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct NewExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub arguments: ::core::option::Option<Arguments<'tree>>,
    pub constructor: PrimaryExpression<'tree>,
    pub type_arguments: ::core::option::Option<TypeArguments<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for NewExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "new_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            arguments: match node.child_by_field_name("arguments") {
                Some(child) => Some(<Arguments as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            constructor: {
                let child = node.child_by_field_name("constructor").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("constructor", node)
                })?;
                <PrimaryExpression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            type_arguments: match node.child_by_field_name("type_arguments") {
                Some(child) => Some(<TypeArguments as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for NewExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct NonNullExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for NonNullExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "non_null_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for NonNullExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Object<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ObjectChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Object<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "object");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<ObjectChildren as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for Object<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ObjectAssignmentPattern<'tree> {
    pub span: ::treesitter_types::Span,
    pub left: ObjectAssignmentPatternLeft<'tree>,
    pub right: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectAssignmentPattern<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "object_assignment_pattern");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            left: {
                let child = node
                    .child_by_field_name("left")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
                <ObjectAssignmentPatternLeft as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?
            },
            right: {
                let child = node
                    .child_by_field_name("right")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ObjectAssignmentPattern<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ObjectPattern<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ObjectPatternChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectPattern<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "object_pattern");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ObjectPatternChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ObjectPattern<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ObjectType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ObjectTypeChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "object_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ObjectTypeChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for ObjectType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct OmittingTypeAnnotation<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for OmittingTypeAnnotation<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "omitting_type_annotation");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for OmittingTypeAnnotation<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct OptingTypeAnnotation<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for OptingTypeAnnotation<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "opting_type_annotation");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for OptingTypeAnnotation<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct OptionalChain<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalChain<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "optional_chain");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for OptionalChain<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for OptionalChain<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct OptionalParameter<'tree> {
    pub span: ::treesitter_types::Span,
    pub decorator: ::std::vec::Vec<Decorator<'tree>>,
    pub name: ::core::option::Option<Identifier<'tree>>,
    pub pattern: ::core::option::Option<OptionalParameterPattern<'tree>>,
    pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
    pub value: ::core::option::Option<Expression<'tree>>,
    pub children: ::std::vec::Vec<OptionalParameterChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameter<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "optional_parameter");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            decorator: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("decorator", &mut cursor) {
                    items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
            name: match node.child_by_field_name("name") {
                Some(child) => Some(<Identifier as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            pattern: match node.child_by_field_name("pattern") {
                Some(child) => Some(
                    <OptionalParameterPattern as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            r#type: match node.child_by_field_name("type") {
                Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            value: match node.child_by_field_name("value") {
                Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <OptionalParameterChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for OptionalParameter<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct OptionalType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "optional_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for OptionalType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct OverrideModifier<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for OverrideModifier<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "override_modifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for OverrideModifier<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for OverrideModifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Pair<'tree> {
    pub span: ::treesitter_types::Span,
    pub key: PairKey<'tree>,
    pub value: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Pair<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "pair");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            key: {
                let child = node
                    .child_by_field_name("key")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
                <PairKey as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            value: {
                let child = node
                    .child_by_field_name("value")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for Pair<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct PairPattern<'tree> {
    pub span: ::treesitter_types::Span,
    pub key: PairPatternKey<'tree>,
    pub value: PairPatternValue<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PairPattern<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "pair_pattern");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            key: {
                let child = node
                    .child_by_field_name("key")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
                <PairPatternKey as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            value: {
                let child = node
                    .child_by_field_name("value")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
                <PairPatternValue as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for PairPattern<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ParenthesizedExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
    pub children: ParenthesizedExpressionChildren<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "parenthesized_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            r#type: match node.child_by_field_name("type") {
                Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <ParenthesizedExpressionChildren as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ParenthesizedExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ParenthesizedType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "parenthesized_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ParenthesizedType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct PredefinedType<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PredefinedType<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "predefined_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for PredefinedType<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for PredefinedType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Program<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<ProgramChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Program<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "program");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <ProgramChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for Program<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct PropertySignature<'tree> {
    pub span: ::treesitter_types::Span,
    pub name: PropertySignatureName<'tree>,
    pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
    pub children: ::std::vec::Vec<PropertySignatureChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PropertySignature<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "property_signature");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <PropertySignatureName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            r#type: match node.child_by_field_name("type") {
                Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <PropertySignatureChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for PropertySignature<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct PublicFieldDefinition<'tree> {
    pub span: ::treesitter_types::Span,
    pub decorator: ::std::vec::Vec<Decorator<'tree>>,
    pub name: PublicFieldDefinitionName<'tree>,
    pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
    pub value: ::core::option::Option<Expression<'tree>>,
    pub children: ::std::vec::Vec<PublicFieldDefinitionChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PublicFieldDefinition<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "public_field_definition");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            decorator: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("decorator", &mut cursor) {
                    items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <PublicFieldDefinitionName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            r#type: match node.child_by_field_name("type") {
                Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            value: match node.child_by_field_name("value") {
                Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <PublicFieldDefinitionChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for PublicFieldDefinition<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ReadonlyType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ReadonlyType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "readonly_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ReadonlyType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Regex<'tree> {
    pub span: ::treesitter_types::Span,
    pub flags: ::core::option::Option<RegexFlags<'tree>>,
    pub pattern: RegexPattern<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Regex<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "regex");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            flags: match node.child_by_field_name("flags") {
                Some(child) => Some(<RegexFlags as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            pattern: {
                let child = node.child_by_field_name("pattern").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("pattern", node)
                })?;
                <RegexPattern as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for Regex<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct RequiredParameter<'tree> {
    pub span: ::treesitter_types::Span,
    pub decorator: ::std::vec::Vec<Decorator<'tree>>,
    pub name: ::core::option::Option<RequiredParameterName<'tree>>,
    pub pattern: ::core::option::Option<RequiredParameterPattern<'tree>>,
    pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
    pub value: ::core::option::Option<Expression<'tree>>,
    pub children: ::std::vec::Vec<RequiredParameterChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for RequiredParameter<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "required_parameter");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            decorator: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("decorator", &mut cursor) {
                    items.push(<Decorator as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
            name: match node.child_by_field_name("name") {
                Some(child) => Some(
                    <RequiredParameterName as ::treesitter_types::FromNode>::from_node(child, src)?,
                ),
                None => None,
            },
            pattern: match node.child_by_field_name("pattern") {
                Some(child) => Some(
                    <RequiredParameterPattern as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?,
                ),
                None => None,
            },
            r#type: match node.child_by_field_name("type") {
                Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            value: match node.child_by_field_name("value") {
                Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <RequiredParameterChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for RequiredParameter<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct RestPattern<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: RestPatternChildren<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for RestPattern<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "rest_pattern");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <RestPatternChildren as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for RestPattern<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct RestType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for RestType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "rest_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for RestType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ReturnStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::core::option::Option<ReturnStatementChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "return_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                match non_field_children.first() {
                    Some(&child) => Some(
                        <ReturnStatementChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    ),
                    None => None,
                }
            },
        })
    }
}
impl ::treesitter_types::Spanned for ReturnStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct SatisfiesExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<SatisfiesExpressionChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SatisfiesExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "satisfies_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <SatisfiesExpressionChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for SatisfiesExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct SequenceExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<Expression<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SequenceExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "sequence_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<Expression as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for SequenceExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct SpreadElement<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SpreadElement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "spread_element");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for SpreadElement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct StatementBlock<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<Statement<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for StatementBlock<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "statement_block");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<Statement as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for StatementBlock<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct String<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<StringChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "string");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<StringChildren as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for String<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct SubscriptExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub index: SubscriptExpressionIndex<'tree>,
    pub object: Expression<'tree>,
    pub optional_chain: ::core::option::Option<OptionalChain<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "subscript_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            index: {
                let child = node
                    .child_by_field_name("index")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("index", node))?;
                <SubscriptExpressionIndex as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            object: {
                let child = node
                    .child_by_field_name("object")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            optional_chain: match node.child_by_field_name("optional_chain") {
                Some(child) => Some(<OptionalChain as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for SubscriptExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct SwitchBody<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<SwitchBodyChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBody<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "switch_body");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <SwitchBodyChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for SwitchBody<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct SwitchCase<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: ::std::vec::Vec<Statement<'tree>>,
    pub value: SwitchCaseValue<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchCase<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "switch_case");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("body", &mut cursor) {
                    items.push(<Statement as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
            value: {
                let child = node
                    .child_by_field_name("value")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
                <SwitchCaseValue as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for SwitchCase<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct SwitchDefault<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: ::std::vec::Vec<Statement<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchDefault<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "switch_default");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let mut cursor = node.walk();
                let mut items = ::std::vec::Vec::new();
                for child in node.children_by_field_name("body", &mut cursor) {
                    items.push(<Statement as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for SwitchDefault<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct SwitchStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: SwitchBody<'tree>,
    pub value: ParenthesizedExpression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "switch_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <SwitchBody as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            value: {
                let child = node
                    .child_by_field_name("value")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
                <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for SwitchStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TemplateLiteralType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<TemplateLiteralTypeChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateLiteralType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "template_literal_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <TemplateLiteralTypeChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for TemplateLiteralType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TemplateString<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<TemplateStringChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateString<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "template_string");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <TemplateStringChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for TemplateString<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TemplateSubstitution<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: TemplateSubstitutionChildren<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateSubstitution<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "template_substitution");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <TemplateSubstitutionChildren as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?
            },
        })
    }
}
impl ::treesitter_types::Spanned for TemplateSubstitution<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TemplateType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: TemplateTypeChildren<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "template_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <TemplateTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for TemplateType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TernaryExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub alternative: Expression<'tree>,
    pub condition: Expression<'tree>,
    pub consequence: Expression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TernaryExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "ternary_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            alternative: {
                let child = node.child_by_field_name("alternative").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("alternative", node)
                })?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            condition: {
                let child = node.child_by_field_name("condition").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("condition", node)
                })?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            consequence: {
                let child = node.child_by_field_name("consequence").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("consequence", node)
                })?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for TernaryExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ThrowStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ThrowStatementChildren<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "throw_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <ThrowStatementChildren as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for ThrowStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TryStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: StatementBlock<'tree>,
    pub finalizer: ::core::option::Option<FinallyClause<'tree>>,
    pub handler: ::core::option::Option<CatchClause<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TryStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "try_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <StatementBlock as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            finalizer: match node.child_by_field_name("finalizer") {
                Some(child) => Some(<FinallyClause as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            handler: match node.child_by_field_name("handler") {
                Some(child) => Some(<CatchClause as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for TryStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TupleType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<TupleTypeChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TupleType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "tuple_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <TupleTypeChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for TupleType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TypeAliasDeclaration<'tree> {
    pub span: ::treesitter_types::Span,
    pub name: TypeIdentifier<'tree>,
    pub type_parameters: ::core::option::Option<TypeParameters<'tree>>,
    pub value: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypeAliasDeclaration<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "type_alias_declaration");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            type_parameters: match node.child_by_field_name("type_parameters") {
                Some(child) => Some(<TypeParameters as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            value: {
                let child = node
                    .child_by_field_name("value")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for TypeAliasDeclaration<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TypeAnnotation<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypeAnnotation<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "type_annotation");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for TypeAnnotation<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TypeArguments<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<Type<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypeArguments<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "type_arguments");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<Type as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for TypeArguments<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TypeAssertion<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<TypeAssertionChildren<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypeAssertion<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "type_assertion");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <TypeAssertionChildren as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for TypeAssertion<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TypeParameter<'tree> {
    pub span: ::treesitter_types::Span,
    pub constraint: ::core::option::Option<Constraint<'tree>>,
    pub name: TypeIdentifier<'tree>,
    pub value: ::core::option::Option<DefaultType<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameter<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "type_parameter");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            constraint: match node.child_by_field_name("constraint") {
                Some(child) => Some(<Constraint as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            value: match node.child_by_field_name("value") {
                Some(child) => Some(<DefaultType as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for TypeParameter<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TypeParameters<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<TypeParameter<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypeParameters<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "type_parameters");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<TypeParameter as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for TypeParameters<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TypePredicate<'tree> {
    pub span: ::treesitter_types::Span,
    pub name: TypePredicateName<'tree>,
    pub r#type: Type<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypePredicate<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "type_predicate");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <TypePredicateName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            r#type: {
                let child = node
                    .child_by_field_name("type")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("type", node))?;
                <Type as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for TypePredicate<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TypePredicateAnnotation<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: TypePredicate<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypePredicateAnnotation<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "type_predicate_annotation");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <TypePredicate as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for TypePredicateAnnotation<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TypeQuery<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: TypeQueryChildren<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypeQuery<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "type_query");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let child = if let Some(&c) = non_field_children.first() {
                    c
                } else {
                    let mut fallback_cursor = node.walk();
                    let mut fallback_child = None;
                    if fallback_cursor.goto_first_child() {
                        loop {
                            if fallback_cursor.field_name().is_none()
                                && !fallback_cursor.node().is_extra()
                            {
                                fallback_child = Some(fallback_cursor.node());
                                break;
                            }
                            if !fallback_cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    fallback_child.ok_or_else(|| {
                        ::treesitter_types::ParseError::missing_field("children", node)
                    })?
                };
                <TypeQueryChildren as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for TypeQuery<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct UnaryExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub argument: UnaryExpressionArgument<'tree>,
    pub operator: UnaryExpressionOperator,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "unary_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            argument: {
                let child = node.child_by_field_name("argument").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("argument", node)
                })?;
                <UnaryExpressionArgument as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            operator: {
                let child = node.child_by_field_name("operator").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("operator", node)
                })?;
                <UnaryExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for UnaryExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct UnionType<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<Type<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for UnionType<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "union_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(<Type as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?);
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for UnionType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct UpdateExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub argument: Expression<'tree>,
    pub operator: UpdateExpressionOperator,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "update_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            argument: {
                let child = node.child_by_field_name("argument").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("argument", node)
                })?;
                <Expression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            operator: {
                let child = node.child_by_field_name("operator").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("operator", node)
                })?;
                <UpdateExpressionOperator as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for UpdateExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct VariableDeclaration<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::std::vec::Vec<VariableDeclarator<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaration<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "variable_declaration");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                let mut items = ::std::vec::Vec::new();
                for child in non_field_children {
                    items.push(
                        <VariableDeclarator as ::treesitter_types::FromNode>::from_node(
                            child, src,
                        )?,
                    );
                }
                items
            },
        })
    }
}
impl ::treesitter_types::Spanned for VariableDeclaration<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct VariableDeclarator<'tree> {
    pub span: ::treesitter_types::Span,
    pub name: VariableDeclaratorName<'tree>,
    pub r#type: ::core::option::Option<TypeAnnotation<'tree>>,
    pub value: ::core::option::Option<Expression<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclarator<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "variable_declarator");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            name: {
                let child = node
                    .child_by_field_name("name")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("name", node))?;
                <VariableDeclaratorName as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            r#type: match node.child_by_field_name("type") {
                Some(child) => Some(<TypeAnnotation as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
            value: match node.child_by_field_name("value") {
                Some(child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
                    child, src,
                )?),
                None => None,
            },
        })
    }
}
impl ::treesitter_types::Spanned for VariableDeclarator<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct WhileStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: Statement<'tree>,
    pub condition: ParenthesizedExpression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for WhileStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "while_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            condition: {
                let child = node.child_by_field_name("condition").ok_or_else(|| {
                    ::treesitter_types::ParseError::missing_field("condition", node)
                })?;
                <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for WhileStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct WithStatement<'tree> {
    pub span: ::treesitter_types::Span,
    pub body: Statement<'tree>,
    pub object: ParenthesizedExpression<'tree>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for WithStatement<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "with_statement");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            body: {
                let child = node
                    .child_by_field_name("body")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("body", node))?;
                <Statement as ::treesitter_types::FromNode>::from_node(child, src)?
            },
            object: {
                let child = node
                    .child_by_field_name("object")
                    .ok_or_else(|| ::treesitter_types::ParseError::missing_field("object", node))?;
                <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(child, src)?
            },
        })
    }
}
impl ::treesitter_types::Spanned for WithStatement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct YieldExpression<'tree> {
    pub span: ::treesitter_types::Span,
    pub children: ::core::option::Option<Expression<'tree>>,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for YieldExpression<'tree> {
    #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "yield_expression");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            children: {
                #[allow(clippy::suspicious_else_formatting)]
                let non_field_children = {
                    let mut cursor = node.walk();
                    let mut result = ::std::vec::Vec::new();
                    if cursor.goto_first_child() {
                        loop {
                            if cursor.field_name().is_none()
                                && cursor.node().is_named()
                                && !cursor.node().is_extra()
                            {
                                result.push(cursor.node());
                            }
                            if !cursor.goto_next_sibling() {
                                break;
                            }
                        }
                    }
                    result
                };
                match non_field_children.first() {
                    Some(&child) => Some(<Expression as ::treesitter_types::FromNode>::from_node(
                        child, src,
                    )?),
                    None => None,
                }
            },
        })
    }
}
impl ::treesitter_types::Spanned for YieldExpression<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Comment<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "comment");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for Comment<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct EscapeSequence<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "escape_sequence");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for EscapeSequence<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct False<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "false");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for False<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct HashBangLine<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for HashBangLine<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "hash_bang_line");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for HashBangLine<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for HashBangLine<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct HtmlComment<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for HtmlComment<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "html_comment");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for HtmlComment<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for HtmlComment<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Null<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Null<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "null");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for Null<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for Null<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Number<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Number<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "number");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for Number<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for Number<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct PrivatePropertyIdentifier<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PrivatePropertyIdentifier<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "private_property_identifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for PrivatePropertyIdentifier<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for PrivatePropertyIdentifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct PropertyIdentifier<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PropertyIdentifier<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "property_identifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for PropertyIdentifier<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for PropertyIdentifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct RegexFlags<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for RegexFlags<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "regex_flags");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for RegexFlags<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for RegexFlags<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct RegexPattern<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for RegexPattern<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "regex_pattern");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for RegexPattern<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for RegexPattern<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ShorthandPropertyIdentifier<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandPropertyIdentifier<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "shorthand_property_identifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for ShorthandPropertyIdentifier<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for ShorthandPropertyIdentifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ShorthandPropertyIdentifierPattern<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ShorthandPropertyIdentifierPattern<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "shorthand_property_identifier_pattern");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for ShorthandPropertyIdentifierPattern<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for ShorthandPropertyIdentifierPattern<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct StatementIdentifier<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for StatementIdentifier<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "statement_identifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for StatementIdentifier<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for StatementIdentifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct StringFragment<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for StringFragment<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "string_fragment");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for StringFragment<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for StringFragment<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Super<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Super<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "super");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for Super<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for Super<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct This<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for This<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "this");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for This<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for This<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct ThisType<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ThisType<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "this_type");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for ThisType<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for ThisType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct True<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "true");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for True<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct TypeIdentifier<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypeIdentifier<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "type_identifier");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for TypeIdentifier<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for TypeIdentifier<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub struct Undefined<'tree> {
    pub span: ::treesitter_types::Span,
    text: &'tree str,
}
impl<'tree> ::treesitter_types::FromNode<'tree> for Undefined<'tree> {
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        debug_assert_eq!(node.kind(), "undefined");
        Ok(Self {
            span: ::treesitter_types::Span::from(node),
            text: node.utf8_text(src)?,
        })
    }
}
impl<'tree> ::treesitter_types::LeafNode<'tree> for Undefined<'tree> {
    fn text(&self) -> &'tree str {
        self.text
    }
}
impl ::treesitter_types::Spanned for Undefined<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        self.span
    }
}
#[derive(Debug, Clone)]
pub enum AbstractMethodSignatureName<'tree> {
    ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
    PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractMethodSignatureName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
                <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "private_property_identifier" => {
                Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
                    <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for AbstractMethodSignatureName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ComputedPropertyName(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum AbstractMethodSignatureReturnType<'tree> {
    AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
    TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
    TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractMethodSignatureReturnType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
                <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate_annotation" => {
                Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
                    <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for AbstractMethodSignatureReturnType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssertsAnnotation(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
            Self::TypePredicateAnnotation(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum AbstractMethodSignatureChildren<'tree> {
    AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
    OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AbstractMethodSignatureChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
                <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
                <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for AbstractMethodSignatureChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AccessibilityModifier(inner) => inner.span(),
            Self::OverrideModifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum AmbientDeclarationChildren<'tree> {
    Declaration(::std::boxed::Box<Declaration<'tree>>),
    PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
    StatementBlock(::std::boxed::Box<StatementBlock<'tree>>),
    Type(::std::boxed::Box<Type<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AmbientDeclarationChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "statement_block" => Ok(Self::StatementBlock(::std::boxed::Box::new(
                <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Declaration as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Declaration(::std::boxed::Box::new(v)))
                } else {
                    if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
                        Ok(Self::Type(::std::boxed::Box::new(v)))
                    } else {
                        Err(::treesitter_types::ParseError::unexpected_kind(
                            _other, node,
                        ))
                    }
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for AmbientDeclarationChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Declaration(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
            Self::StatementBlock(inner) => inner.span(),
            Self::Type(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ArgumentsChildren<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentsChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
                <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ArgumentsChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::SpreadElement(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ArrayChildren<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
                <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ArrayChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::SpreadElement(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ArrayPatternChildren<'tree> {
    AssignmentPattern(::std::boxed::Box<AssignmentPattern<'tree>>),
    Pattern(::std::boxed::Box<Pattern<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayPatternChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "assignment_pattern" => Ok(Self::AssignmentPattern(::std::boxed::Box::new(
                <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Pattern(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ArrayPatternChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssignmentPattern(inner) => inner.span(),
            Self::Pattern(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ArrowFunctionBody<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    StatementBlock(::std::boxed::Box<StatementBlock<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunctionBody<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "statement_block" => Ok(Self::StatementBlock(::std::boxed::Box::new(
                <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ArrowFunctionBody<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::StatementBlock(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ArrowFunctionReturnType<'tree> {
    AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
    TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
    TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ArrowFunctionReturnType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
                <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate_annotation" => {
                Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
                    <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ArrowFunctionReturnType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssertsAnnotation(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
            Self::TypePredicateAnnotation(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum AsExpressionChildren<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    Type(::std::boxed::Box<Type<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AsExpressionChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
            Ok(Self::Expression(::std::boxed::Box::new(v)))
        } else {
            if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
                Ok(Self::Type(::std::boxed::Box::new(v)))
            } else {
                Err(::treesitter_types::ParseError::unexpected_kind(
                    node.kind(),
                    node,
                ))
            }
        }
    }
}
impl ::treesitter_types::Spanned for AsExpressionChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::Type(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum AssertsChildren<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    This(::std::boxed::Box<This<'tree>>),
    TypePredicate(::std::boxed::Box<TypePredicate<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AssertsChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "this" => Ok(Self::This(::std::boxed::Box::new(
                <This as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate" => Ok(Self::TypePredicate(::std::boxed::Box::new(
                <TypePredicate as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for AssertsChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::This(inner) => inner.span(),
            Self::TypePredicate(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum AssignmentExpressionLeft<'tree> {
    ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
    NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
    ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
    ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
    SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
    Undefined(::std::boxed::Box<Undefined<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AssignmentExpressionLeft<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
                <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
                <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
                <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "parenthesized_expression" => {
                Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
                    <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
                <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
                <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for AssignmentExpressionLeft<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ArrayPattern(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::NonNullExpression(inner) => inner.span(),
            Self::ObjectPattern(inner) => inner.span(),
            Self::ParenthesizedExpression(inner) => inner.span(),
            Self::SubscriptExpression(inner) => inner.span(),
            Self::Undefined(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum AugmentedAssignmentExpressionLeft<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
    NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
    ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
    SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionLeft<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
                <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "parenthesized_expression" => {
                Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
                    <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
                <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionLeft<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::NonNullExpression(inner) => inner.span(),
            Self::ParenthesizedExpression(inner) => inner.span(),
            Self::SubscriptExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum AugmentedAssignmentExpressionOperator {
    PercentEq(::treesitter_types::Span),
    AmpAmpEq(::treesitter_types::Span),
    AmpEq(::treesitter_types::Span),
    StarStarEq(::treesitter_types::Span),
    StarEq(::treesitter_types::Span),
    PlusEq(::treesitter_types::Span),
    MinusEq(::treesitter_types::Span),
    SlashEq(::treesitter_types::Span),
    ShlEq(::treesitter_types::Span),
    ShrEq(::treesitter_types::Span),
    GtGtGtEq(::treesitter_types::Span),
    QuestionQuestionEq(::treesitter_types::Span),
    CaretEq(::treesitter_types::Span),
    PipeEq(::treesitter_types::Span),
    PipePipeEq(::treesitter_types::Span),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for AugmentedAssignmentExpressionOperator {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        _src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "%=" => Ok(Self::PercentEq(::treesitter_types::Span::from(node))),
            "&&=" => Ok(Self::AmpAmpEq(::treesitter_types::Span::from(node))),
            "&=" => Ok(Self::AmpEq(::treesitter_types::Span::from(node))),
            "**=" => Ok(Self::StarStarEq(::treesitter_types::Span::from(node))),
            "*=" => Ok(Self::StarEq(::treesitter_types::Span::from(node))),
            "+=" => Ok(Self::PlusEq(::treesitter_types::Span::from(node))),
            "-=" => Ok(Self::MinusEq(::treesitter_types::Span::from(node))),
            "/=" => Ok(Self::SlashEq(::treesitter_types::Span::from(node))),
            "<<=" => Ok(Self::ShlEq(::treesitter_types::Span::from(node))),
            ">>=" => Ok(Self::ShrEq(::treesitter_types::Span::from(node))),
            ">>>=" => Ok(Self::GtGtGtEq(::treesitter_types::Span::from(node))),
            "??=" => Ok(Self::QuestionQuestionEq(::treesitter_types::Span::from(
                node,
            ))),
            "^=" => Ok(Self::CaretEq(::treesitter_types::Span::from(node))),
            "|=" => Ok(Self::PipeEq(::treesitter_types::Span::from(node))),
            "||=" => Ok(Self::PipePipeEq(::treesitter_types::Span::from(node))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for AugmentedAssignmentExpressionOperator {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::PercentEq(span) => *span,
            Self::AmpAmpEq(span) => *span,
            Self::AmpEq(span) => *span,
            Self::StarStarEq(span) => *span,
            Self::StarEq(span) => *span,
            Self::PlusEq(span) => *span,
            Self::MinusEq(span) => *span,
            Self::SlashEq(span) => *span,
            Self::ShlEq(span) => *span,
            Self::ShrEq(span) => *span,
            Self::GtGtGtEq(span) => *span,
            Self::QuestionQuestionEq(span) => *span,
            Self::CaretEq(span) => *span,
            Self::PipeEq(span) => *span,
            Self::PipePipeEq(span) => *span,
        }
    }
}
#[derive(Debug, Clone)]
pub enum BinaryExpressionLeft<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionLeft<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "private_property_identifier" => {
                Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
                    <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for BinaryExpressionLeft<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum BinaryExpressionOperator {
    NotEq(::treesitter_types::Span),
    BangEqEq(::treesitter_types::Span),
    Percent(::treesitter_types::Span),
    Amp(::treesitter_types::Span),
    AmpAmp(::treesitter_types::Span),
    Star(::treesitter_types::Span),
    StarStar(::treesitter_types::Span),
    Plus(::treesitter_types::Span),
    Minus(::treesitter_types::Span),
    Slash(::treesitter_types::Span),
    Lt(::treesitter_types::Span),
    Shl(::treesitter_types::Span),
    LtEq(::treesitter_types::Span),
    EqEq(::treesitter_types::Span),
    EqEqEq(::treesitter_types::Span),
    Gt(::treesitter_types::Span),
    GtEq(::treesitter_types::Span),
    Shr(::treesitter_types::Span),
    GtGtGt(::treesitter_types::Span),
    QuestionQuestion(::treesitter_types::Span),
    Caret(::treesitter_types::Span),
    In(::treesitter_types::Span),
    Instanceof(::treesitter_types::Span),
    Pipe(::treesitter_types::Span),
    PipePipe(::treesitter_types::Span),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryExpressionOperator {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        _src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
            "!==" => Ok(Self::BangEqEq(::treesitter_types::Span::from(node))),
            "%" => Ok(Self::Percent(::treesitter_types::Span::from(node))),
            "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
            "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
            "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
            "**" => Ok(Self::StarStar(::treesitter_types::Span::from(node))),
            "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
            "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
            "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
            "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
            "<<" => Ok(Self::Shl(::treesitter_types::Span::from(node))),
            "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
            "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
            "===" => Ok(Self::EqEqEq(::treesitter_types::Span::from(node))),
            ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
            ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
            ">>" => Ok(Self::Shr(::treesitter_types::Span::from(node))),
            ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
            "??" => Ok(Self::QuestionQuestion(::treesitter_types::Span::from(node))),
            "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
            "in" => Ok(Self::In(::treesitter_types::Span::from(node))),
            "instanceof" => Ok(Self::Instanceof(::treesitter_types::Span::from(node))),
            "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
            "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for BinaryExpressionOperator {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::NotEq(span) => *span,
            Self::BangEqEq(span) => *span,
            Self::Percent(span) => *span,
            Self::Amp(span) => *span,
            Self::AmpAmp(span) => *span,
            Self::Star(span) => *span,
            Self::StarStar(span) => *span,
            Self::Plus(span) => *span,
            Self::Minus(span) => *span,
            Self::Slash(span) => *span,
            Self::Lt(span) => *span,
            Self::Shl(span) => *span,
            Self::LtEq(span) => *span,
            Self::EqEq(span) => *span,
            Self::EqEqEq(span) => *span,
            Self::Gt(span) => *span,
            Self::GtEq(span) => *span,
            Self::Shr(span) => *span,
            Self::GtGtGt(span) => *span,
            Self::QuestionQuestion(span) => *span,
            Self::Caret(span) => *span,
            Self::In(span) => *span,
            Self::Instanceof(span) => *span,
            Self::Pipe(span) => *span,
            Self::PipePipe(span) => *span,
        }
    }
}
#[derive(Debug, Clone)]
pub enum CallExpressionArguments<'tree> {
    Arguments(::std::boxed::Box<Arguments<'tree>>),
    TemplateString(::std::boxed::Box<TemplateString<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionArguments<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "arguments" => Ok(Self::Arguments(::std::boxed::Box::new(
                <Arguments as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "template_string" => Ok(Self::TemplateString(::std::boxed::Box::new(
                <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for CallExpressionArguments<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Arguments(inner) => inner.span(),
            Self::TemplateString(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum CallExpressionFunction<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    Import(::std::boxed::Box<Import<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for CallExpressionFunction<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "import" => Ok(Self::Import(::std::boxed::Box::new(
                <Import as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for CallExpressionFunction<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::Import(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum CallSignatureReturnType<'tree> {
    AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
    TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
    TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for CallSignatureReturnType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
                <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate_annotation" => {
                Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
                    <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for CallSignatureReturnType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssertsAnnotation(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
            Self::TypePredicateAnnotation(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum CatchClauseParameter<'tree> {
    ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for CatchClauseParameter<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
                <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
                <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for CatchClauseParameter<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ArrayPattern(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::ObjectPattern(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ClassBodyChildren<'tree> {
    AbstractMethodSignature(::std::boxed::Box<AbstractMethodSignature<'tree>>),
    ClassStaticBlock(::std::boxed::Box<ClassStaticBlock<'tree>>),
    IndexSignature(::std::boxed::Box<IndexSignature<'tree>>),
    MethodDefinition(::std::boxed::Box<MethodDefinition<'tree>>),
    MethodSignature(::std::boxed::Box<MethodSignature<'tree>>),
    PublicFieldDefinition(::std::boxed::Box<PublicFieldDefinition<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ClassBodyChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "abstract_method_signature" => {
                Ok(Self::AbstractMethodSignature(::std::boxed::Box::new(
                    <AbstractMethodSignature as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "class_static_block" => Ok(Self::ClassStaticBlock(::std::boxed::Box::new(
                <ClassStaticBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "index_signature" => Ok(Self::IndexSignature(::std::boxed::Box::new(
                <IndexSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "method_definition" => Ok(Self::MethodDefinition(::std::boxed::Box::new(
                <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "method_signature" => Ok(Self::MethodSignature(::std::boxed::Box::new(
                <MethodSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "public_field_definition" => Ok(Self::PublicFieldDefinition(::std::boxed::Box::new(
                <PublicFieldDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ClassBodyChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AbstractMethodSignature(inner) => inner.span(),
            Self::ClassStaticBlock(inner) => inner.span(),
            Self::IndexSignature(inner) => inner.span(),
            Self::MethodDefinition(inner) => inner.span(),
            Self::MethodSignature(inner) => inner.span(),
            Self::PublicFieldDefinition(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ClassHeritageChildren<'tree> {
    ExtendsClause(::std::boxed::Box<ExtendsClause<'tree>>),
    ImplementsClause(::std::boxed::Box<ImplementsClause<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ClassHeritageChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "extends_clause" => Ok(Self::ExtendsClause(::std::boxed::Box::new(
                <ExtendsClause as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "implements_clause" => Ok(Self::ImplementsClause(::std::boxed::Box::new(
                <ImplementsClause as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ClassHeritageChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ExtendsClause(inner) => inner.span(),
            Self::ImplementsClause(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum DecoratorChildren<'tree> {
    CallExpression(::std::boxed::Box<CallExpression<'tree>>),
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
    ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for DecoratorChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
                <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "parenthesized_expression" => {
                Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
                    <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for DecoratorChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::CallExpression(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::ParenthesizedExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum EnumAssignmentName<'tree> {
    ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
    PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for EnumAssignmentName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
                <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "private_property_identifier" => {
                Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
                    <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for EnumAssignmentName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ComputedPropertyName(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum EnumBodyName<'tree> {
    ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
    PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for EnumBodyName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
                <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "private_property_identifier" => {
                Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
                    <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for EnumBodyName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ComputedPropertyName(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ExportSpecifierAlias<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifierAlias<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ExportSpecifierAlias<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ExportSpecifierName<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExportSpecifierName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ExportSpecifierName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ExportStatementChildren<'tree> {
    ExportClause(::std::boxed::Box<ExportClause<'tree>>),
    Expression(::std::boxed::Box<Expression<'tree>>),
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    NamespaceExport(::std::boxed::Box<NamespaceExport<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExportStatementChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "export_clause" => Ok(Self::ExportClause(::std::boxed::Box::new(
                <ExportClause as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "namespace_export" => Ok(Self::NamespaceExport(::std::boxed::Box::new(
                <NamespaceExport as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ExportStatementChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ExportClause(inner) => inner.span(),
            Self::Expression(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::NamespaceExport(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ExpressionStatementChildren<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExpressionStatementChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ExpressionStatementChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ExtendsTypeClauseType<'tree> {
    GenericType(::std::boxed::Box<GenericType<'tree>>),
    NestedTypeIdentifier(::std::boxed::Box<NestedTypeIdentifier<'tree>>),
    TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ExtendsTypeClauseType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "generic_type" => Ok(Self::GenericType(::std::boxed::Box::new(
                <GenericType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "nested_type_identifier" => Ok(Self::NestedTypeIdentifier(::std::boxed::Box::new(
                <NestedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ExtendsTypeClauseType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::GenericType(inner) => inner.span(),
            Self::NestedTypeIdentifier(inner) => inner.span(),
            Self::TypeIdentifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ForInStatementKind {
    Const(::treesitter_types::Span),
    Let(::treesitter_types::Span),
    Var(::treesitter_types::Span),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementKind {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        _src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
            "let" => Ok(Self::Let(::treesitter_types::Span::from(node))),
            "var" => Ok(Self::Var(::treesitter_types::Span::from(node))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ForInStatementKind {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Const(span) => *span,
            Self::Let(span) => *span,
            Self::Var(span) => *span,
        }
    }
}
#[derive(Debug, Clone)]
pub enum ForInStatementLeft<'tree> {
    ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
    NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
    ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
    ParenthesizedExpression(::std::boxed::Box<ParenthesizedExpression<'tree>>),
    SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
    Undefined(::std::boxed::Box<Undefined<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementLeft<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
                <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
                <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
                <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "parenthesized_expression" => {
                Ok(Self::ParenthesizedExpression(::std::boxed::Box::new(
                    <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
                <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
                <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ForInStatementLeft<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ArrayPattern(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::NonNullExpression(inner) => inner.span(),
            Self::ObjectPattern(inner) => inner.span(),
            Self::ParenthesizedExpression(inner) => inner.span(),
            Self::SubscriptExpression(inner) => inner.span(),
            Self::Undefined(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ForInStatementOperator {
    In(::treesitter_types::Span),
    Of(::treesitter_types::Span),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementOperator {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        _src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "in" => Ok(Self::In(::treesitter_types::Span::from(node))),
            "of" => Ok(Self::Of(::treesitter_types::Span::from(node))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ForInStatementOperator {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::In(span) => *span,
            Self::Of(span) => *span,
        }
    }
}
#[derive(Debug, Clone)]
pub enum ForInStatementRight<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ForInStatementRight<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ForInStatementRight<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ForStatementCondition<'tree> {
    Semicolon(::treesitter_types::Span),
    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
    Expression(::std::boxed::Box<Expression<'tree>>),
    SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementCondition<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            ";" => Ok(Self::Semicolon(::treesitter_types::Span::from(node))),
            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
                <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ForStatementCondition<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Semicolon(span) => *span,
            Self::EmptyStatement(inner) => inner.span(),
            Self::Expression(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ForStatementIncrement<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementIncrement<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ForStatementIncrement<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ForStatementInitializer<'tree> {
    EmptyStatement(::std::boxed::Box<EmptyStatement<'tree>>),
    Expression(::std::boxed::Box<Expression<'tree>>),
    LexicalDeclaration(::std::boxed::Box<LexicalDeclaration<'tree>>),
    SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
    VariableDeclaration(::std::boxed::Box<VariableDeclaration<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ForStatementInitializer<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "empty_statement" => Ok(Self::EmptyStatement(::std::boxed::Box::new(
                <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "lexical_declaration" => Ok(Self::LexicalDeclaration(::std::boxed::Box::new(
                <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "variable_declaration" => Ok(Self::VariableDeclaration(::std::boxed::Box::new(
                <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ForStatementInitializer<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::EmptyStatement(inner) => inner.span(),
            Self::Expression(inner) => inner.span(),
            Self::LexicalDeclaration(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
            Self::VariableDeclaration(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum FormalParametersChildren<'tree> {
    OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
    RequiredParameter(::std::boxed::Box<RequiredParameter<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FormalParametersChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
                <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "required_parameter" => Ok(Self::RequiredParameter(::std::boxed::Box::new(
                <RequiredParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for FormalParametersChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::OptionalParameter(inner) => inner.span(),
            Self::RequiredParameter(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum FunctionDeclarationReturnType<'tree> {
    AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
    TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
    TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionDeclarationReturnType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
                <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate_annotation" => {
                Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
                    <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for FunctionDeclarationReturnType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssertsAnnotation(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
            Self::TypePredicateAnnotation(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum FunctionExpressionReturnType<'tree> {
    AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
    TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
    TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionExpressionReturnType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
                <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate_annotation" => {
                Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
                    <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for FunctionExpressionReturnType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssertsAnnotation(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
            Self::TypePredicateAnnotation(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum FunctionSignatureReturnType<'tree> {
    AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
    TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
    TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionSignatureReturnType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
                <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate_annotation" => {
                Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
                    <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for FunctionSignatureReturnType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssertsAnnotation(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
            Self::TypePredicateAnnotation(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum FunctionTypeReturnType<'tree> {
    Asserts(::std::boxed::Box<Asserts<'tree>>),
    Type(::std::boxed::Box<Type<'tree>>),
    TypePredicate(::std::boxed::Box<TypePredicate<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for FunctionTypeReturnType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "asserts" => Ok(Self::Asserts(::std::boxed::Box::new(
                <Asserts as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate" => Ok(Self::TypePredicate(::std::boxed::Box::new(
                <TypePredicate as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Type(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for FunctionTypeReturnType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Asserts(inner) => inner.span(),
            Self::Type(inner) => inner.span(),
            Self::TypePredicate(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum GeneratorFunctionReturnType<'tree> {
    AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
    TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
    TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunctionReturnType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
                <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate_annotation" => {
                Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
                    <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for GeneratorFunctionReturnType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssertsAnnotation(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
            Self::TypePredicateAnnotation(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum GeneratorFunctionDeclarationReturnType<'tree> {
    AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
    TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
    TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for GeneratorFunctionDeclarationReturnType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
                <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate_annotation" => {
                Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
                    <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for GeneratorFunctionDeclarationReturnType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssertsAnnotation(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
            Self::TypePredicateAnnotation(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum GenericTypeName<'tree> {
    NestedTypeIdentifier(::std::boxed::Box<NestedTypeIdentifier<'tree>>),
    TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for GenericTypeName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "nested_type_identifier" => Ok(Self::NestedTypeIdentifier(::std::boxed::Box::new(
                <NestedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for GenericTypeName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::NestedTypeIdentifier(inner) => inner.span(),
            Self::TypeIdentifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ImportAliasChildren<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    NestedIdentifier(::std::boxed::Box<NestedIdentifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ImportAliasChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "nested_identifier" => Ok(Self::NestedIdentifier(::std::boxed::Box::new(
                <NestedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ImportAliasChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::NestedIdentifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ImportClauseChildren<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    NamedImports(::std::boxed::Box<NamedImports<'tree>>),
    NamespaceImport(::std::boxed::Box<NamespaceImport<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ImportClauseChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "named_imports" => Ok(Self::NamedImports(::std::boxed::Box::new(
                <NamedImports as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "namespace_import" => Ok(Self::NamespaceImport(::std::boxed::Box::new(
                <NamespaceImport as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ImportClauseChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::NamedImports(inner) => inner.span(),
            Self::NamespaceImport(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ImportSpecifierName<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ImportSpecifierName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ImportSpecifierName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ImportStatementChildren<'tree> {
    ImportAttribute(::std::boxed::Box<ImportAttribute<'tree>>),
    ImportClause(::std::boxed::Box<ImportClause<'tree>>),
    ImportRequireClause(::std::boxed::Box<ImportRequireClause<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ImportStatementChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "import_attribute" => Ok(Self::ImportAttribute(::std::boxed::Box::new(
                <ImportAttribute as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "import_clause" => Ok(Self::ImportClause(::std::boxed::Box::new(
                <ImportClause as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "import_require_clause" => Ok(Self::ImportRequireClause(::std::boxed::Box::new(
                <ImportRequireClause as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ImportStatementChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ImportAttribute(inner) => inner.span(),
            Self::ImportClause(inner) => inner.span(),
            Self::ImportRequireClause(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum IndexSignatureSign {
    Plus(::treesitter_types::Span),
    Minus(::treesitter_types::Span),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for IndexSignatureSign {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        _src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
            "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for IndexSignatureSign {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Plus(span) => *span,
            Self::Minus(span) => *span,
        }
    }
}
#[derive(Debug, Clone)]
pub enum IndexSignatureType<'tree> {
    AddingTypeAnnotation(::std::boxed::Box<AddingTypeAnnotation<'tree>>),
    OmittingTypeAnnotation(::std::boxed::Box<OmittingTypeAnnotation<'tree>>),
    OptingTypeAnnotation(::std::boxed::Box<OptingTypeAnnotation<'tree>>),
    TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for IndexSignatureType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "adding_type_annotation" => Ok(Self::AddingTypeAnnotation(::std::boxed::Box::new(
                <AddingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "omitting_type_annotation" => Ok(Self::OmittingTypeAnnotation(::std::boxed::Box::new(
                <OmittingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "opting_type_annotation" => Ok(Self::OptingTypeAnnotation(::std::boxed::Box::new(
                <OptingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for IndexSignatureType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AddingTypeAnnotation(inner) => inner.span(),
            Self::OmittingTypeAnnotation(inner) => inner.span(),
            Self::OptingTypeAnnotation(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum InferTypeChildren<'tree> {
    Type(::std::boxed::Box<Type<'tree>>),
    TypeIdentifier(::std::boxed::Box<TypeIdentifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for InferTypeChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "type_identifier" => Ok(Self::TypeIdentifier(::std::boxed::Box::new(
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Type(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for InferTypeChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Type(inner) => inner.span(),
            Self::TypeIdentifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum InstantiationExpressionFunction<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    Import(::std::boxed::Box<Import<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
    SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for InstantiationExpressionFunction<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "import" => Ok(Self::Import(::std::boxed::Box::new(
                <Import as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
                <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for InstantiationExpressionFunction<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::Import(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::SubscriptExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum InterfaceBodyChildren<'tree> {
    CallSignature(::std::boxed::Box<CallSignature<'tree>>),
    ConstructSignature(::std::boxed::Box<ConstructSignature<'tree>>),
    ExportStatement(::std::boxed::Box<ExportStatement<'tree>>),
    IndexSignature(::std::boxed::Box<IndexSignature<'tree>>),
    MethodSignature(::std::boxed::Box<MethodSignature<'tree>>),
    PropertySignature(::std::boxed::Box<PropertySignature<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for InterfaceBodyChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "call_signature" => Ok(Self::CallSignature(::std::boxed::Box::new(
                <CallSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "construct_signature" => Ok(Self::ConstructSignature(::std::boxed::Box::new(
                <ConstructSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "export_statement" => Ok(Self::ExportStatement(::std::boxed::Box::new(
                <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "index_signature" => Ok(Self::IndexSignature(::std::boxed::Box::new(
                <IndexSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "method_signature" => Ok(Self::MethodSignature(::std::boxed::Box::new(
                <MethodSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "property_signature" => Ok(Self::PropertySignature(::std::boxed::Box::new(
                <PropertySignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for InterfaceBodyChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::CallSignature(inner) => inner.span(),
            Self::ConstructSignature(inner) => inner.span(),
            Self::ExportStatement(inner) => inner.span(),
            Self::IndexSignature(inner) => inner.span(),
            Self::MethodSignature(inner) => inner.span(),
            Self::PropertySignature(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum InternalModuleName<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    NestedIdentifier(::std::boxed::Box<NestedIdentifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for InternalModuleName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "nested_identifier" => Ok(Self::NestedIdentifier(::std::boxed::Box::new(
                <NestedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for InternalModuleName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::NestedIdentifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum LexicalDeclarationKind {
    Const(::treesitter_types::Span),
    Let(::treesitter_types::Span),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for LexicalDeclarationKind {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        _src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "const" => Ok(Self::Const(::treesitter_types::Span::from(node))),
            "let" => Ok(Self::Let(::treesitter_types::Span::from(node))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for LexicalDeclarationKind {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Const(span) => *span,
            Self::Let(span) => *span,
        }
    }
}
#[derive(Debug, Clone)]
pub enum LiteralTypeChildren<'tree> {
    False(::std::boxed::Box<False<'tree>>),
    Null(::std::boxed::Box<Null<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
    True(::std::boxed::Box<True<'tree>>),
    UnaryExpression(::std::boxed::Box<UnaryExpression<'tree>>),
    Undefined(::std::boxed::Box<Undefined<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for LiteralTypeChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "false" => Ok(Self::False(::std::boxed::Box::new(
                <False as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "null" => Ok(Self::Null(::std::boxed::Box::new(
                <Null as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "true" => Ok(Self::True(::std::boxed::Box::new(
                <True as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "unary_expression" => Ok(Self::UnaryExpression(::std::boxed::Box::new(
                <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
                <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for LiteralTypeChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::False(inner) => inner.span(),
            Self::Null(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::String(inner) => inner.span(),
            Self::True(inner) => inner.span(),
            Self::UnaryExpression(inner) => inner.span(),
            Self::Undefined(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum MemberExpressionObject<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    Import(::std::boxed::Box<Import<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpressionObject<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "import" => Ok(Self::Import(::std::boxed::Box::new(
                <Import as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for MemberExpressionObject<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::Import(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum MemberExpressionProperty<'tree> {
    PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
    PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MemberExpressionProperty<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "private_property_identifier" => {
                Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
                    <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for MemberExpressionProperty<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum MethodDefinitionName<'tree> {
    ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
    PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinitionName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
                <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "private_property_identifier" => {
                Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
                    <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for MethodDefinitionName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ComputedPropertyName(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum MethodDefinitionReturnType<'tree> {
    AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
    TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
    TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinitionReturnType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
                <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate_annotation" => {
                Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
                    <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for MethodDefinitionReturnType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssertsAnnotation(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
            Self::TypePredicateAnnotation(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum MethodDefinitionChildren<'tree> {
    AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
    OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MethodDefinitionChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
                <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
                <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for MethodDefinitionChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AccessibilityModifier(inner) => inner.span(),
            Self::OverrideModifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum MethodSignatureName<'tree> {
    ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
    PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MethodSignatureName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
                <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "private_property_identifier" => {
                Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
                    <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for MethodSignatureName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ComputedPropertyName(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum MethodSignatureReturnType<'tree> {
    AssertsAnnotation(::std::boxed::Box<AssertsAnnotation<'tree>>),
    TypeAnnotation(::std::boxed::Box<TypeAnnotation<'tree>>),
    TypePredicateAnnotation(::std::boxed::Box<TypePredicateAnnotation<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MethodSignatureReturnType<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "asserts_annotation" => Ok(Self::AssertsAnnotation(::std::boxed::Box::new(
                <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_annotation" => Ok(Self::TypeAnnotation(::std::boxed::Box::new(
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "type_predicate_annotation" => {
                Ok(Self::TypePredicateAnnotation(::std::boxed::Box::new(
                    <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for MethodSignatureReturnType<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssertsAnnotation(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
            Self::TypePredicateAnnotation(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum MethodSignatureChildren<'tree> {
    AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
    OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for MethodSignatureChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
                <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
                <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for MethodSignatureChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AccessibilityModifier(inner) => inner.span(),
            Self::OverrideModifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ModuleName<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    NestedIdentifier(::std::boxed::Box<NestedIdentifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ModuleName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "nested_identifier" => Ok(Self::NestedIdentifier(::std::boxed::Box::new(
                <NestedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ModuleName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::NestedIdentifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum NamespaceExportChildren<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for NamespaceExportChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for NamespaceExportChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum NestedIdentifierObject<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for NestedIdentifierObject<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for NestedIdentifierObject<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum NestedTypeIdentifierModule<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    NestedIdentifier(::std::boxed::Box<NestedIdentifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for NestedTypeIdentifierModule<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "nested_identifier" => Ok(Self::NestedIdentifier(::std::boxed::Box::new(
                <NestedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for NestedTypeIdentifierModule<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::NestedIdentifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ObjectChildren<'tree> {
    MethodDefinition(::std::boxed::Box<MethodDefinition<'tree>>),
    Pair(::std::boxed::Box<Pair<'tree>>),
    ShorthandPropertyIdentifier(::std::boxed::Box<ShorthandPropertyIdentifier<'tree>>),
    SpreadElement(::std::boxed::Box<SpreadElement<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "method_definition" => Ok(Self::MethodDefinition(::std::boxed::Box::new(
                <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "pair" => Ok(Self::Pair(::std::boxed::Box::new(
                <Pair as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "shorthand_property_identifier" => {
                Ok(Self::ShorthandPropertyIdentifier(::std::boxed::Box::new(
                    <ShorthandPropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "spread_element" => Ok(Self::SpreadElement(::std::boxed::Box::new(
                <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ObjectChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::MethodDefinition(inner) => inner.span(),
            Self::Pair(inner) => inner.span(),
            Self::ShorthandPropertyIdentifier(inner) => inner.span(),
            Self::SpreadElement(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ObjectAssignmentPatternLeft<'tree> {
    ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
    ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
    ShorthandPropertyIdentifierPattern(
        ::std::boxed::Box<ShorthandPropertyIdentifierPattern<'tree>>,
    ),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectAssignmentPatternLeft<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "array_pattern" => {
                Ok(
                    Self::ArrayPattern(
                        ::std::boxed::Box::new(
                            <ArrayPattern as ::treesitter_types::FromNode>::from_node(
                                node,
                                src,
                            )?,
                        ),
                    ),
                )
            }
            "object_pattern" => {
                Ok(
                    Self::ObjectPattern(
                        ::std::boxed::Box::new(
                            <ObjectPattern as ::treesitter_types::FromNode>::from_node(
                                node,
                                src,
                            )?,
                        ),
                    ),
                )
            }
            "shorthand_property_identifier_pattern" => {
                Ok(
                    Self::ShorthandPropertyIdentifierPattern(
                        ::std::boxed::Box::new(
                            <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
                                node,
                                src,
                            )?,
                        ),
                    ),
                )
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ObjectAssignmentPatternLeft<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ArrayPattern(inner) => inner.span(),
            Self::ObjectPattern(inner) => inner.span(),
            Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ObjectPatternChildren<'tree> {
    ObjectAssignmentPattern(::std::boxed::Box<ObjectAssignmentPattern<'tree>>),
    PairPattern(::std::boxed::Box<PairPattern<'tree>>),
    RestPattern(::std::boxed::Box<RestPattern<'tree>>),
    ShorthandPropertyIdentifierPattern(
        ::std::boxed::Box<ShorthandPropertyIdentifierPattern<'tree>>,
    ),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectPatternChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "object_assignment_pattern" => {
                Ok(
                    Self::ObjectAssignmentPattern(
                        ::std::boxed::Box::new(
                            <ObjectAssignmentPattern as ::treesitter_types::FromNode>::from_node(
                                node,
                                src,
                            )?,
                        ),
                    ),
                )
            }
            "pair_pattern" => {
                Ok(
                    Self::PairPattern(
                        ::std::boxed::Box::new(
                            <PairPattern as ::treesitter_types::FromNode>::from_node(
                                node,
                                src,
                            )?,
                        ),
                    ),
                )
            }
            "rest_pattern" => {
                Ok(
                    Self::RestPattern(
                        ::std::boxed::Box::new(
                            <RestPattern as ::treesitter_types::FromNode>::from_node(
                                node,
                                src,
                            )?,
                        ),
                    ),
                )
            }
            "shorthand_property_identifier_pattern" => {
                Ok(
                    Self::ShorthandPropertyIdentifierPattern(
                        ::std::boxed::Box::new(
                            <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
                                node,
                                src,
                            )?,
                        ),
                    ),
                )
            }
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ObjectPatternChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ObjectAssignmentPattern(inner) => inner.span(),
            Self::PairPattern(inner) => inner.span(),
            Self::RestPattern(inner) => inner.span(),
            Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ObjectTypeChildren<'tree> {
    CallSignature(::std::boxed::Box<CallSignature<'tree>>),
    ConstructSignature(::std::boxed::Box<ConstructSignature<'tree>>),
    ExportStatement(::std::boxed::Box<ExportStatement<'tree>>),
    IndexSignature(::std::boxed::Box<IndexSignature<'tree>>),
    MethodSignature(::std::boxed::Box<MethodSignature<'tree>>),
    PropertySignature(::std::boxed::Box<PropertySignature<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ObjectTypeChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "call_signature" => Ok(Self::CallSignature(::std::boxed::Box::new(
                <CallSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "construct_signature" => Ok(Self::ConstructSignature(::std::boxed::Box::new(
                <ConstructSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "export_statement" => Ok(Self::ExportStatement(::std::boxed::Box::new(
                <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "index_signature" => Ok(Self::IndexSignature(::std::boxed::Box::new(
                <IndexSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "method_signature" => Ok(Self::MethodSignature(::std::boxed::Box::new(
                <MethodSignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "property_signature" => Ok(Self::PropertySignature(::std::boxed::Box::new(
                <PropertySignature as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for ObjectTypeChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::CallSignature(inner) => inner.span(),
            Self::ConstructSignature(inner) => inner.span(),
            Self::ExportStatement(inner) => inner.span(),
            Self::IndexSignature(inner) => inner.span(),
            Self::MethodSignature(inner) => inner.span(),
            Self::PropertySignature(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum OptionalParameterPattern<'tree> {
    Pattern(::std::boxed::Box<Pattern<'tree>>),
    This(::std::boxed::Box<This<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameterPattern<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "this" => Ok(Self::This(::std::boxed::Box::new(
                <This as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Pattern(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for OptionalParameterPattern<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Pattern(inner) => inner.span(),
            Self::This(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum OptionalParameterChildren<'tree> {
    AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
    OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for OptionalParameterChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
                <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
                <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for OptionalParameterChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AccessibilityModifier(inner) => inner.span(),
            Self::OverrideModifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum PairKey<'tree> {
    ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
    PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PairKey<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
                <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "private_property_identifier" => {
                Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
                    <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for PairKey<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ComputedPropertyName(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum PairPatternKey<'tree> {
    ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
    PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PairPatternKey<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
                <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "private_property_identifier" => {
                Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
                    <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for PairPatternKey<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ComputedPropertyName(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum PairPatternValue<'tree> {
    AssignmentPattern(::std::boxed::Box<AssignmentPattern<'tree>>),
    Pattern(::std::boxed::Box<Pattern<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PairPatternValue<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "assignment_pattern" => Ok(Self::AssignmentPattern(::std::boxed::Box::new(
                <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Pattern(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for PairPatternValue<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AssignmentPattern(inner) => inner.span(),
            Self::Pattern(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ParenthesizedExpressionChildren<'tree> {
    CallExpression(::std::boxed::Box<CallExpression<'tree>>),
    Expression(::std::boxed::Box<Expression<'tree>>),
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
    SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ParenthesizedExpressionChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
                <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ParenthesizedExpressionChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::CallExpression(inner) => inner.span(),
            Self::Expression(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ProgramChildren<'tree> {
    HashBangLine(::std::boxed::Box<HashBangLine<'tree>>),
    Statement(::std::boxed::Box<Statement<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ProgramChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "hash_bang_line" => Ok(Self::HashBangLine(::std::boxed::Box::new(
                <HashBangLine as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Statement as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Statement(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ProgramChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::HashBangLine(inner) => inner.span(),
            Self::Statement(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum PropertySignatureName<'tree> {
    ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
    PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PropertySignatureName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
                <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "private_property_identifier" => {
                Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
                    <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for PropertySignatureName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ComputedPropertyName(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum PropertySignatureChildren<'tree> {
    AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
    OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PropertySignatureChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
                <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
                <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for PropertySignatureChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AccessibilityModifier(inner) => inner.span(),
            Self::OverrideModifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum PublicFieldDefinitionName<'tree> {
    ComputedPropertyName(::std::boxed::Box<ComputedPropertyName<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    PrivatePropertyIdentifier(::std::boxed::Box<PrivatePropertyIdentifier<'tree>>),
    PropertyIdentifier(::std::boxed::Box<PropertyIdentifier<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PublicFieldDefinitionName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "computed_property_name" => Ok(Self::ComputedPropertyName(::std::boxed::Box::new(
                <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "private_property_identifier" => {
                Ok(Self::PrivatePropertyIdentifier(::std::boxed::Box::new(
                    <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "property_identifier" => Ok(Self::PropertyIdentifier(::std::boxed::Box::new(
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for PublicFieldDefinitionName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ComputedPropertyName(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum PublicFieldDefinitionChildren<'tree> {
    AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
    OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for PublicFieldDefinitionChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
                <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
                <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for PublicFieldDefinitionChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AccessibilityModifier(inner) => inner.span(),
            Self::OverrideModifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum RequiredParameterName<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    RestPattern(::std::boxed::Box<RestPattern<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for RequiredParameterName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "rest_pattern" => Ok(Self::RestPattern(::std::boxed::Box::new(
                <RestPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for RequiredParameterName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::RestPattern(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum RequiredParameterPattern<'tree> {
    Pattern(::std::boxed::Box<Pattern<'tree>>),
    This(::std::boxed::Box<This<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for RequiredParameterPattern<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "this" => Ok(Self::This(::std::boxed::Box::new(
                <This as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Pattern as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Pattern(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for RequiredParameterPattern<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Pattern(inner) => inner.span(),
            Self::This(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum RequiredParameterChildren<'tree> {
    AccessibilityModifier(::std::boxed::Box<AccessibilityModifier<'tree>>),
    OverrideModifier(::std::boxed::Box<OverrideModifier<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for RequiredParameterChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "accessibility_modifier" => Ok(Self::AccessibilityModifier(::std::boxed::Box::new(
                <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "override_modifier" => Ok(Self::OverrideModifier(::std::boxed::Box::new(
                <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for RequiredParameterChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::AccessibilityModifier(inner) => inner.span(),
            Self::OverrideModifier(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum RestPatternChildren<'tree> {
    ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
    NonNullExpression(::std::boxed::Box<NonNullExpression<'tree>>),
    ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
    SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
    Undefined(::std::boxed::Box<Undefined<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for RestPatternChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
                <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "non_null_expression" => Ok(Self::NonNullExpression(::std::boxed::Box::new(
                <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
                <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
                <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "undefined" => Ok(Self::Undefined(::std::boxed::Box::new(
                <Undefined as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for RestPatternChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ArrayPattern(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::NonNullExpression(inner) => inner.span(),
            Self::ObjectPattern(inner) => inner.span(),
            Self::SubscriptExpression(inner) => inner.span(),
            Self::Undefined(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ReturnStatementChildren<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ReturnStatementChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ReturnStatementChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum SatisfiesExpressionChildren<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    Type(::std::boxed::Box<Type<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SatisfiesExpressionChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
            Ok(Self::Expression(::std::boxed::Box::new(v)))
        } else {
            if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
                Ok(Self::Type(::std::boxed::Box::new(v)))
            } else {
                Err(::treesitter_types::ParseError::unexpected_kind(
                    node.kind(),
                    node,
                ))
            }
        }
    }
}
impl ::treesitter_types::Spanned for SatisfiesExpressionChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::Type(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum StringChildren<'tree> {
    EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
    StringFragment(::std::boxed::Box<StringFragment<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for StringChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
                <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
                <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for StringChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::EscapeSequence(inner) => inner.span(),
            Self::StringFragment(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum SubscriptExpressionIndex<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
    PredefinedType(::std::boxed::Box<PredefinedType<'tree>>),
    SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
    String(::std::boxed::Box<String<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SubscriptExpressionIndex<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "predefined_type" => Ok(Self::PredefinedType(::std::boxed::Box::new(
                <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string" => Ok(Self::String(::std::boxed::Box::new(
                <String as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for SubscriptExpressionIndex<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::PredefinedType(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
            Self::String(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum SwitchBodyChildren<'tree> {
    SwitchCase(::std::boxed::Box<SwitchCase<'tree>>),
    SwitchDefault(::std::boxed::Box<SwitchDefault<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchBodyChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "switch_case" => Ok(Self::SwitchCase(::std::boxed::Box::new(
                <SwitchCase as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "switch_default" => Ok(Self::SwitchDefault(::std::boxed::Box::new(
                <SwitchDefault as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for SwitchBodyChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::SwitchCase(inner) => inner.span(),
            Self::SwitchDefault(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum SwitchCaseValue<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for SwitchCaseValue<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for SwitchCaseValue<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum TemplateLiteralTypeChildren<'tree> {
    StringFragment(::std::boxed::Box<StringFragment<'tree>>),
    TemplateType(::std::boxed::Box<TemplateType<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateLiteralTypeChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
                <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "template_type" => Ok(Self::TemplateType(::std::boxed::Box::new(
                <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for TemplateLiteralTypeChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::StringFragment(inner) => inner.span(),
            Self::TemplateType(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum TemplateStringChildren<'tree> {
    EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
    StringFragment(::std::boxed::Box<StringFragment<'tree>>),
    TemplateSubstitution(::std::boxed::Box<TemplateSubstitution<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateStringChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
                <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "string_fragment" => Ok(Self::StringFragment(::std::boxed::Box::new(
                <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "template_substitution" => Ok(Self::TemplateSubstitution(::std::boxed::Box::new(
                <TemplateSubstitution as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for TemplateStringChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::EscapeSequence(inner) => inner.span(),
            Self::StringFragment(inner) => inner.span(),
            Self::TemplateSubstitution(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum TemplateSubstitutionChildren<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateSubstitutionChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for TemplateSubstitutionChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum TemplateTypeChildren<'tree> {
    InferType(::std::boxed::Box<InferType<'tree>>),
    PrimaryType(::std::boxed::Box<PrimaryType<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TemplateTypeChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "infer_type" => Ok(Self::InferType(::std::boxed::Box::new(
                <InferType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <PrimaryType as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::PrimaryType(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for TemplateTypeChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::InferType(inner) => inner.span(),
            Self::PrimaryType(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum ThrowStatementChildren<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    SequenceExpression(::std::boxed::Box<SequenceExpression<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for ThrowStatementChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "sequence_expression" => Ok(Self::SequenceExpression(::std::boxed::Box::new(
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for ThrowStatementChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum TupleTypeChildren<'tree> {
    OptionalParameter(::std::boxed::Box<OptionalParameter<'tree>>),
    OptionalType(::std::boxed::Box<OptionalType<'tree>>),
    RequiredParameter(::std::boxed::Box<RequiredParameter<'tree>>),
    RestType(::std::boxed::Box<RestType<'tree>>),
    Type(::std::boxed::Box<Type<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TupleTypeChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "optional_parameter" => Ok(Self::OptionalParameter(::std::boxed::Box::new(
                <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "optional_type" => Ok(Self::OptionalType(::std::boxed::Box::new(
                <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "required_parameter" => Ok(Self::RequiredParameter(::std::boxed::Box::new(
                <RequiredParameter as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "rest_type" => Ok(Self::RestType(::std::boxed::Box::new(
                <RestType as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Type as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Type(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for TupleTypeChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::OptionalParameter(inner) => inner.span(),
            Self::OptionalType(inner) => inner.span(),
            Self::RequiredParameter(inner) => inner.span(),
            Self::RestType(inner) => inner.span(),
            Self::Type(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum TypeAssertionChildren<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    TypeArguments(::std::boxed::Box<TypeArguments<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypeAssertionChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "type_arguments" => Ok(Self::TypeArguments(::std::boxed::Box::new(
                <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for TypeAssertionChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::TypeArguments(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum TypePredicateName<'tree> {
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    This(::std::boxed::Box<This<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypePredicateName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "this" => Ok(Self::This(::std::boxed::Box::new(
                <This as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for TypePredicateName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Identifier(inner) => inner.span(),
            Self::This(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum TypeQueryChildren<'tree> {
    CallExpression(::std::boxed::Box<CallExpression<'tree>>),
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    InstantiationExpression(::std::boxed::Box<InstantiationExpression<'tree>>),
    MemberExpression(::std::boxed::Box<MemberExpression<'tree>>),
    SubscriptExpression(::std::boxed::Box<SubscriptExpression<'tree>>),
    This(::std::boxed::Box<This<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for TypeQueryChildren<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "call_expression" => Ok(Self::CallExpression(::std::boxed::Box::new(
                <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "instantiation_expression" => {
                Ok(Self::InstantiationExpression(::std::boxed::Box::new(
                    <InstantiationExpression as ::treesitter_types::FromNode>::from_node(
                        node, src,
                    )?,
                )))
            }
            "member_expression" => Ok(Self::MemberExpression(::std::boxed::Box::new(
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "subscript_expression" => Ok(Self::SubscriptExpression(::std::boxed::Box::new(
                <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "this" => Ok(Self::This(::std::boxed::Box::new(
                <This as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for TypeQueryChildren<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::CallExpression(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::InstantiationExpression(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::SubscriptExpression(inner) => inner.span(),
            Self::This(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum UnaryExpressionArgument<'tree> {
    Expression(::std::boxed::Box<Expression<'tree>>),
    Number(::std::boxed::Box<Number<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionArgument<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "number" => Ok(Self::Number(::std::boxed::Box::new(
                <Number as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            _other => {
                if let Ok(v) = <Expression as ::treesitter_types::FromNode>::from_node(node, src) {
                    Ok(Self::Expression(::std::boxed::Box::new(v)))
                } else {
                    Err(::treesitter_types::ParseError::unexpected_kind(
                        _other, node,
                    ))
                }
            }
        }
    }
}
impl ::treesitter_types::Spanned for UnaryExpressionArgument<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Expression(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum UnaryExpressionOperator {
    Bang(::treesitter_types::Span),
    Plus(::treesitter_types::Span),
    Minus(::treesitter_types::Span),
    Delete(::treesitter_types::Span),
    Typeof(::treesitter_types::Span),
    Void(::treesitter_types::Span),
    Tilde(::treesitter_types::Span),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryExpressionOperator {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        _src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
            "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
            "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
            "delete" => Ok(Self::Delete(::treesitter_types::Span::from(node))),
            "typeof" => Ok(Self::Typeof(::treesitter_types::Span::from(node))),
            "void" => Ok(Self::Void(::treesitter_types::Span::from(node))),
            "~" => Ok(Self::Tilde(::treesitter_types::Span::from(node))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for UnaryExpressionOperator {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Bang(span) => *span,
            Self::Plus(span) => *span,
            Self::Minus(span) => *span,
            Self::Delete(span) => *span,
            Self::Typeof(span) => *span,
            Self::Void(span) => *span,
            Self::Tilde(span) => *span,
        }
    }
}
#[derive(Debug, Clone)]
pub enum UpdateExpressionOperator {
    PlusPlus(::treesitter_types::Span),
    MinusMinus(::treesitter_types::Span),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for UpdateExpressionOperator {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        _src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
            "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for UpdateExpressionOperator {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::PlusPlus(span) => *span,
            Self::MinusMinus(span) => *span,
        }
    }
}
#[derive(Debug, Clone)]
pub enum VariableDeclaratorName<'tree> {
    ArrayPattern(::std::boxed::Box<ArrayPattern<'tree>>),
    Identifier(::std::boxed::Box<Identifier<'tree>>),
    ObjectPattern(::std::boxed::Box<ObjectPattern<'tree>>),
}
impl<'tree> ::treesitter_types::FromNode<'tree> for VariableDeclaratorName<'tree> {
    #[allow(clippy::collapsible_else_if)]
    fn from_node(
        node: ::tree_sitter::Node<'tree>,
        src: &'tree [u8],
    ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
        match node.kind() {
            "array_pattern" => Ok(Self::ArrayPattern(::std::boxed::Box::new(
                <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
                <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            "object_pattern" => Ok(Self::ObjectPattern(::std::boxed::Box::new(
                <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)?,
            ))),
            other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
        }
    }
}
impl ::treesitter_types::Spanned for VariableDeclaratorName<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::ArrayPattern(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::ObjectPattern(inner) => inner.span(),
        }
    }
}
#[derive(Debug, Clone)]
pub enum AnyNode<'tree> {
    Declaration(Declaration<'tree>),
    Expression(Expression<'tree>),
    Pattern(Pattern<'tree>),
    PrimaryExpression(PrimaryExpression<'tree>),
    PrimaryType(PrimaryType<'tree>),
    Statement(Statement<'tree>),
    Type(Type<'tree>),
    AbstractClassDeclaration(AbstractClassDeclaration<'tree>),
    AbstractMethodSignature(AbstractMethodSignature<'tree>),
    AccessibilityModifier(AccessibilityModifier<'tree>),
    AddingTypeAnnotation(AddingTypeAnnotation<'tree>),
    AmbientDeclaration(AmbientDeclaration<'tree>),
    Arguments(Arguments<'tree>),
    Array(Array<'tree>),
    ArrayPattern(ArrayPattern<'tree>),
    ArrayType(ArrayType<'tree>),
    ArrowFunction(ArrowFunction<'tree>),
    AsExpression(AsExpression<'tree>),
    Asserts(Asserts<'tree>),
    AssertsAnnotation(AssertsAnnotation<'tree>),
    AssignmentExpression(AssignmentExpression<'tree>),
    AssignmentPattern(AssignmentPattern<'tree>),
    AugmentedAssignmentExpression(AugmentedAssignmentExpression<'tree>),
    AwaitExpression(AwaitExpression<'tree>),
    BinaryExpression(BinaryExpression<'tree>),
    BreakStatement(BreakStatement<'tree>),
    CallExpression(CallExpression<'tree>),
    CallSignature(CallSignature<'tree>),
    CatchClause(CatchClause<'tree>),
    Class(Class<'tree>),
    ClassBody(ClassBody<'tree>),
    ClassDeclaration(ClassDeclaration<'tree>),
    ClassHeritage(ClassHeritage<'tree>),
    ClassStaticBlock(ClassStaticBlock<'tree>),
    ComputedPropertyName(ComputedPropertyName<'tree>),
    ConditionalType(ConditionalType<'tree>),
    Constraint(Constraint<'tree>),
    ConstructSignature(ConstructSignature<'tree>),
    ConstructorType(ConstructorType<'tree>),
    ContinueStatement(ContinueStatement<'tree>),
    DebuggerStatement(DebuggerStatement<'tree>),
    Decorator(Decorator<'tree>),
    DefaultType(DefaultType<'tree>),
    DoStatement(DoStatement<'tree>),
    ElseClause(ElseClause<'tree>),
    EmptyStatement(EmptyStatement<'tree>),
    EnumAssignment(EnumAssignment<'tree>),
    EnumBody(EnumBody<'tree>),
    EnumDeclaration(EnumDeclaration<'tree>),
    ExistentialType(ExistentialType<'tree>),
    ExportClause(ExportClause<'tree>),
    ExportSpecifier(ExportSpecifier<'tree>),
    ExportStatement(ExportStatement<'tree>),
    ExpressionStatement(ExpressionStatement<'tree>),
    ExtendsClause(ExtendsClause<'tree>),
    ExtendsTypeClause(ExtendsTypeClause<'tree>),
    FinallyClause(FinallyClause<'tree>),
    FlowMaybeType(FlowMaybeType<'tree>),
    ForInStatement(ForInStatement<'tree>),
    ForStatement(ForStatement<'tree>),
    FormalParameters(FormalParameters<'tree>),
    FunctionDeclaration(FunctionDeclaration<'tree>),
    FunctionExpression(FunctionExpression<'tree>),
    FunctionSignature(FunctionSignature<'tree>),
    FunctionType(FunctionType<'tree>),
    GeneratorFunction(GeneratorFunction<'tree>),
    GeneratorFunctionDeclaration(GeneratorFunctionDeclaration<'tree>),
    GenericType(GenericType<'tree>),
    Identifier(Identifier<'tree>),
    IfStatement(IfStatement<'tree>),
    ImplementsClause(ImplementsClause<'tree>),
    Import(Import<'tree>),
    ImportAlias(ImportAlias<'tree>),
    ImportAttribute(ImportAttribute<'tree>),
    ImportClause(ImportClause<'tree>),
    ImportRequireClause(ImportRequireClause<'tree>),
    ImportSpecifier(ImportSpecifier<'tree>),
    ImportStatement(ImportStatement<'tree>),
    IndexSignature(IndexSignature<'tree>),
    IndexTypeQuery(IndexTypeQuery<'tree>),
    InferType(InferType<'tree>),
    InstantiationExpression(InstantiationExpression<'tree>),
    InterfaceBody(InterfaceBody<'tree>),
    InterfaceDeclaration(InterfaceDeclaration<'tree>),
    InternalModule(InternalModule<'tree>),
    IntersectionType(IntersectionType<'tree>),
    LabeledStatement(LabeledStatement<'tree>),
    LexicalDeclaration(LexicalDeclaration<'tree>),
    LiteralType(LiteralType<'tree>),
    LookupType(LookupType<'tree>),
    MappedTypeClause(MappedTypeClause<'tree>),
    MemberExpression(MemberExpression<'tree>),
    MetaProperty(MetaProperty<'tree>),
    MethodDefinition(MethodDefinition<'tree>),
    MethodSignature(MethodSignature<'tree>),
    Module(Module<'tree>),
    NamedImports(NamedImports<'tree>),
    NamespaceExport(NamespaceExport<'tree>),
    NamespaceImport(NamespaceImport<'tree>),
    NestedIdentifier(NestedIdentifier<'tree>),
    NestedTypeIdentifier(NestedTypeIdentifier<'tree>),
    NewExpression(NewExpression<'tree>),
    NonNullExpression(NonNullExpression<'tree>),
    Object(Object<'tree>),
    ObjectAssignmentPattern(ObjectAssignmentPattern<'tree>),
    ObjectPattern(ObjectPattern<'tree>),
    ObjectType(ObjectType<'tree>),
    OmittingTypeAnnotation(OmittingTypeAnnotation<'tree>),
    OptingTypeAnnotation(OptingTypeAnnotation<'tree>),
    OptionalChain(OptionalChain<'tree>),
    OptionalParameter(OptionalParameter<'tree>),
    OptionalType(OptionalType<'tree>),
    OverrideModifier(OverrideModifier<'tree>),
    Pair(Pair<'tree>),
    PairPattern(PairPattern<'tree>),
    ParenthesizedExpression(ParenthesizedExpression<'tree>),
    ParenthesizedType(ParenthesizedType<'tree>),
    PredefinedType(PredefinedType<'tree>),
    Program(Program<'tree>),
    PropertySignature(PropertySignature<'tree>),
    PublicFieldDefinition(PublicFieldDefinition<'tree>),
    ReadonlyType(ReadonlyType<'tree>),
    Regex(Regex<'tree>),
    RequiredParameter(RequiredParameter<'tree>),
    RestPattern(RestPattern<'tree>),
    RestType(RestType<'tree>),
    ReturnStatement(ReturnStatement<'tree>),
    SatisfiesExpression(SatisfiesExpression<'tree>),
    SequenceExpression(SequenceExpression<'tree>),
    SpreadElement(SpreadElement<'tree>),
    StatementBlock(StatementBlock<'tree>),
    String(String<'tree>),
    SubscriptExpression(SubscriptExpression<'tree>),
    SwitchBody(SwitchBody<'tree>),
    SwitchCase(SwitchCase<'tree>),
    SwitchDefault(SwitchDefault<'tree>),
    SwitchStatement(SwitchStatement<'tree>),
    TemplateLiteralType(TemplateLiteralType<'tree>),
    TemplateString(TemplateString<'tree>),
    TemplateSubstitution(TemplateSubstitution<'tree>),
    TemplateType(TemplateType<'tree>),
    TernaryExpression(TernaryExpression<'tree>),
    ThrowStatement(ThrowStatement<'tree>),
    TryStatement(TryStatement<'tree>),
    TupleType(TupleType<'tree>),
    TypeAliasDeclaration(TypeAliasDeclaration<'tree>),
    TypeAnnotation(TypeAnnotation<'tree>),
    TypeArguments(TypeArguments<'tree>),
    TypeAssertion(TypeAssertion<'tree>),
    TypeParameter(TypeParameter<'tree>),
    TypeParameters(TypeParameters<'tree>),
    TypePredicate(TypePredicate<'tree>),
    TypePredicateAnnotation(TypePredicateAnnotation<'tree>),
    TypeQuery(TypeQuery<'tree>),
    UnaryExpression(UnaryExpression<'tree>),
    UnionType(UnionType<'tree>),
    UpdateExpression(UpdateExpression<'tree>),
    VariableDeclaration(VariableDeclaration<'tree>),
    VariableDeclarator(VariableDeclarator<'tree>),
    WhileStatement(WhileStatement<'tree>),
    WithStatement(WithStatement<'tree>),
    YieldExpression(YieldExpression<'tree>),
    Comment(Comment<'tree>),
    EscapeSequence(EscapeSequence<'tree>),
    False(False<'tree>),
    HashBangLine(HashBangLine<'tree>),
    HtmlComment(HtmlComment<'tree>),
    Null(Null<'tree>),
    Number(Number<'tree>),
    PrivatePropertyIdentifier(PrivatePropertyIdentifier<'tree>),
    PropertyIdentifier(PropertyIdentifier<'tree>),
    RegexFlags(RegexFlags<'tree>),
    RegexPattern(RegexPattern<'tree>),
    ShorthandPropertyIdentifier(ShorthandPropertyIdentifier<'tree>),
    ShorthandPropertyIdentifierPattern(ShorthandPropertyIdentifierPattern<'tree>),
    StatementIdentifier(StatementIdentifier<'tree>),
    StringFragment(StringFragment<'tree>),
    Super(Super<'tree>),
    This(This<'tree>),
    ThisType(ThisType<'tree>),
    True(True<'tree>),
    TypeIdentifier(TypeIdentifier<'tree>),
    Undefined(Undefined<'tree>),
    Unknown(::tree_sitter::Node<'tree>),
}
impl<'tree> AnyNode<'tree> {
    pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
        match node.kind() {
            "declaration" => <Declaration as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Declaration)
                .unwrap_or(Self::Unknown(node)),
            "expression" => <Expression as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Expression)
                .unwrap_or(Self::Unknown(node)),
            "pattern" => <Pattern as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Pattern)
                .unwrap_or(Self::Unknown(node)),
            "primary_expression" => {
                <PrimaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::PrimaryExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "primary_type" => <PrimaryType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::PrimaryType)
                .unwrap_or(Self::Unknown(node)),
            "statement" => <Statement as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Statement)
                .unwrap_or(Self::Unknown(node)),
            "type" => <Type as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Type)
                .unwrap_or(Self::Unknown(node)),
            "abstract_class_declaration" => {
                <AbstractClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::AbstractClassDeclaration)
                    .unwrap_or(Self::Unknown(node))
            }
            "abstract_method_signature" => {
                <AbstractMethodSignature as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::AbstractMethodSignature)
                    .unwrap_or(Self::Unknown(node))
            }
            "accessibility_modifier" => {
                <AccessibilityModifier as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::AccessibilityModifier)
                    .unwrap_or(Self::Unknown(node))
            }
            "adding_type_annotation" => {
                <AddingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::AddingTypeAnnotation)
                    .unwrap_or(Self::Unknown(node))
            }
            "ambient_declaration" => {
                <AmbientDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::AmbientDeclaration)
                    .unwrap_or(Self::Unknown(node))
            }
            "arguments" => <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Arguments)
                .unwrap_or(Self::Unknown(node)),
            "array" => <Array as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Array)
                .unwrap_or(Self::Unknown(node)),
            "array_pattern" => <ArrayPattern as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::ArrayPattern)
                .unwrap_or(Self::Unknown(node)),
            "array_type" => <ArrayType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::ArrayType)
                .unwrap_or(Self::Unknown(node)),
            "arrow_function" => {
                <ArrowFunction as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ArrowFunction)
                    .unwrap_or(Self::Unknown(node))
            }
            "as_expression" => <AsExpression as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::AsExpression)
                .unwrap_or(Self::Unknown(node)),
            "asserts" => <Asserts as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Asserts)
                .unwrap_or(Self::Unknown(node)),
            "asserts_annotation" => {
                <AssertsAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::AssertsAnnotation)
                    .unwrap_or(Self::Unknown(node))
            }
            "assignment_expression" => {
                <AssignmentExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::AssignmentExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "assignment_pattern" => {
                <AssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::AssignmentPattern)
                    .unwrap_or(Self::Unknown(node))
            }
            "augmented_assignment_expression" => {
                <AugmentedAssignmentExpression as ::treesitter_types::FromNode>::from_node(
                    node, src,
                )
                .map(Self::AugmentedAssignmentExpression)
                .unwrap_or(Self::Unknown(node))
            }
            "await_expression" => {
                <AwaitExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::AwaitExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "binary_expression" => {
                <BinaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::BinaryExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "break_statement" => {
                <BreakStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::BreakStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "call_expression" => {
                <CallExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::CallExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "call_signature" => {
                <CallSignature as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::CallSignature)
                    .unwrap_or(Self::Unknown(node))
            }
            "catch_clause" => <CatchClause as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::CatchClause)
                .unwrap_or(Self::Unknown(node)),
            "class" => <Class as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Class)
                .unwrap_or(Self::Unknown(node)),
            "class_body" => <ClassBody as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::ClassBody)
                .unwrap_or(Self::Unknown(node)),
            "class_declaration" => {
                <ClassDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ClassDeclaration)
                    .unwrap_or(Self::Unknown(node))
            }
            "class_heritage" => {
                <ClassHeritage as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ClassHeritage)
                    .unwrap_or(Self::Unknown(node))
            }
            "class_static_block" => {
                <ClassStaticBlock as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ClassStaticBlock)
                    .unwrap_or(Self::Unknown(node))
            }
            "computed_property_name" => {
                <ComputedPropertyName as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ComputedPropertyName)
                    .unwrap_or(Self::Unknown(node))
            }
            "conditional_type" => {
                <ConditionalType as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ConditionalType)
                    .unwrap_or(Self::Unknown(node))
            }
            "constraint" => <Constraint as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Constraint)
                .unwrap_or(Self::Unknown(node)),
            "construct_signature" => {
                <ConstructSignature as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ConstructSignature)
                    .unwrap_or(Self::Unknown(node))
            }
            "constructor_type" => {
                <ConstructorType as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ConstructorType)
                    .unwrap_or(Self::Unknown(node))
            }
            "continue_statement" => {
                <ContinueStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ContinueStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "debugger_statement" => {
                <DebuggerStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::DebuggerStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "decorator" => <Decorator as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Decorator)
                .unwrap_or(Self::Unknown(node)),
            "default_type" => <DefaultType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::DefaultType)
                .unwrap_or(Self::Unknown(node)),
            "do_statement" => <DoStatement as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::DoStatement)
                .unwrap_or(Self::Unknown(node)),
            "else_clause" => <ElseClause as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::ElseClause)
                .unwrap_or(Self::Unknown(node)),
            "empty_statement" => {
                <EmptyStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::EmptyStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "enum_assignment" => {
                <EnumAssignment as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::EnumAssignment)
                    .unwrap_or(Self::Unknown(node))
            }
            "enum_body" => <EnumBody as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::EnumBody)
                .unwrap_or(Self::Unknown(node)),
            "enum_declaration" => {
                <EnumDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::EnumDeclaration)
                    .unwrap_or(Self::Unknown(node))
            }
            "existential_type" => {
                <ExistentialType as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ExistentialType)
                    .unwrap_or(Self::Unknown(node))
            }
            "export_clause" => <ExportClause as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::ExportClause)
                .unwrap_or(Self::Unknown(node)),
            "export_specifier" => {
                <ExportSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ExportSpecifier)
                    .unwrap_or(Self::Unknown(node))
            }
            "export_statement" => {
                <ExportStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ExportStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "expression_statement" => {
                <ExpressionStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ExpressionStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "extends_clause" => {
                <ExtendsClause as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ExtendsClause)
                    .unwrap_or(Self::Unknown(node))
            }
            "extends_type_clause" => {
                <ExtendsTypeClause as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ExtendsTypeClause)
                    .unwrap_or(Self::Unknown(node))
            }
            "finally_clause" => {
                <FinallyClause as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::FinallyClause)
                    .unwrap_or(Self::Unknown(node))
            }
            "flow_maybe_type" => {
                <FlowMaybeType as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::FlowMaybeType)
                    .unwrap_or(Self::Unknown(node))
            }
            "for_in_statement" => {
                <ForInStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ForInStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "for_statement" => <ForStatement as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::ForStatement)
                .unwrap_or(Self::Unknown(node)),
            "formal_parameters" => {
                <FormalParameters as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::FormalParameters)
                    .unwrap_or(Self::Unknown(node))
            }
            "function_declaration" => {
                <FunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::FunctionDeclaration)
                    .unwrap_or(Self::Unknown(node))
            }
            "function_expression" => {
                <FunctionExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::FunctionExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "function_signature" => {
                <FunctionSignature as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::FunctionSignature)
                    .unwrap_or(Self::Unknown(node))
            }
            "function_type" => <FunctionType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::FunctionType)
                .unwrap_or(Self::Unknown(node)),
            "generator_function" => {
                <GeneratorFunction as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::GeneratorFunction)
                    .unwrap_or(Self::Unknown(node))
            }
            "generator_function_declaration" => {
                <GeneratorFunctionDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::GeneratorFunctionDeclaration)
                    .unwrap_or(Self::Unknown(node))
            }
            "generic_type" => <GenericType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::GenericType)
                .unwrap_or(Self::Unknown(node)),
            "identifier" => <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Identifier)
                .unwrap_or(Self::Unknown(node)),
            "if_statement" => <IfStatement as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::IfStatement)
                .unwrap_or(Self::Unknown(node)),
            "implements_clause" => {
                <ImplementsClause as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ImplementsClause)
                    .unwrap_or(Self::Unknown(node))
            }
            "import" => <Import as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Import)
                .unwrap_or(Self::Unknown(node)),
            "import_alias" => <ImportAlias as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::ImportAlias)
                .unwrap_or(Self::Unknown(node)),
            "import_attribute" => {
                <ImportAttribute as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ImportAttribute)
                    .unwrap_or(Self::Unknown(node))
            }
            "import_clause" => <ImportClause as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::ImportClause)
                .unwrap_or(Self::Unknown(node)),
            "import_require_clause" => {
                <ImportRequireClause as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ImportRequireClause)
                    .unwrap_or(Self::Unknown(node))
            }
            "import_specifier" => {
                <ImportSpecifier as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ImportSpecifier)
                    .unwrap_or(Self::Unknown(node))
            }
            "import_statement" => {
                <ImportStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ImportStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "index_signature" => {
                <IndexSignature as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::IndexSignature)
                    .unwrap_or(Self::Unknown(node))
            }
            "index_type_query" => {
                <IndexTypeQuery as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::IndexTypeQuery)
                    .unwrap_or(Self::Unknown(node))
            }
            "infer_type" => <InferType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::InferType)
                .unwrap_or(Self::Unknown(node)),
            "instantiation_expression" => {
                <InstantiationExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::InstantiationExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "interface_body" => {
                <InterfaceBody as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::InterfaceBody)
                    .unwrap_or(Self::Unknown(node))
            }
            "interface_declaration" => {
                <InterfaceDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::InterfaceDeclaration)
                    .unwrap_or(Self::Unknown(node))
            }
            "internal_module" => {
                <InternalModule as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::InternalModule)
                    .unwrap_or(Self::Unknown(node))
            }
            "intersection_type" => {
                <IntersectionType as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::IntersectionType)
                    .unwrap_or(Self::Unknown(node))
            }
            "labeled_statement" => {
                <LabeledStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::LabeledStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "lexical_declaration" => {
                <LexicalDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::LexicalDeclaration)
                    .unwrap_or(Self::Unknown(node))
            }
            "literal_type" => <LiteralType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::LiteralType)
                .unwrap_or(Self::Unknown(node)),
            "lookup_type" => <LookupType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::LookupType)
                .unwrap_or(Self::Unknown(node)),
            "mapped_type_clause" => {
                <MappedTypeClause as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::MappedTypeClause)
                    .unwrap_or(Self::Unknown(node))
            }
            "member_expression" => {
                <MemberExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::MemberExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "meta_property" => <MetaProperty as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::MetaProperty)
                .unwrap_or(Self::Unknown(node)),
            "method_definition" => {
                <MethodDefinition as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::MethodDefinition)
                    .unwrap_or(Self::Unknown(node))
            }
            "method_signature" => {
                <MethodSignature as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::MethodSignature)
                    .unwrap_or(Self::Unknown(node))
            }
            "module" => <Module as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Module)
                .unwrap_or(Self::Unknown(node)),
            "named_imports" => <NamedImports as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::NamedImports)
                .unwrap_or(Self::Unknown(node)),
            "namespace_export" => {
                <NamespaceExport as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::NamespaceExport)
                    .unwrap_or(Self::Unknown(node))
            }
            "namespace_import" => {
                <NamespaceImport as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::NamespaceImport)
                    .unwrap_or(Self::Unknown(node))
            }
            "nested_identifier" => {
                <NestedIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::NestedIdentifier)
                    .unwrap_or(Self::Unknown(node))
            }
            "nested_type_identifier" => {
                <NestedTypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::NestedTypeIdentifier)
                    .unwrap_or(Self::Unknown(node))
            }
            "new_expression" => {
                <NewExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::NewExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "non_null_expression" => {
                <NonNullExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::NonNullExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "object" => <Object as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Object)
                .unwrap_or(Self::Unknown(node)),
            "object_assignment_pattern" => {
                <ObjectAssignmentPattern as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ObjectAssignmentPattern)
                    .unwrap_or(Self::Unknown(node))
            }
            "object_pattern" => {
                <ObjectPattern as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ObjectPattern)
                    .unwrap_or(Self::Unknown(node))
            }
            "object_type" => <ObjectType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::ObjectType)
                .unwrap_or(Self::Unknown(node)),
            "omitting_type_annotation" => {
                <OmittingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::OmittingTypeAnnotation)
                    .unwrap_or(Self::Unknown(node))
            }
            "opting_type_annotation" => {
                <OptingTypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::OptingTypeAnnotation)
                    .unwrap_or(Self::Unknown(node))
            }
            "optional_chain" => {
                <OptionalChain as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::OptionalChain)
                    .unwrap_or(Self::Unknown(node))
            }
            "optional_parameter" => {
                <OptionalParameter as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::OptionalParameter)
                    .unwrap_or(Self::Unknown(node))
            }
            "optional_type" => <OptionalType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::OptionalType)
                .unwrap_or(Self::Unknown(node)),
            "override_modifier" => {
                <OverrideModifier as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::OverrideModifier)
                    .unwrap_or(Self::Unknown(node))
            }
            "pair" => <Pair as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Pair)
                .unwrap_or(Self::Unknown(node)),
            "pair_pattern" => <PairPattern as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::PairPattern)
                .unwrap_or(Self::Unknown(node)),
            "parenthesized_expression" => {
                <ParenthesizedExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ParenthesizedExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "parenthesized_type" => {
                <ParenthesizedType as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ParenthesizedType)
                    .unwrap_or(Self::Unknown(node))
            }
            "predefined_type" => {
                <PredefinedType as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::PredefinedType)
                    .unwrap_or(Self::Unknown(node))
            }
            "program" => <Program as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Program)
                .unwrap_or(Self::Unknown(node)),
            "property_signature" => {
                <PropertySignature as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::PropertySignature)
                    .unwrap_or(Self::Unknown(node))
            }
            "public_field_definition" => {
                <PublicFieldDefinition as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::PublicFieldDefinition)
                    .unwrap_or(Self::Unknown(node))
            }
            "readonly_type" => <ReadonlyType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::ReadonlyType)
                .unwrap_or(Self::Unknown(node)),
            "regex" => <Regex as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Regex)
                .unwrap_or(Self::Unknown(node)),
            "required_parameter" => {
                <RequiredParameter as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::RequiredParameter)
                    .unwrap_or(Self::Unknown(node))
            }
            "rest_pattern" => <RestPattern as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::RestPattern)
                .unwrap_or(Self::Unknown(node)),
            "rest_type" => <RestType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::RestType)
                .unwrap_or(Self::Unknown(node)),
            "return_statement" => {
                <ReturnStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ReturnStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "satisfies_expression" => {
                <SatisfiesExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::SatisfiesExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "sequence_expression" => {
                <SequenceExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::SequenceExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "spread_element" => {
                <SpreadElement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::SpreadElement)
                    .unwrap_or(Self::Unknown(node))
            }
            "statement_block" => {
                <StatementBlock as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::StatementBlock)
                    .unwrap_or(Self::Unknown(node))
            }
            "string" => <String as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::String)
                .unwrap_or(Self::Unknown(node)),
            "subscript_expression" => {
                <SubscriptExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::SubscriptExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "switch_body" => <SwitchBody as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::SwitchBody)
                .unwrap_or(Self::Unknown(node)),
            "switch_case" => <SwitchCase as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::SwitchCase)
                .unwrap_or(Self::Unknown(node)),
            "switch_default" => {
                <SwitchDefault as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::SwitchDefault)
                    .unwrap_or(Self::Unknown(node))
            }
            "switch_statement" => {
                <SwitchStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::SwitchStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "template_literal_type" => {
                <TemplateLiteralType as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TemplateLiteralType)
                    .unwrap_or(Self::Unknown(node))
            }
            "template_string" => {
                <TemplateString as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TemplateString)
                    .unwrap_or(Self::Unknown(node))
            }
            "template_substitution" => {
                <TemplateSubstitution as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TemplateSubstitution)
                    .unwrap_or(Self::Unknown(node))
            }
            "template_type" => <TemplateType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::TemplateType)
                .unwrap_or(Self::Unknown(node)),
            "ternary_expression" => {
                <TernaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TernaryExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "throw_statement" => {
                <ThrowStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ThrowStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "try_statement" => <TryStatement as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::TryStatement)
                .unwrap_or(Self::Unknown(node)),
            "tuple_type" => <TupleType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::TupleType)
                .unwrap_or(Self::Unknown(node)),
            "type_alias_declaration" => {
                <TypeAliasDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TypeAliasDeclaration)
                    .unwrap_or(Self::Unknown(node))
            }
            "type_annotation" => {
                <TypeAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TypeAnnotation)
                    .unwrap_or(Self::Unknown(node))
            }
            "type_arguments" => {
                <TypeArguments as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TypeArguments)
                    .unwrap_or(Self::Unknown(node))
            }
            "type_assertion" => {
                <TypeAssertion as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TypeAssertion)
                    .unwrap_or(Self::Unknown(node))
            }
            "type_parameter" => {
                <TypeParameter as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TypeParameter)
                    .unwrap_or(Self::Unknown(node))
            }
            "type_parameters" => {
                <TypeParameters as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TypeParameters)
                    .unwrap_or(Self::Unknown(node))
            }
            "type_predicate" => {
                <TypePredicate as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TypePredicate)
                    .unwrap_or(Self::Unknown(node))
            }
            "type_predicate_annotation" => {
                <TypePredicateAnnotation as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TypePredicateAnnotation)
                    .unwrap_or(Self::Unknown(node))
            }
            "type_query" => <TypeQuery as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::TypeQuery)
                .unwrap_or(Self::Unknown(node)),
            "unary_expression" => {
                <UnaryExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::UnaryExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "union_type" => <UnionType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::UnionType)
                .unwrap_or(Self::Unknown(node)),
            "update_expression" => {
                <UpdateExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::UpdateExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "variable_declaration" => {
                <VariableDeclaration as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::VariableDeclaration)
                    .unwrap_or(Self::Unknown(node))
            }
            "variable_declarator" => {
                <VariableDeclarator as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::VariableDeclarator)
                    .unwrap_or(Self::Unknown(node))
            }
            "while_statement" => {
                <WhileStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::WhileStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "with_statement" => {
                <WithStatement as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::WithStatement)
                    .unwrap_or(Self::Unknown(node))
            }
            "yield_expression" => {
                <YieldExpression as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::YieldExpression)
                    .unwrap_or(Self::Unknown(node))
            }
            "comment" => <Comment as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Comment)
                .unwrap_or(Self::Unknown(node)),
            "escape_sequence" => {
                <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::EscapeSequence)
                    .unwrap_or(Self::Unknown(node))
            }
            "false" => <False as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::False)
                .unwrap_or(Self::Unknown(node)),
            "hash_bang_line" => {
                <HashBangLine as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::HashBangLine)
                    .unwrap_or(Self::Unknown(node))
            }
            "html_comment" => <HtmlComment as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::HtmlComment)
                .unwrap_or(Self::Unknown(node)),
            "null" => <Null as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Null)
                .unwrap_or(Self::Unknown(node)),
            "number" => <Number as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Number)
                .unwrap_or(Self::Unknown(node)),
            "private_property_identifier" => {
                <PrivatePropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::PrivatePropertyIdentifier)
                    .unwrap_or(Self::Unknown(node))
            }
            "property_identifier" => {
                <PropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::PropertyIdentifier)
                    .unwrap_or(Self::Unknown(node))
            }
            "regex_flags" => <RegexFlags as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::RegexFlags)
                .unwrap_or(Self::Unknown(node)),
            "regex_pattern" => <RegexPattern as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::RegexPattern)
                .unwrap_or(Self::Unknown(node)),
            "shorthand_property_identifier" => {
                <ShorthandPropertyIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::ShorthandPropertyIdentifier)
                    .unwrap_or(Self::Unknown(node))
            }
            "shorthand_property_identifier_pattern" => {
                <ShorthandPropertyIdentifierPattern as ::treesitter_types::FromNode>::from_node(
                    node, src,
                )
                .map(Self::ShorthandPropertyIdentifierPattern)
                .unwrap_or(Self::Unknown(node))
            }
            "statement_identifier" => {
                <StatementIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::StatementIdentifier)
                    .unwrap_or(Self::Unknown(node))
            }
            "string_fragment" => {
                <StringFragment as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::StringFragment)
                    .unwrap_or(Self::Unknown(node))
            }
            "super" => <Super as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Super)
                .unwrap_or(Self::Unknown(node)),
            "this" => <This as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::This)
                .unwrap_or(Self::Unknown(node)),
            "this_type" => <ThisType as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::ThisType)
                .unwrap_or(Self::Unknown(node)),
            "true" => <True as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::True)
                .unwrap_or(Self::Unknown(node)),
            "type_identifier" => {
                <TypeIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
                    .map(Self::TypeIdentifier)
                    .unwrap_or(Self::Unknown(node))
            }
            "undefined" => <Undefined as ::treesitter_types::FromNode>::from_node(node, src)
                .map(Self::Undefined)
                .unwrap_or(Self::Unknown(node)),
            _ => Self::Unknown(node),
        }
    }
}
impl ::treesitter_types::Spanned for AnyNode<'_> {
    fn span(&self) -> ::treesitter_types::Span {
        match self {
            Self::Declaration(inner) => inner.span(),
            Self::Expression(inner) => inner.span(),
            Self::Pattern(inner) => inner.span(),
            Self::PrimaryExpression(inner) => inner.span(),
            Self::PrimaryType(inner) => inner.span(),
            Self::Statement(inner) => inner.span(),
            Self::Type(inner) => inner.span(),
            Self::AbstractClassDeclaration(inner) => inner.span(),
            Self::AbstractMethodSignature(inner) => inner.span(),
            Self::AccessibilityModifier(inner) => inner.span(),
            Self::AddingTypeAnnotation(inner) => inner.span(),
            Self::AmbientDeclaration(inner) => inner.span(),
            Self::Arguments(inner) => inner.span(),
            Self::Array(inner) => inner.span(),
            Self::ArrayPattern(inner) => inner.span(),
            Self::ArrayType(inner) => inner.span(),
            Self::ArrowFunction(inner) => inner.span(),
            Self::AsExpression(inner) => inner.span(),
            Self::Asserts(inner) => inner.span(),
            Self::AssertsAnnotation(inner) => inner.span(),
            Self::AssignmentExpression(inner) => inner.span(),
            Self::AssignmentPattern(inner) => inner.span(),
            Self::AugmentedAssignmentExpression(inner) => inner.span(),
            Self::AwaitExpression(inner) => inner.span(),
            Self::BinaryExpression(inner) => inner.span(),
            Self::BreakStatement(inner) => inner.span(),
            Self::CallExpression(inner) => inner.span(),
            Self::CallSignature(inner) => inner.span(),
            Self::CatchClause(inner) => inner.span(),
            Self::Class(inner) => inner.span(),
            Self::ClassBody(inner) => inner.span(),
            Self::ClassDeclaration(inner) => inner.span(),
            Self::ClassHeritage(inner) => inner.span(),
            Self::ClassStaticBlock(inner) => inner.span(),
            Self::ComputedPropertyName(inner) => inner.span(),
            Self::ConditionalType(inner) => inner.span(),
            Self::Constraint(inner) => inner.span(),
            Self::ConstructSignature(inner) => inner.span(),
            Self::ConstructorType(inner) => inner.span(),
            Self::ContinueStatement(inner) => inner.span(),
            Self::DebuggerStatement(inner) => inner.span(),
            Self::Decorator(inner) => inner.span(),
            Self::DefaultType(inner) => inner.span(),
            Self::DoStatement(inner) => inner.span(),
            Self::ElseClause(inner) => inner.span(),
            Self::EmptyStatement(inner) => inner.span(),
            Self::EnumAssignment(inner) => inner.span(),
            Self::EnumBody(inner) => inner.span(),
            Self::EnumDeclaration(inner) => inner.span(),
            Self::ExistentialType(inner) => inner.span(),
            Self::ExportClause(inner) => inner.span(),
            Self::ExportSpecifier(inner) => inner.span(),
            Self::ExportStatement(inner) => inner.span(),
            Self::ExpressionStatement(inner) => inner.span(),
            Self::ExtendsClause(inner) => inner.span(),
            Self::ExtendsTypeClause(inner) => inner.span(),
            Self::FinallyClause(inner) => inner.span(),
            Self::FlowMaybeType(inner) => inner.span(),
            Self::ForInStatement(inner) => inner.span(),
            Self::ForStatement(inner) => inner.span(),
            Self::FormalParameters(inner) => inner.span(),
            Self::FunctionDeclaration(inner) => inner.span(),
            Self::FunctionExpression(inner) => inner.span(),
            Self::FunctionSignature(inner) => inner.span(),
            Self::FunctionType(inner) => inner.span(),
            Self::GeneratorFunction(inner) => inner.span(),
            Self::GeneratorFunctionDeclaration(inner) => inner.span(),
            Self::GenericType(inner) => inner.span(),
            Self::Identifier(inner) => inner.span(),
            Self::IfStatement(inner) => inner.span(),
            Self::ImplementsClause(inner) => inner.span(),
            Self::Import(inner) => inner.span(),
            Self::ImportAlias(inner) => inner.span(),
            Self::ImportAttribute(inner) => inner.span(),
            Self::ImportClause(inner) => inner.span(),
            Self::ImportRequireClause(inner) => inner.span(),
            Self::ImportSpecifier(inner) => inner.span(),
            Self::ImportStatement(inner) => inner.span(),
            Self::IndexSignature(inner) => inner.span(),
            Self::IndexTypeQuery(inner) => inner.span(),
            Self::InferType(inner) => inner.span(),
            Self::InstantiationExpression(inner) => inner.span(),
            Self::InterfaceBody(inner) => inner.span(),
            Self::InterfaceDeclaration(inner) => inner.span(),
            Self::InternalModule(inner) => inner.span(),
            Self::IntersectionType(inner) => inner.span(),
            Self::LabeledStatement(inner) => inner.span(),
            Self::LexicalDeclaration(inner) => inner.span(),
            Self::LiteralType(inner) => inner.span(),
            Self::LookupType(inner) => inner.span(),
            Self::MappedTypeClause(inner) => inner.span(),
            Self::MemberExpression(inner) => inner.span(),
            Self::MetaProperty(inner) => inner.span(),
            Self::MethodDefinition(inner) => inner.span(),
            Self::MethodSignature(inner) => inner.span(),
            Self::Module(inner) => inner.span(),
            Self::NamedImports(inner) => inner.span(),
            Self::NamespaceExport(inner) => inner.span(),
            Self::NamespaceImport(inner) => inner.span(),
            Self::NestedIdentifier(inner) => inner.span(),
            Self::NestedTypeIdentifier(inner) => inner.span(),
            Self::NewExpression(inner) => inner.span(),
            Self::NonNullExpression(inner) => inner.span(),
            Self::Object(inner) => inner.span(),
            Self::ObjectAssignmentPattern(inner) => inner.span(),
            Self::ObjectPattern(inner) => inner.span(),
            Self::ObjectType(inner) => inner.span(),
            Self::OmittingTypeAnnotation(inner) => inner.span(),
            Self::OptingTypeAnnotation(inner) => inner.span(),
            Self::OptionalChain(inner) => inner.span(),
            Self::OptionalParameter(inner) => inner.span(),
            Self::OptionalType(inner) => inner.span(),
            Self::OverrideModifier(inner) => inner.span(),
            Self::Pair(inner) => inner.span(),
            Self::PairPattern(inner) => inner.span(),
            Self::ParenthesizedExpression(inner) => inner.span(),
            Self::ParenthesizedType(inner) => inner.span(),
            Self::PredefinedType(inner) => inner.span(),
            Self::Program(inner) => inner.span(),
            Self::PropertySignature(inner) => inner.span(),
            Self::PublicFieldDefinition(inner) => inner.span(),
            Self::ReadonlyType(inner) => inner.span(),
            Self::Regex(inner) => inner.span(),
            Self::RequiredParameter(inner) => inner.span(),
            Self::RestPattern(inner) => inner.span(),
            Self::RestType(inner) => inner.span(),
            Self::ReturnStatement(inner) => inner.span(),
            Self::SatisfiesExpression(inner) => inner.span(),
            Self::SequenceExpression(inner) => inner.span(),
            Self::SpreadElement(inner) => inner.span(),
            Self::StatementBlock(inner) => inner.span(),
            Self::String(inner) => inner.span(),
            Self::SubscriptExpression(inner) => inner.span(),
            Self::SwitchBody(inner) => inner.span(),
            Self::SwitchCase(inner) => inner.span(),
            Self::SwitchDefault(inner) => inner.span(),
            Self::SwitchStatement(inner) => inner.span(),
            Self::TemplateLiteralType(inner) => inner.span(),
            Self::TemplateString(inner) => inner.span(),
            Self::TemplateSubstitution(inner) => inner.span(),
            Self::TemplateType(inner) => inner.span(),
            Self::TernaryExpression(inner) => inner.span(),
            Self::ThrowStatement(inner) => inner.span(),
            Self::TryStatement(inner) => inner.span(),
            Self::TupleType(inner) => inner.span(),
            Self::TypeAliasDeclaration(inner) => inner.span(),
            Self::TypeAnnotation(inner) => inner.span(),
            Self::TypeArguments(inner) => inner.span(),
            Self::TypeAssertion(inner) => inner.span(),
            Self::TypeParameter(inner) => inner.span(),
            Self::TypeParameters(inner) => inner.span(),
            Self::TypePredicate(inner) => inner.span(),
            Self::TypePredicateAnnotation(inner) => inner.span(),
            Self::TypeQuery(inner) => inner.span(),
            Self::UnaryExpression(inner) => inner.span(),
            Self::UnionType(inner) => inner.span(),
            Self::UpdateExpression(inner) => inner.span(),
            Self::VariableDeclaration(inner) => inner.span(),
            Self::VariableDeclarator(inner) => inner.span(),
            Self::WhileStatement(inner) => inner.span(),
            Self::WithStatement(inner) => inner.span(),
            Self::YieldExpression(inner) => inner.span(),
            Self::Comment(inner) => inner.span(),
            Self::EscapeSequence(inner) => inner.span(),
            Self::False(inner) => inner.span(),
            Self::HashBangLine(inner) => inner.span(),
            Self::HtmlComment(inner) => inner.span(),
            Self::Null(inner) => inner.span(),
            Self::Number(inner) => inner.span(),
            Self::PrivatePropertyIdentifier(inner) => inner.span(),
            Self::PropertyIdentifier(inner) => inner.span(),
            Self::RegexFlags(inner) => inner.span(),
            Self::RegexPattern(inner) => inner.span(),
            Self::ShorthandPropertyIdentifier(inner) => inner.span(),
            Self::ShorthandPropertyIdentifierPattern(inner) => inner.span(),
            Self::StatementIdentifier(inner) => inner.span(),
            Self::StringFragment(inner) => inner.span(),
            Self::Super(inner) => inner.span(),
            Self::This(inner) => inner.span(),
            Self::ThisType(inner) => inner.span(),
            Self::True(inner) => inner.span(),
            Self::TypeIdentifier(inner) => inner.span(),
            Self::Undefined(inner) => inner.span(),
            Self::Unknown(node) => ::treesitter_types::Span::from(*node),
        }
    }
}