sqlgen

type Add = sqldsl.Add

type Alias = sqldsl.Alias

type AnchorPathStep = analysis.AnchorPathStep

type AndExpr = sqldsl.AndExpr

type ArrayAppend = sqldsl.ArrayAppend

type ArrayContains = sqldsl.ArrayContains

type ArrayLength = sqldsl.ArrayLength

type ArrayLiteral = sqldsl.ArrayLiteral

type Assign = plpgsql.Assign

type BlockSet struct {
	Primary       []TypedQueryBlock
	Secondary     []TypedQueryBlock
	SecondarySelf *TypedQueryBlock
}

type Bool = sqldsl.Bool

type CTEDef = sqldsl.CTEDef

type CaseExpr = sqldsl.CaseExpr

type CaseWhen = sqldsl.CaseWhen

type Cast = sqldsl.Cast

type CheckBlocks struct {
	DirectCheck             Expr       // EXISTS check for direct/implied tuple lookup
	UsersetCheck            Expr       // EXISTS check for userset membership
	ExclusionCheck          Expr       // EXISTS check for exclusion (denial)
	UsersetSubjectSelfCheck SelectStmt // Validates when subject IS a userset

	// UsersetSubjectComputedCheck validates userset subject via tuple join
	UsersetSubjectComputedCheck SelectStmt

	ParentRelationBlocks []ParentRelationBlock    // TTU pattern checks
	ImpliedFunctionCalls []ImpliedFunctionCheck   // Complex implied relation checks
	IntersectionGroups   []IntersectionGroupCheck // AND groups for intersection patterns
	HasStandaloneAccess  bool                     // Access paths outside intersections exist
}

type CheckPermission struct {
	Schema      string
	Subject     SubjectRef
	Relation    string
	Object      ObjectRef
	Visited     Expr // nil uses empty array
	ExpectAllow bool // true compares "= 1", false compares "= 0"
}

type CheckPermissionCall struct {
	Schema       string
	FunctionName string
	Subject      SubjectRef
	Relation     string
	Object       ObjectRef
	ExpectAllow  bool
}

type CheckPlan struct {
	// Input data
	Analysis       RelationAnalysis
	Inline         InlineSQLData
	DatabaseSchema string

	// Function identity
	FunctionName              string
	InternalCheckFunctionName string // Dispatcher function for recursive calls
	ObjectType                string
	Relation                  string
	FeaturesString            string // Human-readable features for SQL comments

	// Feature configuration
	AllowWildcard bool            // Whether wildcards are allowed
	NoWildcard    bool            // True if this is a no-wildcard variant
	Exclusions    ExclusionConfig // Exclusion rules configuration

	// Feature flags (derived from analysis)
	HasDirect       bool
	HasImplied      bool
	HasUserset      bool
	HasExclusion    bool
	HasIntersection bool
	HasRecursive    bool

	// Derived computation flags
	HasStandaloneAccess    bool // Has access paths outside of intersections
	HasComplexUsersets     bool // Has userset patterns requiring function calls
	NeedsPLpgSQL           bool // Requires PL/pgSQL (not pure SQL)
	HasParentRelations     bool // Has TTU patterns
	HasImpliedFunctionCall bool // Has complex implied relations needing function calls

	// Eligibility from unified analysis
	Capabilities GenerationCapabilities

	// Relation lists for closure lookups
	RelationList        []string // Relations for tuple lookup (self + simple closure)
	ComplexClosure      []string // Complex closure relations
	AllowedSubjectTypes []string // Subject types allowed for this relation

	// ComplexityByRelation maps (object_type, relation) to a cost score. Used to
	// order ImpliedFunctionCalls (same object type) and ParentRelationBlocks
	// (different object type) so cheapest callees are evaluated first in OR
	// short-circuit chains. May be nil; absent entries score zero.
	ComplexityByRelation map[string]map[string]int

	// NeedsNoWildcard maps (object_type, relation) to whether a distinct _nw
	// check function is emitted for it. Used when NoWildcard is true to decide,
	// for each complex-closure callee, whether to call its _nw function or its
	// base function (identical body, no _nw emitted). Nil means "always assume a
	// _nw variant exists" (backward-compatible for direct plan-builder callers).
	NeedsNoWildcard map[string]map[string]bool
}

