translate

type BindingResult struct {
	// Binding supplies the binding input to the BindingResult contract.
	Binding *BoundIdentifier
	// AlreadyBound indicates whether already bound applies.
	AlreadyBound bool
}

type BoundIdentifier struct {
	// Identifier is the canonical PostgreSQL name allocated for the binding.
	Identifier pgsql.Identifier
	// Alias is the optional source-visible name projected for the binding.
	Alias models.Optional[pgsql.Identifier]
	// Parameter is the translated SQL parameter represented by this binding, when applicable.
	Parameter *pgsql.Parameter
	// LastProjection is the most recent frame that materialized the binding.
	LastProjection *Frame
	// Dependencies are the bindings required to reconstruct this value.
	Dependencies []*BoundIdentifier
	// DataType is the PostgreSQL representation carried by the binding.
	DataType pgsql.DataType
	// IDOnly reports that the binding is represented by a scalar entity ID instead of a composite.
	IDOnly bool

	// PathDirectionReversed marks a path composite binding whose dependency order was produced
	// from an optimizer-reversed pattern. Path materialization reverses the assembled node and
	// edge references so the path renders in its original left-to-right logical order.
	PathDirectionReversed bool
	// DistanceOnly reports that the binding carries only shortest-path distance state.
	DistanceOnly bool
	// contains filtered or unexported fields
}

type BoundProjections struct {
	// Items contains the SQL expressions emitted by the projection.
	Items pgsql.Projection

	// Bindings contains the scope bindings represented by Items.
	Bindings []*BoundIdentifier
}

type Builder struct {
	// contains filtered or unexported fields
}

type Constraint struct {
	Dependencies *pgsql.IdentifierSet
	Expression   pgsql.Expression
}

type ConstraintTracker struct {
	Constraints []*Constraint
}

type Delete struct {
	// Detach permits removal of incident relationships when deleting a node.
	Detach bool
	// Frame supplies the frame input to the Delete contract.
	Frame *Frame
	// TargetBinding supplies the target binding input to the Delete contract.
	TargetBinding *BoundIdentifier
	// UpdateBinding supplies the update binding input to the Delete contract.
	UpdateBinding *BoundIdentifier
}

type EdgeCreate struct {
	// Binding supplies the binding input to the EdgeCreate contract.
	Binding *BoundIdentifier
	// Properties supplies the properties input to the EdgeCreate contract.
	Properties TranslatedProperties
	// Kinds supplies the kinds input to the EdgeCreate contract.
	Kinds graph.Kinds
	// LeftNode supplies the left node input to the EdgeCreate contract.
	LeftNode *BoundIdentifier
	// RightNode supplies the right node input to the EdgeCreate contract.
	RightNode *BoundIdentifier
	// Direction selects the traversal orientation covered by the contract.
	Direction graph.Direction
}

