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 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 {
	Subject     SubjectRef
	Relation    string
	Object      ObjectRef
	Visited     Expr // nil uses empty array
	ExpectAllow bool // true compares "= 1", false compares "= 0"
}

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

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

	// 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
}

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 {
	ObjectType        string
	Relation          string
	CheckFunctionName string
}

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
	ExcludedRelation string
	ParentRelation   *ExcludedParentRelation
}

type ExcludedParentRelation struct {
	Relation            string
	LinkingRelation     string
	AllowedLinkingTypes []string
}

type ExclusionConfig struct {
	ObjectType string

	ObjectIDExpr    Expr
	SubjectTypeExpr Expr
	SubjectIDExpr   Expr

	SimpleExcludedRelations  []string
	ComplexExcludedRelations []string
	ExcludedParentRelations  []ExcludedParentRelation
	ExcludedIntersection     []ExcludedIntersectionGroup
}

type Exists = sqldsl.Exists

type Expr = sqldsl.Expr

type Func = sqldsl.Func

type FuncArg = plpgsql.FuncArg

type FuncCallEq = sqldsl.FuncCallEq

type FuncCallNe = sqldsl.FuncCallNe

type FunctionCallExpr = sqldsl.FunctionCallExpr

type GeneratedSQL struct {
	// Functions contains CREATE OR REPLACE FUNCTION statements
	// for each specialized check function.
	Functions []string
	// NoWildcardFunctions contains CREATE OR REPLACE FUNCTION statements
	// for no-wildcard variants of each specialized check function.
	NoWildcardFunctions []string

	// Dispatcher contains the check_permission dispatcher function
	// that routes to specialized functions.
	Dispatcher string

	// DispatcherNoWildcard contains the check_permission_no_wildcard dispatcher.
	DispatcherNoWildcard string
}

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 InFunctionSelect = sqldsl.InFunctionSelect

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
	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 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 {
	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 ListObjectsComplexClosureInput struct {
	ObjectType          string
	Relation            string
	AllowedSubjectTypes []string
	AllowWildcard       bool
	Exclusions          ExclusionConfig
}

type ListObjectsCrossTypeTTUInput struct {
	ObjectType      string
	LinkingRelation string
	Relation        string
	CrossTypes      []string
	Exclusions      ExclusionConfig
}

type ListObjectsDirectInput struct {
	ObjectType          string
	Relations           []string
	AllowedSubjectTypes []string
	AllowWildcard       bool
	Exclusions          ExclusionConfig
}

type ListObjectsRecursiveTTUInput struct {
	ObjectType       string
	LinkingRelations []string
	Exclusions       ExclusionConfig
}

type ListObjectsSelfCandidateInput struct {
	ObjectType    string
	Relation      string
	ClosureValues string      // Deprecated: use ClosureRows
	ClosureRows   []ValuesRow // Typed closure rows (preferred)
}

type ListObjectsUsersetPatternComplexInput struct {
	ObjectType       string
	SubjectType      string
	SubjectRelation  string
	SourceRelations  []string
	IsClosurePattern bool
	SourceRelation   string
	Exclusions       ExclusionConfig
}

type ListObjectsUsersetPatternSimpleInput struct {
	ObjectType          string
	SubjectType         string
	SubjectRelation     string
	SourceRelations     []string
	SatisfyingRelations []string
	AllowedSubjectTypes []string
	AllowWildcard       bool
	IsClosurePattern    bool
	SourceRelation      string
	Exclusions          ExclusionConfig
}

type ListObjectsUsersetSubjectInput struct {
	ObjectType    string
	Relations     []string
	ClosureValues string      // Deprecated: use ClosureRows
	ClosureRows   []ValuesRow // Typed closure rows (preferred)
	Exclusions    ExclusionConfig
}

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
}

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

	// 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 wildcards are allowed (list_objects)
	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)
}

type ListStrategy = analysis.ListStrategy

type ListSubjectsComplexClosureInput struct {
	ObjectType      string
	Relation        string
	ObjectIDExpr    Expr
	SubjectTypeExpr Expr
	ExcludeWildcard bool
	Exclusions      ExclusionConfig
}

type ListSubjectsDirectInput struct {
	ObjectType      string
	RelationList    []string
	ObjectIDExpr    Expr
	SubjectTypeExpr Expr
	ExcludeWildcard bool
	Exclusions      ExclusionConfig
}

type ListSubjectsSelfCandidateInput struct {
	ObjectType         string
	Relation           string
	ObjectIDExpr       Expr
	FilterTypeExpr     Expr
	FilterRelationExpr Expr
	ClosureValues      string      // Deprecated: use ClosureRows
	ClosureRows        []ValuesRow // Typed closure rows (preferred)
	ExtraPredicatesSQL []string    // Raw SQL predicate strings
}

type ListSubjectsUsersetFilterInput struct {
	ObjectType          string
	RelationList        []string
	AllowedSubjectTypes []string
	ObjectIDExpr        Expr
	FilterTypeExpr      Expr
	FilterRelationExpr  Expr
	ClosureValues       string      // Deprecated: use ClosureRows
	ClosureRows         []ValuesRow // Typed closure rows (preferred)
	UseTypeGuard        bool
	ExtraPredicatesSQL  []string // Raw SQL predicate strings
}

type ListSubjectsUsersetPatternComplexInput struct {
	ObjectType       string
	SubjectType      string
	SubjectRelation  string
	SourceRelations  []string
	ObjectIDExpr     Expr
	SubjectTypeExpr  Expr
	IsClosurePattern bool
	SourceRelation   string
	Exclusions       ExclusionConfig
}

type ListSubjectsUsersetPatternRecursiveComplexInput struct {
	ObjectType          string
	SubjectType         string
	SubjectRelation     string
	SourceRelations     []string
	ObjectIDExpr        Expr
	SubjectTypeExpr     Expr
	AllowedSubjectTypes []string
	ExcludeWildcard     bool
	IsClosurePattern    bool
	SourceRelation      string
	Exclusions          ExclusionConfig
}

type ListSubjectsUsersetPatternSimpleInput struct {
	ObjectType          string
	SubjectType         string
	SubjectRelation     string
	SourceRelations     []string
	SatisfyingRelations []string
	ObjectIDExpr        Expr
	SubjectTypeExpr     Expr
	AllowedSubjectTypes []string
	ExcludeWildcard     bool
	IsClosurePattern    bool
	SourceRelation      string
	Exclusions          ExclusionConfig
}

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 Ne = sqldsl.Ne

type NoUserset = sqldsl.NoUserset

type NotExists = sqldsl.NotExists

type NotExpr = sqldsl.NotExpr

type NotIn = sqldsl.NotIn

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
	SelfRefLinkingRelations []string
}

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 SubstringUsersetRelation = sqldsl.SubstringUsersetRelation

type TableExpr = sqldsl.TableExpr

type TableRef = sqldsl.TableRef

type TupleQuery = tuples.TupleQuery

type TypeDefinition = analysis.TypeDefinition

type TypedQueryBlock struct {
	Comments []string
	Query    SelectStmt
}

type TypedValuesTable = sqldsl.TypedValuesTable

type UnionAll = sqldsl.UnionAll

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