cyrs-ast 0.1.0

// @generated by `cargo xtask codegen`. DO NOT EDIT.
// Source: crates/cyrs-ast/cypher.ungrammar (spec 0001 §5.2).
//
// Typed AST wrappers are zero-cost views over `cyrs_syntax::SyntaxNode`
// (spec §5.1). Each struct wrapper has a `cast` that succeeds iff the
// underlying node's `SyntaxKind` matches, plus `Option`-returning
// accessors per child (spec §5.3). Sum-type enum wrappers cover
// alternation-only productions (spec §5.4) and cast by cascading into
// their variants — first successful arm cast wins.
//
// SKIPPED (no wrapper emitted — productions listed below):
//   - SingleQuery: no `SyntaxKind::SINGLE_QUERY` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - Union: no `SyntaxKind::UNION` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - ReturnItems: alternation contains a sequence arm (not a single-node shape)
//   - Skip: no `SyntaxKind::SKIP` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - Limit: no `SyntaxKind::LIMIT` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - NameDef: alternation contains a token arm (sum-type-over-tokens emitter not in cy-pbx scope)
//   - QualifiedName: no `SyntaxKind::QUALIFIED_NAME` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - YieldClause: no `SyntaxKind::YIELD_CLAUSE` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - SortItem: no `SyntaxKind::SORT_ITEM` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - NameRef: alternation contains a token arm (sum-type-over-tokens emitter not in cy-pbx scope)
//   - PropertyAssign: no `SyntaxKind::PROPERTY_ASSIGN` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - LabelAdd: no `SyntaxKind::LABEL_ADD` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - NodeReplace: no `SyntaxKind::NODE_REPLACE` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - NodeMerge: no `SyntaxKind::NODE_MERGE` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - PropertyAccess: no `SyntaxKind::PROPERTY_ACCESS` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - PropertyRemove: no `SyntaxKind::PROPERTY_REMOVE` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - LabelRemove: no `SyntaxKind::LABEL_REMOVE` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - PathPattern: alternation contains a sequence arm (not a single-node shape)
//   - PathElement: no `SyntaxKind::PATH_ELEMENT` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - RelPattern: alternation contains a sequence arm (not a single-node shape)
//   - TypeExpr: no `SyntaxKind::TYPE_EXPR` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - RangeHops: alternation contains a sequence arm (not a single-node shape)
//   - IntLiteral: no `SyntaxKind::INT_LITERAL` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - Label: no `SyntaxKind::LABEL` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - RelType: no `SyntaxKind::REL_TYPE` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - PropertyKV: no `SyntaxKind::PROPERTY_K_V` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - PropertyKey: alternation contains a token arm (sum-type-over-tokens emitter not in cy-pbx scope)
//   - ParameterExpr: no `SyntaxKind::PARAMETER_EXPR` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - VariableRef: no `SyntaxKind::VARIABLE_REF` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - IndexAccess: no `SyntaxKind::INDEX_ACCESS` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - CountStar: no `SyntaxKind::COUNT_STAR` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - NullCheck: no `SyntaxKind::NULL_CHECK` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - ExistsPredicate: no `SyntaxKind::EXISTS_PREDICATE` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - StringPatternExpr: no `SyntaxKind::STRING_PATTERN_EXPR` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - MembershipExpr: no `SyntaxKind::MEMBERSHIP_EXPR` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - FloatLiteral: no `SyntaxKind::FLOAT_LITERAL` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - StringLiteral: no `SyntaxKind::STRING_LITERAL` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - BoolLiteral: alternation contains a token arm (sum-type-over-tokens emitter not in cy-pbx scope)
//   - NullLiteral: no `SyntaxKind::NULL_LITERAL` variant in cyrs-syntax::kind (see cy-nom follow-ups)
//   - MapProjectionItem: alternation contains a sequence arm (not a single-node shape)
//   - BinaryOp: alternation contains a token arm (sum-type-over-tokens emitter not in cy-pbx scope)
//   - UnaryOp: alternation contains a token arm (sum-type-over-tokens emitter not in cy-pbx scope)
//   - StringPatternOp: alternation contains a token arm (sum-type-over-tokens emitter not in cy-pbx scope)
//   - Statement: alternation arms all reference types that aren't emitted yet (will light up as `SyntaxKind` variants land)
//   - SetItem: alternation arms all reference types that aren't emitted yet (will light up as `SyntaxKind` variants land)
//   - RemoveItem: alternation arms all reference types that aren't emitted yet (will light up as `SyntaxKind` variants land)
//   - Literal: alternation arms all reference types that aren't emitted yet (will light up as `SyntaxKind` variants land)