type ClosureRow = analysis.ClosureRow

type Col = sqldsl.Col

type Comment = plpgsql.Comment

type CommentedSQL = sqldsl.CommentedSQL

type ComposedObjectsBlockSet struct {
	// SelfBlock is the self-candidate check block
	SelfBlock *TypedQueryBlock

	// MainBlocks are the composed query blocks (TTU and/or userset paths)
	MainBlocks []TypedQueryBlock

	// AllowedSubjectTypes for the type guard
	AllowedSubjectTypes []string

	// Anchor metadata for comments
	AnchorType     string
	AnchorRelation string
	FirstStepType  string
}

type ComposedSubjectsBlockSet struct {
	// SelfBlock is the self-candidate check block (for userset filter)
	SelfBlock *TypedQueryBlock

	// UsersetFilterBlocks are candidate blocks for userset filter path
	UsersetFilterBlocks []TypedQueryBlock

	// RegularBlocks are candidate blocks for regular path
	RegularBlocks []TypedQueryBlock

	// AllowedSubjectTypes for the type guard
	AllowedSubjectTypes []string

	// HasExclusions indicates if exclusion predicates are needed
	HasExclusions bool

	// Anchor metadata for comments
	AnchorType     string
	AnchorRelation string
	FirstStepType  string
}

type Concat = sqldsl.Concat

type Decl = plpgsql.Decl

type DispatcherCase struct {
	DatabaseSchema      string
	ObjectType          string
	Relation            string
	CheckFunctionName   string
	Inlineable          bool     // true if simple direct-assignment only (bulk dispatcher can inline EXISTS)
	DirectSubjectTypes  []string // subject types allowed for direct tuples (used in inline)
	SatisfyingRelations []string // relations in closure that satisfy this one (used in inline userset check)
}

type DispatcherData struct {
	FunctionName            string
	HasSpecializedFunctions bool
	Cases                   []DispatcherCase
}

type EmptyArray = sqldsl.EmptyArray

type Eq = sqldsl.Eq

type ExcludedIntersectionGroup struct {
	Parts []ExcludedIntersectionPart
}

type ExcludedIntersectionPart struct {
	Relation         string                  // The relation to check
	ExcludedRelation string                  // Optional nested exclusion (e.g., "editor but not owner")
	ParentRelation   *ExcludedParentRelation // Optional TTU pattern in the intersection
}

type ExcludedParentRelation struct {
	Relation            string   // The relation to check on the parent (e.g., "viewer")
	LinkingRelation     string   // The relation linking to the parent (e.g., "parent")
	AllowedLinkingTypes []string // Object types the linking relation can point to
}

type ExclusionConfig struct {
	DatabaseSchema string
	ObjectType     string // The object type being checked

	ObjectIDExpr    Expr // Expression for the object ID (typically a column or parameter)
	SubjectTypeExpr Expr // Expression for the subject type
	SubjectIDExpr   Expr // Expression for the subject ID

	// SimpleExcludedRelations can use direct tuple lookups (NOT EXISTS).
	SimpleExcludedRelations []string

	// ComplexExcludedRelations need check_permission_internal calls.
	ComplexExcludedRelations []string

	// ExcludedParentRelations represent TTU exclusions (e.g., "but not viewer from parent").
	ExcludedParentRelations []ExcludedParentRelation

	// ExcludedIntersection represents intersection exclusions (e.g., "but not (A and B)").
	ExcludedIntersection []ExcludedIntersectionGroup

	// Compose, when set, lets complex exclusions replace the per-candidate
	// check_permission_internal(...) = 0 with a set-oriented anti-join against
	// the excluded relation's list_objects function. It is only valid in a
	// list_objects context — ObjectIDExpr must be the per-row candidate column
	// and the subject exprs query-constant params — so only the list_objects
	// plan builder sets it; check and list_subjects contexts leave it nil and
	// keep the per-candidate check.
	Compose *exclusionCompose
}