type Expansion struct {
	// Frame is the scope frame that materializes the expansion result.
	Frame *Frame
	// PathBinding is the optional Cypher path variable backed by recursive path state.
	PathBinding *BoundIdentifier
	// Options records shortest-path mode and traversal depth bounds.
	Options ExpansionOptions

	// PrimerNodeConstraints restricts root nodes used to seed recursive traversal.
	PrimerNodeConstraints pgsql.Expression
	// PrimerNodeSatisfactionProjection evaluates terminal satisfaction at the seed node.
	PrimerNodeSatisfactionProjection pgsql.SelectItem
	// PrimerNodeJoinCondition joins the expansion seed to its root node.
	PrimerNodeJoinCondition pgsql.Expression
	// EdgeConstraints restricts relationships admitted into the expansion.
	EdgeConstraints pgsql.Expression
	// PreviousRelationshipUniqueness rejects relationships already traversed in this MATCH.
	PreviousRelationshipUniqueness pgsql.Expression
	// EdgeJoinCondition joins a relationship to the current traversal frontier.
	EdgeJoinCondition pgsql.Expression
	// RecursiveConstraints restricts recursive states independently of edge and node predicates.
	RecursiveConstraints pgsql.Expression
	// ExpansionNodeJoinCondition joins the traversed relationship to its next node.
	ExpansionNodeJoinCondition pgsql.Expression
	// TerminalNodeConstraints restricts nodes considered valid expansion terminals.
	TerminalNodeConstraints pgsql.Expression
	// TerminalNodeSatisfactionProjection computes whether a recursive state satisfies terminal predicates.
	TerminalNodeSatisfactionProjection pgsql.SelectItem
	// DeferredNodeSatisfactionConstraint retains terminal predicates that require outer bindings.
	DeferredNodeSatisfactionConstraint pgsql.Expression
	// UseMaterializedTerminalFilter enables lookup against precomputed terminal node IDs.
	UseMaterializedTerminalFilter bool
	// UseMaterializedEndpointPairFilter enables lookup against precomputed root-terminal ID pairs.
	UseMaterializedEndpointPairFilter bool
	// HasExplicitEndpointInequality reports whether the source query already excludes identical endpoints.
	HasExplicitEndpointInequality bool

	// PrimerQueryParameter identifies the harness parameter containing the forward primer query.
	PrimerQueryParameter *BoundIdentifier
	// BackwardPrimerQueryParameter identifies the harness parameter containing the backward primer query.
	BackwardPrimerQueryParameter *BoundIdentifier
	// RecursiveQueryParameter identifies the harness parameter containing the forward recursive query.
	RecursiveQueryParameter *BoundIdentifier
	// BackwardRecursiveQueryParameter identifies the harness parameter containing the backward recursive query.
	BackwardRecursiveQueryParameter *BoundIdentifier

	// UseBidirectionalSearch reports whether shortest-path traversal expands from both endpoints.
	UseBidirectionalSearch bool
	// ShortestPathExecutor selects the physical implementation for this shortest-path expansion.
	ShortestPathExecutor optimize.ShortestPathExecutor
	// ShortestPathTarget locates this expansion in the optimizer's lowering plan.
	ShortestPathTarget optimize.TraversalStepTarget
	// ShortestPathStateLimit caps distinct seen state for compact executors.
	ShortestPathStateLimit int64
	// ShortestPathFrontierLimit caps current and queued frontier state.
	ShortestPathFrontierLimit int64
	// ShortestPathPredecessorLimit caps retained witness predecessors.
	ShortestPathPredecessorLimit int64
	// ShortestPathEnumerationLimit caps staged all-shortest-path arrays.
	ShortestPathEnumerationLimit int64
	// ShortestPathOutputBytesLimit caps staged all-shortest-path array bytes.
	ShortestPathOutputBytesLimit int64
	// SingletonRootID holds the statically resolved root ID when exactly one root is known.
	SingletonRootID pgsql.Expression
	// SingletonTerminalID holds the statically resolved terminal ID when exactly one terminal is known.
	SingletonTerminalID pgsql.Expression
	// RelationshipKindIDs contains the statically resolved relationship kinds admitted by the expansion.
	RelationshipKindIDs []int16

	// EdgeStartIdentifier is the unqualified edge endpoint column from which the chosen direction advances.
	EdgeStartIdentifier pgsql.Identifier
	// EdgeStartColumn is the qualified edge endpoint expression from which the chosen direction advances.
	EdgeStartColumn pgsql.CompoundIdentifier
	// EdgeEndIdentifier is the unqualified edge endpoint column reached by the chosen direction.
	EdgeEndIdentifier pgsql.Identifier
	// EdgeEndColumn is the qualified edge endpoint expression reached by the chosen direction.
	EdgeEndColumn pgsql.CompoundIdentifier

	// Projection contains the select items exposed by the completed expansion frame.
	Projection []pgsql.SelectItem
}

type ExpansionBuilder struct {
	// PrimerStatement produces the first traversal edge for each root.
	PrimerStatement pgsql.Select

	// RecursiveStatement advances each eligible expansion state by one edge.
	RecursiveStatement pgsql.Select

	// ProjectionStatement converts internal expansion state into the requested result shape.
	ProjectionStatement pgsql.Select

	// ZeroDepthStatement produces empty-path rows when the traversal admits depth zero.
	ZeroDepthStatement *pgsql.Select

	// UseUnionAll controls whether recursive branches retain duplicate states.
	UseUnionAll bool
	// contains filtered or unexported fields
}

type ExpansionOptions struct {
	// FindShortestPath identifies the filesystem find shortest path.
	FindShortestPath bool
	// FindAllShortestPaths identifies the filesystem find all shortest paths.
	FindAllShortestPaths bool
	// MinDepth supplies the min depth input to the ExpansionOptions contract.
	MinDepth models.Optional[int64]
	// MaxDepth supplies the max depth input to the ExpansionOptions contract.
	MaxDepth models.Optional[int64]
}

type ExpressionTreeTranslator struct {
	UserConstraints        *ConstraintTracker
	TranslationConstraints *ConstraintTracker
	// contains filtered or unexported fields
}