#![forbid(unsafe_code)]
#![allow(clippy::wildcard_imports)]
#![allow(clippy::return_self_not_must_use)]
#![allow(dead_code)]
#![allow(missing_docs)]

use cyrs_syntax::{SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken};

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SourceFile {
    syntax: SyntaxNode,
}

impl SourceFile {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::SOURCE_FILE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UnionTail {
    syntax: SyntaxNode,
}

impl UnionTail {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::UNION_TAIL).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn union_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::UNION_KW)
    }

    pub fn all_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::ALL_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MatchClause {
    syntax: SyntaxNode,
}

impl MatchClause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::MATCH_CLAUSE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn pattern(&self) -> impl Iterator<Item = Pattern> + '_ {
        self.syntax.children().filter_map(Pattern::cast)
    }

    pub fn where_clause(&self) -> Option<WhereClause> {
        self.syntax.children().find_map(WhereClause::cast)
    }

    pub fn optional_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::OPTIONAL_KW)
    }

    pub fn match_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::MATCH_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct WithClause {
    syntax: SyntaxNode,
}

impl WithClause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::WITH_CLAUSE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn where_clause(&self) -> Option<WhereClause> {
        self.syntax.children().find_map(WhereClause::cast)
    }

    pub fn order_by(&self) -> Option<OrderBy> {
        self.syntax.children().find_map(OrderBy::cast)
    }

    pub fn with_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::WITH_KW)
    }

    pub fn distinct_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::DISTINCT_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ReturnClause {
    syntax: SyntaxNode,
}

impl ReturnClause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::RETURN_CLAUSE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn order_by(&self) -> Option<OrderBy> {
        self.syntax.children().find_map(OrderBy::cast)
    }

    pub fn return_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::RETURN_KW)
    }

    pub fn distinct_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::DISTINCT_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UnwindClause {
    syntax: SyntaxNode,
}

impl UnwindClause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::UNWIND_CLAUSE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn expr(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn unwind_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::UNWIND_KW)
    }

    pub fn as_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::AS_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CallClause {
    syntax: SyntaxNode,
}

impl CallClause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::CALL_CLAUSE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn arg_list(&self) -> Option<ArgList> {
        self.syntax.children().find_map(ArgList::cast)
    }

    pub fn call_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::CALL_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CreateClause {
    syntax: SyntaxNode,
}

impl CreateClause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::CREATE_CLAUSE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn pattern(&self) -> impl Iterator<Item = Pattern> + '_ {
        self.syntax.children().filter_map(Pattern::cast)
    }

    pub fn create_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::CREATE_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MergeClause {
    syntax: SyntaxNode,
}

impl MergeClause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::MERGE_CLAUSE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn pattern(&self) -> Option<Pattern> {
        self.syntax.children().find_map(Pattern::cast)
    }

    pub fn merge_action(&self) -> impl Iterator<Item = MergeAction> + '_ {
        self.syntax.children().filter_map(MergeAction::cast)
    }

    pub fn merge_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::MERGE_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SetClause {
    syntax: SyntaxNode,
}

impl SetClause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::SET_CLAUSE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn set_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::SET_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct RemoveClause {
    syntax: SyntaxNode,
}

impl RemoveClause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::REMOVE_CLAUSE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn remove_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::REMOVE_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct DeleteClause {
    syntax: SyntaxNode,
}

impl DeleteClause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::DELETE_CLAUSE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn expr(&self) -> impl Iterator<Item = Expr> + '_ {
        self.syntax.children().filter_map(Expr::cast)
    }

    pub fn detach_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::DETACH_KW)
    }

    pub fn delete_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::DELETE_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Pattern {
    syntax: SyntaxNode,
}