type Exists = sqldsl.Exists

type ExpandExclusion struct {
	Relation       string
	ParentRelation *ParentRelationInfo
	Intersection   *IntersectionGroupInfo
}

type ExpandPlan struct {
	DatabaseSchema string
	ObjectType     string
	Relation       string
	Rewrites       []ExpandRewrite
	// Exclusions captures the relation's `but not` subtrahends. Each
	// entry wraps into a `Difference{base, subtract}` node, with the
	// previous tree as `base` — chained exclusions like
	// `(writer but not editor) but not owner` produce left-nested
	// Differences. Each entry's shape determines its subtract leaf:
	//
	//   - Relation set                 → Leaf.Computed pointer
	//     (`but not X` — covers both simple and complex; Expand emits a
	//      pointer and the caller chases via ExpandRecursive)
	//   - ParentRelation set           → Leaf.TupleToUserset
	//     (`but not X from Y` — same shape as the top-level TTU rewrite)
	//   - Intersection set             → Nodes.Intersection
	//     (`but not (A and B)` — reuses the intersection rewrite shape)
	//
	// An empty slice means the relation has no exclusion (the renderer
	// emits the rewrites-derived tree directly).
	Exclusions []ExpandExclusion
}

type ExpandRewrite struct {
	// Direct is the subject-type whitelist for a direct rewrite. nil/empty
	// means this rewrite is not a direct grant.
	Direct []string
	// Computed is the implied relation name on the same object type for
	// a computed-userset rewrite. Empty means this rewrite is not a
	// computed pointer.
	Computed string
	// TTU carries the "X from Y" rewrite info. nil means this rewrite is
	// not a TTU. When set the renderer emits a Leaf.TupleToUserset with
	// tupleset = "<obj>:#<linking>" and one Computed per linked object
	// (enumerated at expand time via jsonb_agg over melange_tuples).
	TTU *ParentRelationInfo
	// Intersection lists the parts for `a and b [and …]` rewrites. nil
	// means this rewrite is not an intersection. When set the renderer
	// emits a Nodes intersection wrapping one child per part — each
	// child's value slot dispatches by part shape (Computed pointer for
	// plain-relation parts, Leaf.Users for IsThis, Leaf.TupleToUserset
	// for ParentRelation, Difference for per-part exclusion). Same
	// shallow-pointer treatment as the Computed rewrite because
	// OpenFGA's Expand never resolves intersection parts recursively.
	Intersection []IntersectionPart
}

type Expr = sqldsl.Expr

type ForLoop = plpgsql.ForLoop

type Func = sqldsl.Func

type FuncArg = plpgsql.FuncArg

type FuncCallEq = sqldsl.FuncCallEq

type FuncCallNe = sqldsl.FuncCallNe

type FunctionCallExpr = sqldsl.FunctionCallExpr

type GenerateSQLOptions struct {
	// EnableMaterializedCTEs forces "AS MATERIALIZED" on multi-referenced CTEs
	// inside generated list functions. The default (false) lets PostgreSQL
	// decide whether to inline or materialize each CTE — which on benchmarked
	// production-scale workloads (100K+ tuples) outperformed forced
	// materialization by ~10% on heavy list_objects queries.
	//
	// Set true when profiling shows a workload where forced materialization
	// wins (typically queries whose inner CTE is recomputed many times due to
	// inlining and produces non-trivial row counts).
	EnableMaterializedCTEs bool
}