type Frame struct {
	Previous *Frame
	Binding  *BoundIdentifier
	Visible  *pgsql.IdentifierSet

	Exported *pgsql.IdentifierSet

	Synthetic bool
	// contains filtered or unexported fields
}

type FrameBindingRewriter struct {
	walk.Visitor[pgsql.SyntaxNode]
	// contains filtered or unexported fields
}

type FromClauseBuilder struct {
	// contains filtered or unexported fields
}

type IdentifierGenerator map[pgsql.DataType]int

type LabelAssignment struct {
	// Kinds supplies the kinds input to the LabelAssignment contract.
	Kinds pgsql.Expression
}

type Mutations struct {
	// Deletions supplies the deletions input to the Mutations contract.
	Deletions *graph.IndexedSlice[pgsql.Identifier, *Delete]
	// Updates supplies the updates input to the Mutations contract.
	Updates *graph.IndexedSlice[pgsql.Identifier, *Update]
	// Creations supplies the creations input to the Mutations contract.
	Creations *graph.IndexedSlice[pgsql.Identifier, *NodeCreate]
	// EdgeCreations supplies the edge creations input to the Mutations contract.
	EdgeCreations *graph.IndexedSlice[pgsql.Identifier, *EdgeCreate]
}

type NodeCreate struct {
	// Binding supplies the binding input to the NodeCreate contract.
	Binding *BoundIdentifier
	// Properties supplies the properties input to the NodeCreate contract.
	Properties TranslatedProperties
	// Kinds supplies the kinds input to the NodeCreate contract.
	Kinds graph.Kinds
}

type NodeSelect struct {
	// Frame supplies the frame input to the NodeSelect contract.
	Frame *Frame
	// Binding supplies the binding input to the NodeSelect contract.
	Binding *BoundIdentifier
	// Select supplies the select input to the NodeSelect contract.
	Select pgsql.Select
	// Constraints supplies the constraints input to the NodeSelect contract.
	Constraints pgsql.Expression
}

type OptimizationSummary struct {
	// Rules contains the semantic optimizer rule results in execution order.
	Rules []optimize.RuleResult `json:"rules,omitempty"`
	// PredicateAttachments records optimizer-selected predicate scopes.
	PredicateAttachments []optimize.PredicateAttachment `json:"predicate_attachments,omitempty"`
	// PlannedLowerings summarizes lowering categories selected by the optimizer.
	PlannedLowerings []optimize.LoweringDecision `json:"planned_lowerings,omitempty"`
	// Lowerings summarizes lowering categories actually emitted by translation.
	Lowerings []optimize.LoweringDecision `json:"lowerings,omitempty"`
	// SkippedLowerings explains planned lowering applications that translation did not emit.
	SkippedLowerings []SkippedLowering `json:"skipped_lowerings,omitempty"`
	// TargetOutcomes reports selection and application results for each lowering target.
	TargetOutcomes []TargetLoweringOutcome `json:"target_outcomes,omitempty"`
	// LoweringPlan exposes the optimizer decisions used to translate the statement.
	LoweringPlan *optimize.LoweringPlan `json:"lowering_plan,omitempty"`
}

type OptimizerMode string

type Options struct {
	OptimizerMode OptimizerMode
}

type Pattern struct {
	// Parts supplies the parts input to the Pattern contract.
	Parts []*PatternPart
}

type PatternConstraints struct {
	LeftNode  *Constraint
	Edge      *Constraint
	RightNode *Constraint
}

type PatternPart struct {
	// IsTraversal indicates whether is traversal applies.
	IsTraversal bool
	// ShortestPath identifies the filesystem shortest path.
	ShortestPath bool
	// AllShortestPaths identifies the filesystem all shortest paths.
	AllShortestPaths bool
	// PathDirectionReversed is set when the optimizer reversed the originating cypher pattern's
	// element order and relationship directions. Path materialization uses it to restore the
	// original left-to-right logical order for a bound path.
	PathDirectionReversed bool
	// PatternBinding supplies the pattern binding input to the PatternPart contract.
	PatternBinding *BoundIdentifier
	// Target supplies the target input to the PatternPart contract.
	Target optimize.PatternTarget
	// HasTarget indicates whether has target applies.
	HasTarget bool
	// TraversalSteps supplies the traversal steps input to the PatternPart contract.
	TraversalSteps []*TraversalStep
	// NodeSelect supplies the node select input to the PatternPart contract.
	NodeSelect NodeSelect
	// Constraints supplies the constraints input to the PatternPart contract.
	Constraints *ConstraintTracker
	// contains filtered or unexported fields
}