impl Pattern {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::PATTERN).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct WhereClause {
    syntax: SyntaxNode,
}

impl WhereClause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::WHERE_CLAUSE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn expr(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn where_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::WHERE_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct OrderBy {
    syntax: SyntaxNode,
}

impl OrderBy {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ORDER_BY).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn order_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::ORDER_KW)
    }

    pub fn by_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::BY_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ArgList {
    syntax: SyntaxNode,
}

impl ArgList {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::ARG_LIST).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn expr(&self) -> impl Iterator<Item = Expr> + '_ {
        self.syntax.children().filter_map(Expr::cast)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct YieldItem {
    syntax: SyntaxNode,
}

impl YieldItem {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::YIELD_ITEM).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn as_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::AS_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MergeAction {
    syntax: SyntaxNode,
}

impl MergeAction {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::MERGE_ACTION).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn set_clause(&self) -> Option<SetClause> {
        self.syntax.children().find_map(SetClause::cast)
    }

    pub fn on_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::ON_KW)
    }

    pub fn create_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::CREATE_KW)
    }

    pub fn match_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::MATCH_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ReturnItem {
    syntax: SyntaxNode,
}

impl ReturnItem {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::RETURN_ITEM).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn expr(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn as_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::AS_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct LabelExpr {
    syntax: SyntaxNode,
}

impl LabelExpr {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::LABEL_EXPR).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ShortestPathPattern {
    syntax: SyntaxNode,
}

impl ShortestPathPattern {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::SHORTEST_PATH_PATTERN).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn shortestpath_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::SHORTESTPATH_KW)
    }

    pub fn allshortestpaths_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::ALLSHORTESTPATHS_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct NodePattern {
    syntax: SyntaxNode,
}