type GeneratedSQL struct {
	// Functions contains CREATE OR REPLACE FUNCTION statements
	// for each specialized check function (check_{type}_{relation}).
	Functions []string

	// NoWildcardFunctions contains CREATE OR REPLACE FUNCTION statements
	// for no-wildcard variants (check_{type}_{relation}_nw).
	// These skip wildcard matching for performance-critical paths.
	NoWildcardFunctions []string

	// NoWildcardIndex maps object_type -> relation -> whether a distinct _nw
	// variant was emitted (true) or the base function is reused (false). It is the
	// buildNoWildcardIndex result computed once during generation, exposed so
	// callers (e.g. CollectNamedFunctions) need not recompute the per-relation
	// wildcard-reachability walk.
	NoWildcardIndex map[string]map[string]bool

	// Dispatcher contains the check_permission dispatcher function
	// that routes requests to specialized functions based on object type and relation.
	Dispatcher string

	// DispatcherNoWildcard contains the check_permission_nw dispatcher.
	DispatcherNoWildcard string

	// BulkDispatcher contains the check_permission_bulk function that evaluates
	// multiple permission checks in a single SQL call using UNION ALL branches.
	BulkDispatcher string

	// ExplainFunctions contains CREATE OR REPLACE FUNCTION statements for the
	// per-relation explain_{type}_{relation} functions. Each returns JSONB
	// shaped to melange.Trace and is the codegen companion to check_*.
	ExplainFunctions []string

	// ExplainDispatcher contains the explain_permission public + internal
	// functions that route to per-relation explain_* by (object_type, relation).
	// Returns a structurally valid JSONB Trace even for unknown pairs so
	// callers can deserialise without special-casing.
	ExplainDispatcher string

	// ExplainEligible records the (object_type, relation) pairs for which an
	// explain function was generated. CollectNamedFunctions reads this
	// directly; hand-built GeneratedSQL values must populate it via
	// ComputeExplainEligibility(analyses) before calling CollectNamedFunctions.
	ExplainEligible map[string]map[string]bool

	// ExpandFunctions contains CREATE OR REPLACE FUNCTION statements for the
	// per-relation expand_{type}_{relation} functions. Each returns the
	// OpenFGA-shaped UsersetTree JSONB documented in melange/expand.go.
	ExpandFunctions []string

	// ExpandDispatcher contains the expand_permission public + internal
	// functions that route to per-relation expand_* by (object_type, relation).
	// Returns an empty Leaf.Users sentinel for unknown / not-yet-supported
	// pairs so OpenFGA tooling deserialises without special-casing.
	ExpandDispatcher string

	// ExpandEligible records the (object_type, relation) pairs for which an
	// expand function was generated. Stage 2 slice 2.1 gates many shapes
	// (TTU, intersection, exclusion, usersets, wildcards, complex usersets)
	// out — those route to the dispatcher's empty-leaf sentinel until the
	// follow-up slices land.
	ExpandEligible map[string]map[string]bool

	// IndexRecommendations lists composite indexes that make the generated
	// functions efficient against melange_tuples. Advisory only — users
	// translate the DDL to their source tables. See RecommendIndexes.
	IndexRecommendations []IndexRecommendation
}

type GenerationCapabilities = analysis.GenerationCapabilities

type Gt = sqldsl.Gt

type Gte = sqldsl.Gte

type HasUserset = sqldsl.HasUserset

type If = plpgsql.If

type ImpliedFunctionCheck struct {
	Relation     string
	FunctionName string
	Check        Expr
}

type In = sqldsl.In

type InCTESelect = sqldsl.InCTESelect

type InFunctionSelect = sqldsl.InFunctionSelect

type IndexRecommendation struct {
	// BaseTable is the table the DDL targets. Always "melange_tuples" in the
	// schema-driven flow; doctor integration may rewrite to source tables.
	BaseTable string

	// Columns is the ordered composite — earliest-most-selective first.
	Columns []string

	// WhereClause is an optional partial-index predicate. Empty for full indexes.
	WhereClause string

	// BenefitsFunctions lists generated function names that match this index's
	// access pattern. Sorted alphabetically for stable output.
	BenefitsFunctions []string

	// DDL is the rendered CREATE INDEX IF NOT EXISTS statement.
	DDL string
}