type ProductionFixedSuffixCaps struct {
	SuffixRowLimit   int64 `json:"suffix_row_limit"`
	StateLimit       int64 `json:"state_limit"`
	OutputRowLimit   int64 `json:"output_row_limit"`
	OutputBytesLimit int64 `json:"output_bytes_limit"`
}

type ProductionOptions struct {
	// ShortestPathExecutor supplies the shortest path executor input to the ProductionOptions contract.
	ShortestPathExecutor optimize.ShortestPathExecutor
	// ShortestPathCaps supplies the shortest path caps input to the ProductionOptions contract.
	ShortestPathCaps *ProductionShortestPathCaps
	// AuthorizedBucket supplies the authorized bucket input to the ProductionOptions contract.
	AuthorizedBucket *ProductionTraversalBucket
	// EnableExpansionOrientation indicates whether enable expansion orientation applies.
	EnableExpansionOrientation bool
	// EnableTopologyFixedSuffix enables the separately versioned production
	// reverse-only fixed-suffix candidate. Callers must supply immutable caps;
	// route selection and exact fallback remain driver responsibilities.
	EnableTopologyFixedSuffix bool
	// TopologyFixedSuffixCaps are the immutable candidate and output limits.
	TopologyFixedSuffixCaps *ProductionFixedSuffixCaps
	// ExpansionOrientationPolicy identifies the manifest-authorized immutable
	// runtime formula. Production callers must set it explicitly when enabling
	// orientation so v2 evidence cannot silently execute the v1 selector.
	ExpansionOrientationPolicy optimize.ExpansionSearchPolicy
	// DisableEndpointSeededReverse indicates whether disable endpoint seeded reverse applies.
	DisableEndpointSeededReverse bool
	// DisableInlineASPDAG indicates whether disable inline aspdag applies.
	DisableInlineASPDAG bool
	// DisableInlineSPWitness indicates whether disable inline sp witness applies.
	DisableInlineSPWitness bool
	// DisableInlineSPDistance is the emergency rollback switch for SP-I2-C-D.
	DisableInlineSPDistance bool
	// SelectorVersion identifies the schema version for selector version.
	SelectorVersion string
}

type ProductionShortestPathCaps struct {
	// StateLimit supplies the state limit input to the ProductionShortestPathCaps contract.
	StateLimit int64 `json:"state_limit"`
	// FrontierLimit caps rows admitted at any one breadth-first level.
	FrontierLimit int64 `json:"frontier_limit"`
	// PredecessorLimit supplies the predecessor limit input to the ProductionShortestPathCaps contract.
	PredecessorLimit int64 `json:"predecessor_limit"`
	// EnumerationLimit supplies the enumeration limit input to the ProductionShortestPathCaps contract.
	EnumerationLimit int64 `json:"enumeration_limit"`
	// OutputBytesLimit supplies the output bytes limit input to the ProductionShortestPathCaps contract.
	OutputBytesLimit int64 `json:"output_bytes_limit"`
}

type ProductionTraversalBucket struct {
	// Direction selects the traversal orientation covered by the contract.
	Direction string `json:"direction"`
	// ObservationMode identifies the observation mode.
	ObservationMode string `json:"observation_mode"`
	// MinimumDepth sets the inclusive lower traversal-depth bound.
	MinimumDepth int64 `json:"minimum_depth"`
	// MaximumDepth sets the inclusive upper traversal-depth bound.
	MaximumDepth int64 `json:"maximum_depth"`
	// RelationshipKindCount records the number of relationship kind count.
	RelationshipKindCount int `json:"relationship_kind_count"`
	// UntypedRelationship indicates whether untyped relationship applies.
	UntypedRelationship bool `json:"untyped_relationship"`
}

type Projection struct {
	// SelectItem supplies the select item input to the Projection contract.
	SelectItem pgsql.SelectItem
	// Alias supplies the alias input to the Projection contract.
	Alias models.Optional[pgsql.Identifier]
}

type ProjectionPruningApplication struct {
	// LeftNode supplies the left node input to the ProjectionPruningApplication contract.
	LeftNode *BoundIdentifier
	// Relationship supplies the relationship input to the ProjectionPruningApplication contract.
	Relationship *BoundIdentifier
	// RightNode supplies the right node input to the ProjectionPruningApplication contract.
	RightNode *BoundIdentifier
	// PathBinding supplies the path binding input to the ProjectionPruningApplication contract.
	PathBinding *BoundIdentifier
}

