router

type APIEndpoint struct {
	Path         string
	Method       string
	FuncName     string
	Package      string
	Description  string
	Params       []ParamDef
	RequestType  *TypeInfo
	ResponseType *TypeInfo
}

type APIHandler func(ctx server.Ctx, params any, body any) (any, error)

type CanonicalizeResult = routepath.CanonicalizeResult

type ErrorHandler func(ctx server.Ctx, err error) *vdom.VNode

type FieldInfo struct {
	Name     string
	Type     string
	JSONName string
	Required bool
}

type FileDiff struct {
	// Path is the relative path to the file
	Path string `json:"path"`

	// Status is one of: "missing", "changed"
	Status string `json:"status"`
}

type GenerationResult struct {
	// OutputFile is the path to the generated file
	OutputFile string `json:"outputFile"`

	// RouteCount is the total number of routes discovered
	RouteCount int `json:"routeCount"`

	// PageCount is the number of page routes
	PageCount int `json:"pageCount"`

	// APICount is the number of API routes
	APICount int `json:"apiCount"`

	// LayoutCount is the number of layouts
	LayoutCount int `json:"layoutCount"`

	// MiddlewareCount is the number of middleware registrations
	MiddlewareCount int `json:"middlewareCount"`
}

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

type GeneratorConfig struct {
	// RoutesDir is the directory to scan for route files (e.g., "app/routes")
	RoutesDir string

	// ModulePath is the Go module path (e.g., "github.com/example/myapp")
	ModulePath string

	// OutputPath is the output file path (default: {RoutesDir}/routes_gen.go)
	OutputPath string
}

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

type Handler func(ctx server.Ctx) error

type HandlerFunc = Handler

type HandlerRegistry struct {
	Pages   map[string]PageHandler
	Layouts map[string]LayoutHandler
	APIs    map[string]map[string]APIHandler // path -> method -> handler
	MW      map[string][]Middleware
}

type LayoutHandler func(ctx server.Ctx, children Slot) *vdom.VNode

type MatchResult struct {
	// PageHandler is the handler for page routes
	PageHandler PageHandler

	// APIHandler is the handler for API routes
	APIHandler APIHandler

	// Layouts are hierarchical layouts collected from app.Layout() calls (root to leaf)
	Layouts []LayoutHandler

	// PageLayouts are explicit layouts from app.Page(..., layouts)
	// These are NOT inherited - they replace hierarchical layouts when HasPageLayouts is true
	PageLayouts []LayoutHandler

	// HasPageLayouts distinguishes "unset" vs "explicitly empty"
	// When true, PageLayouts should be used instead of Layouts
	HasPageLayouts bool

	// Middleware is the combined middleware chain
	Middleware []Middleware

	// Params are the extracted route parameters
	Params map[string]string

	// Route is the matched route definition
	Route *ScannedRoute

	// MethodNotAllowed indicates the path matched an API route, but the requested
	// method did not match any registered handler.
	MethodNotAllowed bool

	// AllowedMethods is the set of allowed HTTP methods for the matched API path.
	// Only meaningful when MethodNotAllowed is true.
	AllowedMethods []string
}

type Middleware interface {
	// Handle processes the request and optionally calls next.
	// Return an error to stop the chain and report an error.
	// Return nil without calling next to stop the chain without error.
	Handle(ctx server.Ctx, next func() error) error
}

type MiddlewareFunc func(ctx server.Ctx, next func() error) error

type MultiValidationError struct {
	Errors []ValidationError
}

type NavigateOption func(*NavigateOptions)

type NavigateOptions struct {
	// Replace replaces the current history entry instead of pushing.
	Replace bool

	// Params are query parameters to add to the URL.
	Params map[string]any

	// Scroll controls whether to scroll to top after navigation.
	// Defaults to true.
	Scroll bool

	// Prefetch indicates this path should be prefetched.
	Prefetch bool
}

type NavigationRequest struct {
	Path    string
	Options NavigateOptions
}

type Navigator interface {
	// Navigate performs a client-side navigation to the given path.
	Navigate(path string, opts ...NavigateOption)

	// Back navigates back in browser history.
	Back()

	// Forward navigates forward in browser history.
	Forward()
}

type OpenAPIComponents struct {
	Schemas map[string]*OpenAPISchema `json:"schemas,omitempty"`
}

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

type OpenAPIInfo struct {
	Title       string
	Description string
	Version     string
}

type OpenAPIMediaType struct {
	Schema *OpenAPISchema `json:"schema,omitempty"`
}

type OpenAPIOperation struct {
	Summary     string                     `json:"summary,omitempty"`
	Description string                     `json:"description,omitempty"`
	OperationID string                     `json:"operationId,omitempty"`
	Tags        []string                   `json:"tags,omitempty"`
	Parameters  []OpenAPIParameter         `json:"parameters,omitempty"`
	RequestBody *OpenAPIRequestBody        `json:"requestBody,omitempty"`
	Responses   map[string]OpenAPIResponse `json:"responses"`
}