type IndirectAnchorInfo = analysis.IndirectAnchorInfo

type InlineSQLData = inline.InlineSQLData

type Int = sqldsl.Int

type IntersectSubquery = sqldsl.IntersectSubquery

type IntersectionGroup = analysis.IntersectionGroup

type IntersectionGroupCheck struct {
	Parts []IntersectionPartCheck
}

type IntersectionGroupInfo = analysis.IntersectionGroupInfo

type IntersectionPart = analysis.IntersectionPart

type IntersectionPartCheck struct {
	Relation         string
	ExcludedRelation string
	IsThis           bool // [user]-direct grant probe at the wrapping relation
	IsParent         bool
	ParentRelation   string
	LinkingRelation  string
	Check            Expr
}

type IsNotNull = sqldsl.IsNotNull

type IsNull = sqldsl.IsNull

type IsWildcard = sqldsl.IsWildcard

type JoinClause = sqldsl.JoinClause

type LateralFunction = sqldsl.LateralFunction

type Like = sqldsl.Like

type ListAnchorPathStepData struct {
	Type string // "ttu" or "userset"

	// For TTU steps (e.g., "viewer from parent"):
	LinkingRelation string   // "parent"
	TargetType      string   // "folder" (first type with direct anchor)
	TargetRelation  string   // "viewer"
	AllTargetTypes  []string // All types with direct anchor (e.g., ["document", "folder"])
	RecursiveTypes  []string // Types needing check_permission_internal (same-type recursive TTU)

	// For userset steps (e.g., [group#member]):
	SubjectType             string // "group"
	SubjectRelation         string // "member"
	SatisfyingRelationsList string // SQL-formatted satisfying relations
	HasWildcard             bool   // Whether membership allows wildcards
}

type ListDispatcherCase struct {
	DatabaseSchema string
	ObjectType     string
	Relation       string
	FunctionName   string
}

type ListDispatcherData struct {
	// HasSpecializedFunctions is true if any specialized list functions were generated.
	HasSpecializedFunctions bool

	// Cases contains the routing cases for specialized functions.
	Cases []ListDispatcherCase
}

type ListGeneratedSQL struct {
	// ListObjectsFunctions contains CREATE OR REPLACE FUNCTION statements
	// for each specialized list_objects function (list_{type}_{relation}_objects).
	ListObjectsFunctions []string

	// ListSubjectsFunctions contains CREATE OR REPLACE FUNCTION statements
	// for each specialized list_subjects function (list_{type}_{relation}_subjects).
	ListSubjectsFunctions []string

	// ListObjectsDispatcher contains the list_accessible_objects dispatcher function
	// that routes to specialized functions or falls back to generic.
	ListObjectsDispatcher string

	// ListSubjectsDispatcher contains the list_accessible_subjects dispatcher function
	// that routes to specialized functions or falls back to generic.
	ListSubjectsDispatcher string
}

type ListIndirectAnchorData struct {
	// Path steps from this relation to the anchor
	Path []ListAnchorPathStepData

	// First step's target function (used for composition)
	// For multi-hop chains, we compose with the first step's target, not the anchor.
	// e.g., for job.can_read -> permission.assignee -> role.assignee, we call
	// list_permission_assignee_objects (first step's target), not list_role_assignee_objects (anchor).
	FirstStepTargetFunctionName string // e.g., "list_permission_assignee_objects"

	// Anchor relation info (end of the chain)
	AnchorType              string // Type of anchor relation (e.g., "folder")
	AnchorRelation          string // Anchor relation name (e.g., "viewer")
	AnchorFunctionName      string // Name of anchor's list function (e.g., "list_folder_viewer_objects")
	AnchorSubjectTypes      string // SQL-formatted allowed subject types from anchor
	AnchorHasWildcard       bool   // Whether anchor supports wildcards
	SatisfyingRelationsList string // SQL-formatted list of relations that satisfy the anchor
}