type Projections struct {
	// Distinct indicates whether distinct applies.
	Distinct bool
	// Frame supplies the frame input to the Projections contract.
	Frame *Frame
	// Constraints supplies the constraints input to the Projections contract.
	Constraints pgsql.Expression
	// OutputConstraints evaluates a WITH predicate for filtering after its row modifiers.
	OutputConstraints pgsql.Expression
	// Items supplies the items input to the Projections contract.
	Items []*Projection
	// GroupBy supplies the group by input to the Projections contract.
	GroupBy []pgsql.Expression
}

type PropertyAssignment struct {
	// Field supplies the field input to the PropertyAssignment contract.
	Field string
	// Operator supplies the operator input to the PropertyAssignment contract.
	Operator pgsql.Operator
	// ValueExpression supplies the value expression input to the PropertyAssignment contract.
	ValueExpression pgsql.Expression
}

type PropertyLookup struct {
	Reference pgsql.CompoundIdentifier
	Field     string
}

type Query struct {
	// Parts supplies the parts input to the Query contract.
	Parts []*QueryPart
}

type QueryPart struct {
	// Model supplies the model input to the QueryPart contract.
	Model *pgsql.Query
	// Frame supplies the frame input to the QueryPart contract.
	Frame *Frame
	// Updates supplies the updates input to the QueryPart contract.
	Updates []*Mutations
	// SortItems supplies the sort items input to the QueryPart contract.
	SortItems []*pgsql.OrderBy
	// Skip supplies the skip input to the QueryPart contract.
	Skip pgsql.Expression
	// Limit supplies the limit input to the QueryPart contract.
	Limit pgsql.Expression
	// contains filtered or unexported fields
}

type QueryStage struct {
	Binding pgsql.Identifier
	Query   pgsql.Query
}

type Removal struct {
	// Field supplies the field input to the Removal contract.
	Field string
}

type Result struct {
	// HasMissingKinds marks plans that depend on absent kind definitions. Caches must
	// bypass these plans so a later kind registration can change the match result.
	HasMissingKinds bool
	// Statement is the translated PostgreSQL AST.
	Statement pgsql.Statement
	// Stages preserves statement boundaries around sequential mutations.
	// Staged translations must be formatted and executed in order in one transaction.
	Stages []QueryStage
	// Parameters contains SQL parameters generated during translation.
	Parameters map[string]any
	// LiteralParameters contains immutable string literals extracted during SQL formatting.
	LiteralParameters map[string]string
	// ParameterSources maps generated SQL parameter names back to Cypher parameter names.
	ParameterSources map[string]string
	// Optimization summarizes planned, applied, and skipped lowering decisions.
	Optimization OptimizationSummary
	// GraphID identifies the graph partitions targeted by the statement.
	GraphID int32
}

type Scope struct {
	// contains filtered or unexported fields
}

type SkippedLowering struct {
	// Name identifies the name.
	Name string `json:"name"`
	// Reason supplies the reason input to the SkippedLowering contract.
	Reason string `json:"reason"`
	// Count records the number of count.
	Count int `json:"count,omitempty"`
}

type TargetEligibilityFact struct {
	// Name identifies the qualification check.
	Name string `json:"name"`
	// Eligible reports whether the target passed the named check.
	Eligible bool `json:"eligible"`
}