impl NodePattern {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::NODE_PATTERN).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn label_expr(&self) -> Option<LabelExpr> {
        self.syntax.children().find_map(LabelExpr::cast)
    }

    pub fn property_map(&self) -> Option<PropertyMap> {
        self.syntax.children().find_map(PropertyMap::cast)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PropertyMap {
    syntax: SyntaxNode,
}

impl PropertyMap {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::PROPERTY_MAP).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct RelDetail {
    syntax: SyntaxNode,
}

impl RelDetail {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::REL_DETAIL).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn property_map(&self) -> Option<PropertyMap> {
        self.syntax.children().find_map(PropertyMap::cast)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct IndexExpr {
    syntax: SyntaxNode,
}

impl IndexExpr {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::INDEX_EXPR).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn receiver(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn index(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct SliceExpr {
    syntax: SyntaxNode,
}

impl SliceExpr {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::SLICE_EXPR).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn receiver(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn start(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn end(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct FunctionCall {
    syntax: SyntaxNode,
}

impl FunctionCall {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::FUNCTION_CALL).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn arg_list(&self) -> Option<ArgList> {
        self.syntax.children().find_map(ArgList::cast)
    }

    pub fn distinct_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::DISTINCT_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ParenExpr {
    syntax: SyntaxNode,
}

impl ParenExpr {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::PAREN_EXPR).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn expr(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ListLiteral {
    syntax: SyntaxNode,
}

impl ListLiteral {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::LIST_LITERAL).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn expr(&self) -> impl Iterator<Item = Expr> + '_ {
        self.syntax.children().filter_map(Expr::cast)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MapLiteral {
    syntax: SyntaxNode,
}

impl MapLiteral {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::MAP_LITERAL).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MapProjection {
    syntax: SyntaxNode,
}

impl MapProjection {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::MAP_PROJECTION).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn subject(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ListComprehension {
    syntax: SyntaxNode,
}

impl ListComprehension {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::LIST_COMPREHENSION).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn source(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn where_clause(&self) -> Option<WhereClause> {
        self.syntax.children().find_map(WhereClause::cast)
    }

    pub fn projection(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn in_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::IN_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ListPredicateExpr {
    syntax: SyntaxNode,
}

impl ListPredicateExpr {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::LIST_PREDICATE_EXPR).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn source(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn where_clause(&self) -> Option<WhereClause> {
        self.syntax.children().find_map(WhereClause::cast)
    }

    pub fn any_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::ANY_KW)
    }

    pub fn all_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::ALL_KW)
    }

    pub fn none_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::NONE_KW)
    }

    pub fn single_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::SINGLE_KW)
    }

    pub fn in_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::IN_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PatternComprehension {
    syntax: SyntaxNode,
}

impl PatternComprehension {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::PATTERN_COMPREHENSION).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn where_clause(&self) -> Option<WhereClause> {
        self.syntax.children().find_map(WhereClause::cast)
    }

    pub fn projection(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CaseExpr {
    syntax: SyntaxNode,
}

impl CaseExpr {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::CASE_EXPR).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn scrutinee(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn arms(&self) -> Option<CaseWhenArm> {
        self.syntax.children().find_map(CaseWhenArm::cast)
    }

    pub fn case_when_arm(&self) -> impl Iterator<Item = CaseWhenArm> + '_ {
        self.syntax.children().filter_map(CaseWhenArm::cast)
    }

    pub fn else_arm(&self) -> Option<CaseElseArm> {
        self.syntax.children().find_map(CaseElseArm::cast)
    }

    pub fn case_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::CASE_KW)
    }

    pub fn end_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::END_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct BinaryExpr {
    syntax: SyntaxNode,
}

impl BinaryExpr {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::BINARY_EXPR).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn lhs(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn rhs(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct UnaryExpr {
    syntax: SyntaxNode,
}

impl UnaryExpr {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::UNARY_EXPR).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn operand(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PatternPredicate {
    syntax: SyntaxNode,
}

impl PatternPredicate {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::PATTERN_PREDICATE).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CaseWhenArm {
    syntax: SyntaxNode,
}

impl CaseWhenArm {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::CASE_WHEN_ARM).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn when_value(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn then_value(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn when_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::WHEN_KW)
    }

    pub fn then_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::THEN_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CaseElseArm {
    syntax: SyntaxNode,
}

impl CaseElseArm {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        (syntax.kind() == SyntaxKind::CASE_ELSE_ARM).then_some(Self { syntax })
    }

    pub fn syntax(&self) -> &SyntaxNode {
        &self.syntax
    }

    pub fn value(&self) -> Option<Expr> {
        self.syntax.children().find_map(Expr::cast)
    }

    pub fn else_token(&self) -> Option<SyntaxToken> {
        self.syntax
            .children_with_tokens()
            .filter_map(SyntaxElement::into_token)
            .find(|t| t.kind() == SyntaxKind::ELSE_KW)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Clause {
    MatchClause(MatchClause),
    WithClause(WithClause),
    ReturnClause(ReturnClause),
    UnwindClause(UnwindClause),
    CallClause(CallClause),
    CreateClause(CreateClause),
    MergeClause(MergeClause),
    SetClause(SetClause),
    RemoveClause(RemoveClause),
    DeleteClause(DeleteClause),
}

impl Clause {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        if let Some(inner) = MatchClause::cast(syntax.clone()) {
            return Some(Self::MatchClause(inner));
        }
        if let Some(inner) = WithClause::cast(syntax.clone()) {
            return Some(Self::WithClause(inner));
        }
        if let Some(inner) = ReturnClause::cast(syntax.clone()) {
            return Some(Self::ReturnClause(inner));
        }
        if let Some(inner) = UnwindClause::cast(syntax.clone()) {
            return Some(Self::UnwindClause(inner));
        }
        if let Some(inner) = CallClause::cast(syntax.clone()) {
            return Some(Self::CallClause(inner));
        }
        if let Some(inner) = CreateClause::cast(syntax.clone()) {
            return Some(Self::CreateClause(inner));
        }
        if let Some(inner) = MergeClause::cast(syntax.clone()) {
            return Some(Self::MergeClause(inner));
        }
        if let Some(inner) = SetClause::cast(syntax.clone()) {
            return Some(Self::SetClause(inner));
        }
        if let Some(inner) = RemoveClause::cast(syntax.clone()) {
            return Some(Self::RemoveClause(inner));
        }
        if let Some(inner) = DeleteClause::cast(syntax) {
            return Some(Self::DeleteClause(inner));
        }
        None
    }

    pub fn syntax(&self) -> &SyntaxNode {
        match self {
            Self::MatchClause(inner) => inner.syntax(),
            Self::WithClause(inner) => inner.syntax(),
            Self::ReturnClause(inner) => inner.syntax(),
            Self::UnwindClause(inner) => inner.syntax(),
            Self::CallClause(inner) => inner.syntax(),
            Self::CreateClause(inner) => inner.syntax(),
            Self::MergeClause(inner) => inner.syntax(),
            Self::SetClause(inner) => inner.syntax(),
            Self::RemoveClause(inner) => inner.syntax(),
            Self::DeleteClause(inner) => inner.syntax(),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Expr {
    IndexExpr(IndexExpr),
    SliceExpr(SliceExpr),
    FunctionCall(FunctionCall),
    ParenExpr(ParenExpr),
    ListLiteral(ListLiteral),
    MapLiteral(MapLiteral),
    MapProjection(MapProjection),
    ListComprehension(ListComprehension),
    ListPredicateExpr(ListPredicateExpr),
    PatternComprehension(PatternComprehension),
    CaseExpr(CaseExpr),
    BinaryExpr(BinaryExpr),
    UnaryExpr(UnaryExpr),
    PatternPredicate(PatternPredicate),
}

impl Expr {
    pub fn cast(syntax: SyntaxNode) -> Option<Self> {
        if let Some(inner) = IndexExpr::cast(syntax.clone()) {
            return Some(Self::IndexExpr(inner));
        }
        if let Some(inner) = SliceExpr::cast(syntax.clone()) {
            return Some(Self::SliceExpr(inner));
        }
        if let Some(inner) = FunctionCall::cast(syntax.clone()) {
            return Some(Self::FunctionCall(inner));
        }
        if let Some(inner) = ParenExpr::cast(syntax.clone()) {
            return Some(Self::ParenExpr(inner));
        }
        if let Some(inner) = ListLiteral::cast(syntax.clone()) {
            return Some(Self::ListLiteral(inner));
        }
        if let Some(inner) = MapLiteral::cast(syntax.clone()) {
            return Some(Self::MapLiteral(inner));
        }
        if let Some(inner) = MapProjection::cast(syntax.clone()) {
            return Some(Self::MapProjection(inner));
        }
        if let Some(inner) = ListComprehension::cast(syntax.clone()) {
            return Some(Self::ListComprehension(inner));
        }
        if let Some(inner) = ListPredicateExpr::cast(syntax.clone()) {
            return Some(Self::ListPredicateExpr(inner));
        }
        if let Some(inner) = PatternComprehension::cast(syntax.clone()) {
            return Some(Self::PatternComprehension(inner));
        }
        if let Some(inner) = CaseExpr::cast(syntax.clone()) {
            return Some(Self::CaseExpr(inner));
        }
        if let Some(inner) = BinaryExpr::cast(syntax.clone()) {
            return Some(Self::BinaryExpr(inner));
        }
        if let Some(inner) = UnaryExpr::cast(syntax.clone()) {
            return Some(Self::UnaryExpr(inner));
        }
        if let Some(inner) = PatternPredicate::cast(syntax) {
            return Some(Self::PatternPredicate(inner));
        }
        None
    }

    pub fn syntax(&self) -> &SyntaxNode {
        match self {
            Self::IndexExpr(inner) => inner.syntax(),
            Self::SliceExpr(inner) => inner.syntax(),
            Self::FunctionCall(inner) => inner.syntax(),
            Self::ParenExpr(inner) => inner.syntax(),
            Self::ListLiteral(inner) => inner.syntax(),
            Self::MapLiteral(inner) => inner.syntax(),
            Self::MapProjection(inner) => inner.syntax(),
            Self::ListComprehension(inner) => inner.syntax(),
            Self::ListPredicateExpr(inner) => inner.syntax(),
            Self::PatternComprehension(inner) => inner.syntax(),
            Self::CaseExpr(inner) => inner.syntax(),
            Self::BinaryExpr(inner) => inner.syntax(),
            Self::UnaryExpr(inner) => inner.syntax(),
            Self::PatternPredicate(inner) => inner.syntax(),
        }
    }
}