type ListParentRelationData struct {
	Relation            string // Relation to check on parent (e.g., "viewer")
	LinkingRelation     string // Relation that links to parent (e.g., "parent")
	AllowedLinkingTypes string // SQL-formatted list of parent types (e.g., "'folder', 'org'")
	ParentType          string // First allowed linking type (for self-referential check)
	IsSelfReferential   bool   // True if any parent type equals the object type

	// AllowedLinkingTypesSlice contains the same types as AllowedLinkingTypes but as a slice.
	// Used for typed DSL expressions (In{Expr: ..., Values: AllowedLinkingTypesSlice}).
	AllowedLinkingTypesSlice []string

	// CrossTypeLinkingTypes is a SQL-formatted list of linking types that are NOT self-referential.
	// When a parent relation allows both self-referential and cross-type links (e.g., [folder, document]
	// for document.parent), this contains only the cross-type entries (e.g., "'folder'").
	// Used to generate check_permission_internal calls for cross-type parents even when
	// IsSelfReferential is true for the same linking relation.
	CrossTypeLinkingTypes string
	HasCrossTypeLinks     bool // True if CrossTypeLinkingTypes is non-empty

	// IsClosurePattern indicates this TTU pattern was inherited from an implied relation.
	// For example, if `can_read: reader` and `reader: repo_admin from owner but not restricted`,
	// then can_read's TTU "owner -> repo_admin" is a closure pattern with SourceRelation="reader".
	// Closure patterns must verify through the source relation to honor its exclusions/intersections.
	IsClosurePattern bool
	SourceRelation   string // The relation this TTU was inherited from (for closure patterns)
}

type ListPlan struct {
	// Input data
	Analysis       RelationAnalysis
	Inline         InlineSQLData
	DatabaseSchema string

	// Function identity
	FunctionName string
	ObjectType   string
	Relation     string

	// Computed relation lists
	RelationList           []string // Relations for tuple lookup (self + simple closure)
	AllSatisfyingRelations []string // All relations that satisfy this one (for list_subjects)
	AllowedSubjectTypes    []string // Subject types allowed for this relation
	ComplexClosure         []string // Complex closure relations (excluding intersection)

	// Feature configuration
	AllowWildcard bool            // Whether the relation can surface '*' (direct or TTU-reachable)
	Exclusions    ExclusionConfig // Exclusion rules configuration

	// Feature flags (derived from analysis)
	HasUserset      bool
	HasExclusion    bool
	HasIntersection bool
	HasRecursive    bool

	// Eligibility and strategy from unified analysis
	Capabilities GenerationCapabilities
	Strategy     ListStrategy

	// Additional flags for routing
	HasUsersetSubject   bool // Has userset subject matching capability
	HasUsersetPatterns  bool // Has userset patterns to expand
	HasComplexUsersets  bool // Has userset patterns requiring check_permission calls
	HasStandaloneAccess bool // Has standalone access paths (not constrained by intersection)

	// Optimization flags
	UseCTEExclusion bool // Use CTE-based exclusion optimization (precompute + anti-join)

	// Analysis lookup for checking parent relation complexity (TTU optimization)
	// Maps "objectType.relation" -> *RelationAnalysis
	// Used by TTU block generation to determine if parent relations are simple or complex
	AnalysisLookup map[string]*RelationAnalysis

	// EnableMaterializedCTEs, when true, emits AS MATERIALIZED on
	// multi-referenced CTEs in generated list functions. Default false: PG
	// chooses inlining vs materialization on its own, which on benchmarked
	// production-scale workloads outperformed forced materialization. Wired
	// from GenerateSQLOptions for callers that profile a workload where
	// forced materialization helps.
	EnableMaterializedCTEs bool
}

type ListStrategy = analysis.ListStrategy