type TargetLoweringOutcome struct {
	// Lowering names the lowering pass that produced this outcome.
	Lowering string `json:"lowering"`
	// TargetKind identifies the kind of syntax or binding targeted by the lowering.
	TargetKind string `json:"target_kind"`
	// TraversalTarget locates a traversal-step target when the lowering applies to one.
	TraversalTarget *optimize.TraversalStepTarget `json:"traversal_target,omitempty"`
	// QueryPartIndex locates a query-part target when the lowering applies to one.
	QueryPartIndex *int `json:"query_part_index,omitempty"`
	// Symbol identifies a binding target when the lowering applies to one.
	Symbol string `json:"symbol,omitempty"`
	// Family names the candidate-selection family that produced this outcome.
	Family string `json:"family,omitempty"`
	// TraversalFamily preserves the SP/ASP family for analysis-only decisions
	// whose outcome family must remain distinct from an executable traversal.
	TraversalFamily string `json:"traversal_family,omitempty"`
	// PlannedPolicy identifies the runtime policy intended for this candidate
	// family, whether or not it was emitted.
	PlannedPolicy string `json:"planned_policy,omitempty"`
	// EmittedPolicy identifies a runtime policy present in translated SQL. A
	// single incumbent or tool-forced arm has no emitted policy identity.
	EmittedPolicy string `json:"emitted_policy,omitempty"`
	// PlannedCandidates lists the candidates considered in preference order.
	PlannedCandidates []string `json:"planned_candidates,omitempty"`
	// EmittedCandidates lists the arms present in translated SQL. Runtime
	// telemetry separately records which arm executed.
	EmittedCandidates []string `json:"emitted_candidates,omitempty"`
	// ProbeCaps records bounded evidence inputs for an expansion policy.
	ProbeCaps *optimize.ExpansionSearchProbeCaps `json:"probe_caps,omitempty"`
	// Admission supplies the admission input to the TargetLoweringOutcome contract.
	Admission *optimize.ExpansionSearchAdmission `json:"admission,omitempty"`
	// EndpointRoot and EndpointTerminal describe the bounded endpoint inputs
	// considered by analysis without implying that translation emitted them.
	EndpointRoot *optimize.EndpointResolutionInput `json:"endpoint_root,omitempty"`
	// EndpointTerminal supplies the endpoint terminal input to the TargetLoweringOutcome contract.
	EndpointTerminal *optimize.EndpointResolutionInput `json:"endpoint_terminal,omitempty"`
	// EndpointPairClass records a correlation class when endpoint resolution
	// must preserve a paired input rather than independent endpoint sets.
	EndpointPairClass optimize.EndpointResolutionClass `json:"endpoint_pair_class,omitempty"`
	// EndpointResolutionCaps records immutable 1/2/32/33 admission sentinels.
	EndpointResolutionCaps *optimize.EndpointResolutionCaps `json:"endpoint_resolution_caps,omitempty"`
	// PredicateClass and its source/index expose conservative traversal
	// predicate placement analysis as a first-class target outcome.
	PredicateClass optimize.TraversalPredicateClass `json:"predicate_class,omitempty"`
	// PredicateSource supplies the predicate source input to the TargetLoweringOutcome contract.
	PredicateSource string `json:"predicate_source,omitempty"`
	// PredicateIndex supplies the predicate index input to the TargetLoweringOutcome contract.
	PredicateIndex *int `json:"predicate_index,omitempty"`
	// Scheduler identifies the selected shortest-path frontier scheduling policy.
	Scheduler string `json:"scheduler,omitempty"`
	// ExecutionBoundary identifies whether the selected executor is inline SQL,
	// a stored helper, or a guarded multi-arm statement.
	ExecutionBoundary string `json:"execution_boundary,omitempty"`
	// Candidate is the specialized candidate proposed by analysis.
	Candidate string `json:"candidate,omitempty"`
	// EligibilityFacts records named qualification checks for the candidate.
	EligibilityFacts []TargetEligibilityFact `json:"eligibility_facts,omitempty"`
	// ObservationMode describes how downstream clauses consume the target.
	ObservationMode string `json:"observation_mode,omitempty"`
	// Direction selects the traversal orientation covered by the contract.
	Direction string `json:"direction,omitempty"`
	// PhysicalExpansion supplies the physical expansion input to the TargetLoweringOutcome contract.
	PhysicalExpansion string `json:"physical_expansion,omitempty"`
	// RelationshipKindCount is the number of statically resolved relationship kinds.
	RelationshipKindCount int `json:"relationship_kind_count,omitempty"`
	// UntypedRelationship reports whether the pattern omitted relationship kinds.
	UntypedRelationship bool `json:"untyped_relationship,omitempty"`
	// TopologyClassification summarizes logical direction, physical direction, and depth.
	TopologyClassification string `json:"topology_classification,omitempty"`
	// Eligible reports the structural qualification result when one is available.
	Eligible *bool `json:"eligible,omitempty"`
	// StaticallyEligible reports the literal- and kind-based qualification result when available.
	StaticallyEligible *bool `json:"statically_eligible,omitempty"`
	// SelectionMode records whether selection was automatic or forced by tooling.
	SelectionMode string `json:"selection_mode,omitempty"`
	// SelectorVersion identifies the policy version that ranked candidates.
	SelectorVersion string `json:"selector_version,omitempty"`
	// Fallback names the candidate used if the preferred lowering was not applied.
	Fallback string `json:"fallback,omitempty"`
	// MinimumDepth is the target's inclusive lower traversal-depth bound.
	MinimumDepth *int64 `json:"minimum_depth,omitempty"`
	// MaximumDepth is the target's inclusive upper traversal-depth bound when finite.
	MaximumDepth *int64 `json:"maximum_depth,omitempty"`
	// MaximumDepthSource distinguishes an explicit upper bound from the
	// repository's existing effective cap for syntax-open shortest paths.
	MaximumDepthSource string `json:"maximum_depth_source,omitempty"`
	// StateLimit is the maximum intermediate-state count admitted by the candidate.
	StateLimit int64 `json:"state_limit,omitempty"`
	// FrontierLimit is the maximum current or queued frontier size admitted by a shortest-path candidate.
	FrontierLimit int64 `json:"frontier_limit,omitempty"`
	// PredecessorLimit is the maximum retained witness predecessor state admitted by a shortest-path candidate.
	PredecessorLimit int64 `json:"predecessor_limit,omitempty"`
	// EnumerationLimit is the maximum distinct ordered path count staged by an all-shortest-path candidate.
	EnumerationLimit int64 `json:"enumeration_limit,omitempty"`
	// OutputBytesLimit is the maximum staged ordered edge-array bytes admitted by an all-shortest-path candidate.
	OutputBytesLimit int64 `json:"output_bytes_limit,omitempty"`
	// EndpointLimit is the maximum endpoint-seed count admitted by the candidate.
	EndpointLimit int64 `json:"endpoint_limit,omitempty"`
	// SeedPredicateClass describes the predicate used to bound search seeds.
	SeedPredicateClass string `json:"seed_predicate_class,omitempty"`
	// PrefixLength is the number of fixed steps before the variable expansion.
	PrefixLength int `json:"prefix_length,omitempty"`
	// HasFinalLimit reports whether a final row limit influenced candidate selection.
	HasFinalLimit bool `json:"has_final_limit,omitempty"`
	// Selected names the candidate selected by the optimizer.
	Selected string `json:"selected,omitempty"`
	// Applied names the candidate actually emitted by translation.
	Applied string `json:"applied,omitempty"`
	// SkipReason explains why a planned candidate was not emitted.
	SkipReason string `json:"skip_reason,omitempty"`
}