type OpenAPIParameter struct {
	Name        string         `json:"name"`
	In          string         `json:"in"` // path, query, header
	Description string         `json:"description,omitempty"`
	Required    bool           `json:"required,omitempty"`
	Schema      *OpenAPISchema `json:"schema"`
}

type OpenAPIPath map[string]*OpenAPIOperation

type OpenAPIRequestBody struct {
	Description string                      `json:"description,omitempty"`
	Required    bool                        `json:"required,omitempty"`
	Content     map[string]OpenAPIMediaType `json:"content"`
}

type OpenAPIResponse struct {
	Description string                      `json:"description"`
	Content     map[string]OpenAPIMediaType `json:"content,omitempty"`
}

type OpenAPISchema struct {
	Type       string                    `json:"type,omitempty"`
	Format     string                    `json:"format,omitempty"`
	Items      *OpenAPISchema            `json:"items,omitempty"`
	Properties map[string]*OpenAPISchema `json:"properties,omitempty"`
	Required   []string                  `json:"required,omitempty"`
	Ref        string                    `json:"$ref,omitempty"`
}

type OpenAPISpec struct {
	OpenAPI    string                 `json:"openapi"`
	Info       OpenAPISpecInfo        `json:"info"`
	Paths      map[string]OpenAPIPath `json:"paths"`
	Components *OpenAPIComponents     `json:"components,omitempty"`
}

type OpenAPISpecInfo struct {
	Title       string `json:"title"`
	Description string `json:"description,omitempty"`
	Version     string `json:"version"`
}

type PageHandler func(ctx server.Ctx, params any) vdom.Component

type PageMeta struct {
	Title       string
	Description string
	Keywords    []string
	OGImage     string
	OGTitle     string
	OGDesc      string
	Canonical   string
	Robots      string
}

type ParamDef struct {
	// Name is the parameter name (e.g., "id")
	Name string

	// Type is the parameter type (e.g., "int", "string", "uuid")
	Type string

	// ExplicitType is the explicit type annotation from the route segment, if any.
	// Example: "[id:int]" -> "int". Empty means the type was inferred by convention.
	ExplicitType string

	// Segment is the original segment (e.g., "[id]", "[id:int]")
	Segment string
}

type ParamParser struct{}

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

type RouteOption func(*routeOptions)

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

type RouterAdapter struct {
	*Router
}

type ScanOptions struct {
	// Validate enables route validation (duplicate detection, constraint conflicts, etc.)
	Validate bool

	// Sort enables specificity sorting (static > typed > plain > catch-all)
	Sort bool
}

type ScannedRoute struct {
	// Path is the URL pattern (e.g., "/projects/:id")
	Path string

	// FilePath is the source file path
	FilePath string

	// Package is the Go package name
	Package string

	// Params are the route parameters
	Params []ParamDef

	// ParamStructTypes maps route param name -> canonical type derived from the
	// handler's params struct (when available). Used for validation.
	ParamStructTypes map[string]string

	// HasPage indicates the file exports a page handler function (e.g., IndexPage)
	HasPage bool

	// HandlerName is the actual name of the page handler function (e.g., "IndexPage", "ShowPage")
	HandlerName string

	// HasLayout indicates the file exports a Layout function
	HasLayout bool

	// HasMeta indicates the file exports a Meta function
	HasMeta bool

	// HasMiddleware indicates the file exports a Middleware variable or function
	HasMiddleware bool

	// MiddlewareIsFunc indicates the route exports a Middleware() function.
	MiddlewareIsFunc bool

	// MiddlewareIsVar indicates the route exports a Middleware variable.
	MiddlewareIsVar bool

	// Methods lists HTTP methods for API routes (GET, POST, etc.)
	Methods []string

	// APIHandlers maps HTTP method to the exported Go function name.
	// Example: {"GET": "GET"} or {"GET": "HealthGET"}.
	APIHandlers map[string]string

	// IsAPI indicates this is an API route (returns JSON)
	IsAPI bool

	// IsCatchAll indicates this is a catch-all route ([...slug])
	IsCatchAll bool
}

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

type Slot = corevango.Slot

type TypeInfo struct {
	Name      string
	Package   string
	Fields    []FieldInfo
	IsSlice   bool
	IsPointer bool
}

type ValidationError struct {
	// Type is the error category
	Type ValidationErrorType

	// Message is the human-readable error message
	Message string

	// Files are the source files involved
	Files []string

	// Path is the conflicting URL pattern
	Path string

	// Details contains additional error-specific information
	Details string
}

type ValidationErrorType string

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

type VerifyResult struct {
	// Current is true if the generated routes match the existing file
	Current bool `json:"current"`

	// Differences lists files that differ from expected
	Differences []FileDiff `json:"differences,omitempty"`
}