type ListUsersetPatternData struct {
	SubjectType     string // e.g., "group"
	SubjectRelation string // e.g., "member"

	// SatisfyingRelationsList is a SQL-formatted list of relations that satisfy SubjectRelation.
	// e.g., "'member', 'admin'" when admin implies member.
	SatisfyingRelationsList string

	// SourceRelationList is a SQL-formatted list of relations to search for userset grant tuples.
	// For direct userset patterns, this is the same as the parent's RelationList.
	// For closure userset patterns (inherited from implied relations), this is the source relation.
	// e.g., "'viewer'" for a pattern inherited from viewer: [group#member]
	SourceRelationList string

	// SourceRelation is the relation where this userset pattern is defined (unquoted).
	// Used for closure patterns to verify permission via check_permission_internal.
	SourceRelation string

	// IsClosurePattern is true if this pattern is inherited from an implied relation.
	// When true, candidates need to be verified via check_permission_internal on the
	// source relation to apply any exclusions or complex features.
	IsClosurePattern bool

	// HasWildcard is true if any satisfying relation allows wildcards.
	// When true, membership check includes subject_id = '*'.
	HasWildcard bool

	// IsComplex is true if this pattern requires check_permission_internal for membership.
	// This happens when any relation in the closure has TTU, exclusion, or intersection.
	IsComplex bool

	// IsSelfReferential is true if SubjectType == ObjectType and SubjectRelation == Relation.
	// Self-referential usersets (e.g., group.member: [group#member]) require recursive CTEs.
	// Non-self-referential usersets use JOIN-based expansion.
	IsSelfReferential bool
}

type Lit = sqldsl.Lit

type Lt = sqldsl.Lt

type Lte = sqldsl.Lte

type NamedFunction struct {
	Name string
	SQL  string
}

type Ne = sqldsl.Ne

type NoUserset = sqldsl.NoUserset

type NodeJSONArgs struct {
	// Label is a SQL expression for the human-readable description.
	// Wrap literals with sqldsl.QuoteLiteral.
	Label string
	// Evidence, Children, Users should evaluate to JSONB arrays
	// (commonly jsonb_agg(...) or jsonb_build_array(...)).
	Evidence string
	Children string
	Users    string
	// Result is a SQL expression evaluating to a boolean. Populated on
	// Explain nodes; omit on safety-stop nodes (cycle / truncated).
	Result string
}

type NotExists = sqldsl.NotExists

type NotExpr = sqldsl.NotExpr

type NotIn = sqldsl.NotIn

type NotLike = sqldsl.NotLike

type Null = sqldsl.Null

type ObjectRef = sqldsl.ObjectRef

type OrExpr = sqldsl.OrExpr

type Param = sqldsl.Param

type Paren = sqldsl.Paren

type ParentRelationBlock struct {
	LinkingRelation     string
	ParentRelation      string
	AllowedLinkingTypes []string
	Query               SelectStmt
}

type ParentRelationCheck = analysis.ParentRelationCheck

type ParentRelationInfo = analysis.ParentRelationInfo

type PlpgsqlFunction = plpgsql.PlpgsqlFunction

type Position = sqldsl.Position

type QueryBlock = sqldsl.QueryBlock

type Raise = plpgsql.Raise

type Raw = sqldsl.Raw

type RawStmt = plpgsql.RawStmt

type RecursiveBlockSet struct {
	BaseBlocks         []TypedQueryBlock
	RecursiveBlock     *TypedQueryBlock
	SelfCandidateBlock *TypedQueryBlock
	// HoistedCTEs are shared list_*_obj computations lifted out of the base
	// blocks. The same list_<parent>_obj(p_subject_type, p_subject_id, NULL,
	// NULL) call was previously inlined in both the userset-subject arm and the
	// cross-type-TTU subject-first arm; these CTEs compute each distinct call
	// once and the arms reference them. Rendered before the accessible CTE.
	HoistedCTEs []CTEDef
}

type RelationAnalysis = analysis.RelationAnalysis

type RelationDefinition = analysis.RelationDefinition