type ToolOptions struct {
	// ForceShortestPathExecutor requests a qualified shortest-path executor instead of automatic selection.
	ForceShortestPathExecutor optimize.ShortestPathExecutor
	// GuardedDistanceStateLimit overrides SP-I2's cap+1 state admission only for
	// diagnostic tool forcing. It must be paired with a positive frontier limit.
	GuardedDistanceStateLimit int64
	// GuardedDistanceFrontierLimit overrides SP-I2's per-level frontier admission
	// only for diagnostic tool forcing. Production caps remain immutable.
	GuardedDistanceFrontierLimit int64
	// ForceExpansionSearchStrategy requests a qualified variable-expansion strategy instead of automatic selection.
	ForceExpansionSearchStrategy optimize.ExpansionSearchStrategy
	// ExpansionOrientationPolicy selects the immutable orientation selector
	// identity used by an enabled tournament or shadow mode. The zero value
	// preserves orientation-probe-v1.
	ExpansionOrientationPolicy optimize.ExpansionSearchPolicy
	// EnableExpansionOrientationTournament emits a guarded orientation policy
	// for one qualified fixed-suffix expansion. It defaults to
	// orientation-probe-v1 and is intentionally tool-only while selectors are
	// being shadow-qualified.
	EnableExpansionOrientationTournament bool
	// EnableExpansionOrientationShadow emits the same bounded orientation
	// probes and SQL-visible would_select metadata while executing only the
	// exact incumbent traversal arm.
	EnableExpansionOrientationShadow bool
	// EnableExpansionSuffixReverseGuard emits bounded fixed-suffix reverse
	// execution with exact stepwise-forward fallback for one statically eligible
	// full-path observation. It is deliberately tool-only during qualification.
	EnableExpansionSuffixReverseGuard bool
	// EnableExpansionSuffixReverseRetry emits only the bounded fixed-suffix
	// reverse candidate. The PostgreSQL tool transaction owns exact forward
	// retry; this option never installs a production selector.
	EnableExpansionSuffixReverseRetry bool
	// EnableExpansionSuffixRouteComponent emits one exact suffix-seeded reverse
	// statement with a runtime receipt. It is a default-off GraphBench component
	// arm and has no retry, probe, cache, or production policy.
	EnableExpansionSuffixRouteComponent bool
	// SuffixReverseGuardSuffixRowLimit overrides the tool-only fixed-suffix
	// payload cap. Zero selects ExpansionSearchSuffixReverseGuardSuffixRowLimit.
	SuffixReverseGuardSuffixRowLimit int64
	// SuffixReverseGuardStateLimit overrides the tool-only reverse-state cap.
	// Zero selects ExpansionSearchSuffixReverseGuardStateLimit.
	SuffixReverseGuardStateLimit int64
	// SuffixReverseRetryOutputRowLimit caps buffered candidate rows. Zero selects
	// ExpansionSearchSuffixReverseRetryOutputRowLimit.
	SuffixReverseRetryOutputRowLimit int64
	// SuffixReverseRetryOutputBytesLimit caps buffered candidate bytes. Zero
	// selects ExpansionSearchSuffixReverseRetryOutputBytesLimit.
	SuffixReverseRetryOutputBytesLimit int64
	// DisableEndpointSeededReverse is an emergency production rollback switch.
	DisableEndpointSeededReverse bool
}