type RelationFeatures = analysis.RelationFeatures

type Return = plpgsql.Return

type ReturnInt = plpgsql.ReturnInt

type ReturnQuery = plpgsql.ReturnQuery

type ReturnValue = plpgsql.ReturnValue

type SQLer = sqldsl.SQLer

type SelectInto = plpgsql.SelectInto

type SelectIntoVar = sqldsl.SelectIntoVar

type SelectStmt = sqldsl.SelectStmt

type SelfRefUsersetBlockSet struct {
	// BaseBlocks are the base case blocks (depth=0) in the CTE
	BaseBlocks []TypedQueryBlock

	// RecursiveBlock is the recursive term block that expands self-referential usersets
	RecursiveBlock *TypedQueryBlock

	// SelfCandidateBlock is added outside the CTE (UNION with CTE result)
	SelfCandidateBlock *TypedQueryBlock
}

type SelfRefUsersetSubjectsBlockSet struct {
	// UsersetFilterBlocks are blocks for the userset filter path (when p_subject_type contains '#')
	UsersetFilterBlocks []TypedQueryBlock

	// UsersetFilterSelfBlock is the self-candidate block for userset filter path
	UsersetFilterSelfBlock *TypedQueryBlock

	// UsersetFilterRecursiveBlock is the recursive block for userset filter expansion
	UsersetFilterRecursiveBlock *TypedQueryBlock

	// RegularBlocks are blocks for the regular path (individual subjects)
	RegularBlocks []TypedQueryBlock

	// UsersetObjectsBaseBlock is the base block for userset objects CTE
	UsersetObjectsBaseBlock *TypedQueryBlock

	// UsersetObjectsRecursiveBlock is the recursive block for userset objects CTE
	UsersetObjectsRecursiveBlock *TypedQueryBlock
}

type SqlFunction = plpgsql.SqlFunction

type Stmt = plpgsql.Stmt

type Sub = sqldsl.Sub

type SubjectRef = sqldsl.SubjectRef

type SubjectTypeRef = analysis.SubjectTypeRef

type SubjectsIntersectionBlockSet struct {
	RegularCandidateBlocks       []TypedQueryBlock
	UsersetFilterCandidateBlocks []TypedQueryBlock
	UsersetFilterSelfBlock       *TypedQueryBlock
}

type SubjectsRecursiveBlockSet struct {
	RegularBlocks          []TypedQueryBlock
	RegularTTUBlocks       []TypedQueryBlock
	UsersetFilterBlocks    []TypedQueryBlock
	UsersetFilterSelfBlock *TypedQueryBlock
	ParentRelations        []ListParentRelationData
}

type Substring = sqldsl.Substring

type TableExpr = sqldsl.TableExpr

type TableRef = sqldsl.TableRef

type TraceNodeType string

type TupleNotIn = sqldsl.TupleNotIn

type TupleQuery = tuples.TupleQuery

type TypeDefinition = analysis.TypeDefinition

type TypedQueryBlock struct {
	Comments []string
	Query    SelectStmt

	// Propagatable indicates whether results from this block should seed
	// the recursive step in a recursive CTE. Only results from relations
	// that participate in self-referential TTU patterns should propagate.
	// For example, with "can_view: viewer or folder_viewer" where only
	// viewer has "viewer from parent", blocks matching folder_viewer
	// should NOT propagate through the parent chain.
	Propagatable bool
}

type TypedValuesTable = sqldsl.TypedValuesTable

type UnionAll = sqldsl.UnionAll

type UnionSubquery = sqldsl.UnionSubquery

type UsersetNormalized = sqldsl.UsersetNormalized

type UsersetObjectID = sqldsl.UsersetObjectID

type UsersetPattern = analysis.UsersetPattern

type UsersetRelation = sqldsl.UsersetRelation

type ValuesRow = sqldsl.ValuesRow

type ValuesTable = sqldsl.ValuesTable

type WithCTE = sqldsl.WithCTE