type TranslatedProperties struct {
	// Map supplies the map input to the TranslatedProperties contract.
	Map map[string]pgsql.Expression
	// Parameter supplies the parameter input to the TranslatedProperties contract.
	Parameter pgsql.Expression
}

type Translator struct {
	// Visitor supplies traversal control and error propagation for the Cypher walk.
	walk.Visitor[cypher.SyntaxNode]
	// contains filtered or unexported fields
}

type TraversalStep struct {
	// Frame supplies the frame input to the TraversalStep contract.
	Frame *Frame
	// SourceTarget supplies the source target input to the TraversalStep contract.
	SourceTarget optimize.TraversalStepTarget
	// HasSourceTarget indicates whether has source target applies.
	HasSourceTarget bool
	// Direction selects the traversal orientation covered by the contract.
	Direction graph.Direction
	// Expansion supplies the expansion input to the TraversalStep contract.
	Expansion *Expansion
	// PathReversed indicates whether path reversed applies.
	PathReversed bool

	// OmitPreviousFrameSource suppresses comma-joining the previous frame as a FROM source. Pattern
	// predicate roots require this so that references to the enclosing query part's frame remain
	// correlated to the outer row instead of re-scanning the outer CTE.
	OmitPreviousFrameSource bool

	// ProjectionPruning supplies the projection pruning input to the TraversalStep contract.
	ProjectionPruning ProjectionPruningApplication
	// LeftNode supplies the left node input to the TraversalStep contract.
	LeftNode *BoundIdentifier
	// LeftNodeBound indicates whether left node bound applies.
	LeftNodeBound bool
	// UseExpandInto indicates whether use expand into applies.
	UseExpandInto bool
	// LeftNodeConstraints supplies the left node constraints input to the TraversalStep contract.
	LeftNodeConstraints pgsql.Expression
	// LeftNodeJoinCondition supplies the left node join condition input to the TraversalStep contract.
	LeftNodeJoinCondition pgsql.Expression
	// Edge supplies the edge input to the TraversalStep contract.
	Edge *BoundIdentifier
	// EdgeConstraints supplies the edge constraints input to the TraversalStep contract.
	EdgeConstraints *Constraint
	// EdgeJoinCondition supplies the edge join condition input to the TraversalStep contract.
	EdgeJoinCondition pgsql.Expression
	// RightNode supplies the right node input to the TraversalStep contract.
	RightNode *BoundIdentifier
	// RightNodeBound indicates whether right node bound applies.
	RightNodeBound bool
	// RightNodeConstraints supplies the right node constraints input to the TraversalStep contract.
	RightNodeConstraints pgsql.Expression
	// RightNodeJoinCondition supplies the right node join condition input to the TraversalStep contract.
	RightNodeJoinCondition pgsql.Expression
	// Projection supplies the projection input to the TraversalStep contract.
	Projection []pgsql.SelectItem
}

type TraversalStepContext struct {
	// PreviousStep supplies the previous step input to the TraversalStepContext contract.
	PreviousStep *TraversalStep
	// CurrentStep supplies the current step input to the TraversalStepContext contract.
	CurrentStep *TraversalStep
	// IsRootStep indicates whether is root step applies.
	IsRootStep bool
}

type UnwindClause struct {
	// Expression supplies the expression input to the UnwindClause contract.
	Expression pgsql.Expression
	// Binding supplies the binding input to the UnwindClause contract.
	Binding *BoundIdentifier
}

type Update struct {
	// Frame supplies the frame input to the Update contract.
	Frame *Frame
	// JoinConstraint supplies the join constraint input to the Update contract.
	JoinConstraint pgsql.Expression
	// Projection supplies the projection input to the Update contract.
	Projection []pgsql.SelectItem
	// TargetBinding supplies the target binding input to the Update contract.
	TargetBinding *BoundIdentifier
	// UpdateBinding supplies the update binding input to the Update contract.
	UpdateBinding *BoundIdentifier
	// contains filtered or unexported fields
}