doors

type ABlur struct {
	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate the hook is running (e.g., spinner, class, content). Optional.
	Indicator []Indicator

	// On is the required backend handler that runs when the event is triggered.
	//
	// The function receives a typed EventRequest[FocusEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[FocusEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type AChange struct {
	// Mode determines how this hook is scheduled (e.g., blocking, debounce).
	// See ModeDefault, ModeBlock, ModeFrame, etc.
	Scope []Scope

	// Indicator specifies how to visually indicate the hook is running
	// (e.g., by applying a class, attribute, or replacing content). Optional.
	Indicator []Indicator

	// On is the required backend handler for the change event.
	//
	// It receives a typed EventRequest[ChangeEvent] and should return true
	// when the hook is complete and can be removed.
	On func(context.Context, REvent[ChangeEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type AClick struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// PreventDefault, if true, prevents the browser's default action for the event.
	PreventDefault bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate that the hook is running.
	Indicator []Indicator

	// On is the required backend handler for the click event.
	// It receives a typed REvent[PointerEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[PointerEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type AData struct {
	Name  string
	Value any
}

type ADataMap map[string]any

type ADyn interface {
	Attr
	Value(ctx context.Context, value string)
	Enable(ctx context.Context, enable bool)
}

type AFileHref struct {
	Path string
	Once bool
	Name string
}

type AFocus struct {
	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate the hook is running (e.g., spinner, class, content). Optional.
	Indicator []Indicator

	// On is the required backend handler that runs when the event is triggered.
	//
	// The function receives a typed EventRequest[FocusEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[FocusEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type AFocusIn struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate the hook is running (e.g., spinner, class, content). Optional.
	Indicator []Indicator

	// On is the required backend handler that runs when the event is triggered.
	//
	// The function receives a typed EventRequest[FocusEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[FocusEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type AFocusOut struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate the hook is running (e.g., spinner, class, content). Optional.
	Indicator []Indicator

	// On is the required backend handler that runs when the event is triggered.
	//
	// The function receives a typed EventRequest[FocusEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[FocusEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type AGotPointerCapture pointerEventHook

type AHook[I any, O any] struct {
	On        func(ctx context.Context, r RHook[I]) (O, bool)
	Name      string
	Scope     []Scope
	Indicator []Indicator
}

type AHref struct {
	Active          Active
	StopPropagation bool
	Model           any
	Indicator       []Indicator
	OnError         []OnError
}

type AInput struct {
	Scope        []Scope
	Indicator    []Indicator
	On           func(context.Context, REvent[InputEvent]) bool
	ExcludeValue bool
	OnError      []OnError
}

type AKeyDown struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// PreventDefault, if true, prevents the browser's default action for the event.
	PreventDefault bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate that the hook is running.
	Indicator []Indicator

	// On is the required backend handler for the click event.
	// It receives a typed EventRequest[KeyboardEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[KeyboardEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type AKeyUp struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// PreventDefault, if true, prevents the browser's default action for the event.
	PreventDefault bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate that the hook is running.
	Indicator []Indicator

	// On is the required backend handler for the click event.
	// It receives a typed EventRequest[KeyboardEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[KeyboardEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type ALostPointerCapture pointerEventHook

type APointerCancel struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// PreventDefault, if true, prevents the browser's default action for the event.
	PreventDefault bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate that the hook is running.
	Indicator []Indicator

	// On is the required backend handler for the click event.
	// It receives a typed REvent[PointerEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[PointerEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type APointerDown struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// PreventDefault, if true, prevents the browser's default action for the event.
	PreventDefault bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate that the hook is running.
	Indicator []Indicator

	// On is the required backend handler for the click event.
	// It receives a typed REvent[PointerEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[PointerEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type APointerEnter struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// PreventDefault, if true, prevents the browser's default action for the event.
	PreventDefault bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate that the hook is running.
	Indicator []Indicator

	// On is the required backend handler for the click event.
	// It receives a typed REvent[PointerEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[PointerEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type APointerLeave struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// PreventDefault, if true, prevents the browser's default action for the event.
	PreventDefault bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate that the hook is running.
	Indicator []Indicator

	// On is the required backend handler for the click event.
	// It receives a typed REvent[PointerEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[PointerEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type APointerMove struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// PreventDefault, if true, prevents the browser's default action for the event.
	PreventDefault bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate that the hook is running.
	Indicator []Indicator

	// On is the required backend handler for the click event.
	// It receives a typed REvent[PointerEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[PointerEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type APointerOut struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// PreventDefault, if true, prevents the browser's default action for the event.
	PreventDefault bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate that the hook is running.
	Indicator []Indicator

	// On is the required backend handler for the click event.
	// It receives a typed REvent[PointerEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[PointerEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type APointerOver pointerEventHook

type APointerUp struct {
	// StopPropagation, if true, stops the event from bubbling up the DOM.
	StopPropagation bool

	// PreventDefault, if true, prevents the browser's default action for the event.
	PreventDefault bool

	// Scope determines how this hook is scheduled (e.g., blocking, debounce).
	Scope []Scope

	// Indicator specifies how to visually indicate that the hook is running.
	Indicator []Indicator

	// On is the required backend handler for the click event.
	// It receives a typed REvent[PointerEvent] and should return true
	// when the hook is considered complete and can be removed.
	On func(context.Context, REvent[PointerEvent]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type ARawFileHref struct {
	Once    bool
	Name    string
	Handler func(w http.ResponseWriter, r *http.Request)
}

type ARawHook struct {
	Name      string
	On        func(ctx context.Context, r RRawHook) bool
	Scope     []Scope
	Indicator []Indicator
}

type ARawSrc struct {
	Once    bool
	Name    string
	Handler func(w http.ResponseWriter, r *http.Request)
}

type ARawSubmit struct {
	// Mode determines how this hook is scheduled (e.g., blocking, debounce).
	// See ModeDefault, ModeBlock, ModeFrame, etc.
	Scope []Scope

	// Indicator specifies how to visually indicate the hook is running
	// (e.g., by applying a class, attribute, or replacing content). Optional.
	Indicator []Indicator

	// On is the required backend handler for the form submission.
	//
	// It receives a RawFormRequest and should return true (is done)
	// when processing is complete and the hook can be removed.
	On func(context.Context, RRawForm) bool
	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type ASrc struct {
	Path string
	Once bool
	Name string
}

type ASubmit[D any] struct {
	// MaxMemory sets the maximum number of bytes to parse into memory
	// before falling back to temporary files when handling multipart forms.
	//
	// This affects file upload behavior. It is passed to ParseMultipartForm.
	// Defaults to 8 MB if zero.
	MaxMemory int

	// Mode determines how this hook is scheduled (e.g., blocking, debounce).
	// See ModeDefault, ModeBlock, ModeFrame, etc.
	Scope []Scope

	// Indicator specifies how to visually indicate the hook is running
	// (e.g., by applying a class, attribute, or replacing content). Optional.
	Indicator []Indicator

	// On is the required backend handler for the form submission.
	//
	// It receives a typed FormRequest[D] and should return true (is done)
	// when processing is complete and the hook can be removed.
	On func(context.Context, RForm[D]) bool

	// OnError determines what to do if error occured during hook requrest
	OnError []OnError
}

type Active struct {
	PathMatcher  PathMatcher
	QueryMatcher QueryMatcher
	Indicator    []Indicator
}

type After interface {
	// contains filtered or unexported methods
}

type Attr interface {
	Attr() AttrInit
	templ.Component
}

type AttrIndicator struct {
	Selector Selector // Element selector
	Name     string   // Attribute name
	Value    string   // Attribute value
}

type AttrInit = front.Attr

type Attrs = front.Attrs

type Beam[T any] = beam.Beam[T]

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

type CSP = common.CSP

type CallConf struct {
	// Name of the JavaScript call handler  (must be registered on the frontend).
	Name string

	// Arg is the value passed to the frontend function. It is serialized to JSON.
	Arg any

	// On is an optional backend handler that is called with the frontend call responce.
	On func(context.Context, RCall)

	// OnCancel is called if the context becomes invalid before the call is delivered,
	// or if the call is canceled explicitly. Optional.
	OnCancel func(context.Context, error)
}

type CallOnError struct {
	Name string
	Meta any
}

type ChangeEvent = front.ChangeEvent

type ClassIndicator struct {
	Selector Selector // Element selector
	Class    string   // CSS classes to add (space-separated)
}

type ClassRemoveIndicator struct {
	Selector Selector // Element selector
	Class    string   // CSS classes to remove (space-separated)
}

type ContentIndicator struct {
	Selector Selector // Element selector
	Content  string   // Text content to display
}

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

type Door = door.Door

type ESConf = resources.BuildProfiles

type ESOptions struct {
	External []string
	Minify   bool
	JSX      JSX
}

type FocusEvent = front.FocusEvent

type Fragment interface {
	Render() templ.Component
}

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

type HeadData struct {
	Title string
	Meta  map[string]string
}

type HrefActiveMatch int

type Import interface {
	// contains filtered or unexported methods
}

type ImportModule struct {
	Specifier string // Import map specifier name (optional)
	Path      string // File system path to the module
	Profile   string // Build profile for esbuild options
	Load      bool   // Whether to load the module immediately via script tag
	Name      string // Custom name for the generated file (optional)
}

type ImportModuleBundle struct {
	Specifier string // Import map specifier name (optional)
	Entry     string // Entry point file for the bundle
	Profile   string // Build profile for esbuild options
	Load      bool   // Whether to load the module immediately via script tag
	Name      string // Custom name for the generated file (optional)
}

type ImportModuleBundleFS struct {
	CacheKey  string // Unique cache key for this filesystem/bundle combination
	Specifier string // Import map specifier name (optional)
	FS        fs.FS  // File system to read from
	Entry     string // Entry point file within the filesystem
	Profile   string // Build profile for esbuild options
	Load      bool   // Whether to load the module immediately via script tag
	Name      string // Custom name for the generated file (optional)
}

type ImportModuleBytes struct {
	Specifier string // Import map specifier name (optional)
	Content   []byte // Module source code
	Profile   string // Build profile for esbuild options
	Load      bool   // Whether to load the module immediately via script tag
	Name      string // Custom name for the generated file
}

type ImportModuleExternal struct {
	Specifier string // Import map specifier name (optional)
	Load      bool   // Whether to load the module immediately via script tag
	Src       string // External URL to the module
}

type ImportModuleHosted struct {
	Specifier string // Import map specifier name (optional)
	Load      bool   // Whether to load the module immediately via script tag
	Src       string // Full path to the hosted module
}

type ImportModuleRaw struct {
	Specifier string // Import map specifier name (optional)
	Path      string // File system path to the module
	Load      bool   // Whether to load the module immediately via script tag
	Name      string // Custom name for the generated file (optional)
}

type ImportModuleRawBytes struct {
	Specifier string // Import map specifier name (optional)
	Content   []byte // Raw JavaScript content
	Load      bool   // Whether to load the module immediately via script tag
	Name      string // Custom name for the generated file
}

type ImportStyle struct {
	Path string // File system path to the CSS file
	Name string // Custom name for the generated file (optional)
}

type ImportStyleBytes struct {
	Content []byte // CSS source code
	Name    string // Custom name for the generated file
}

type ImportStyleExternal struct {
	Href string // External URL to the stylesheet
}

type ImportStyleHosted struct {
	Href string // Full path to the hosted stylesheet
}

type IndicateOnError struct {
	Duration  time.Duration
	Indicator []Indicator
}

type Indicator = front.Indicator

type InputEvent = front.InputEvent

type JSX struct {
	JSX          api.JSX
	Factory      string
	ImportSource string
	Fragment     string
	SideEffects  bool
	Dev          bool
}

type KeyboardEvent = front.KeyboardEvent

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

type Location = path.Location

type Mod = router.Mod

type Node = Door

type OnError = front.OnError

type Page[M any] interface {
	Render(SourceBeam[M]) templ.Component
}

type PageRoute = router.Response

type PageRouter[M any] interface {
	// Serve page
	Page(page Page[M]) PageRoute
	// Serve page with custom status
	PageStatus(page Page[M], status int) PageRoute
	// Serve func page
	PageFunc(pageFunc func(SourceBeam[M]) templ.Component) PageRoute
	// Serve func page and custom status
	PageFuncStatus(pageFunc func(SourceBeam[M]) templ.Component, status int) PageRoute
	// Serve static page
	StaticPage(content templ.Component) PageRoute
	// Serve static page with custom status
	StaticPageStatus(content templ.Component, status int) PageRoute
	// Internal reroute to different model (detached=true disables path synchronization)
	Reroute(model any, detached bool) PageRoute
	// HTTP redirect to model URL
	Redirect(model any) PageRoute
	// HTTP redirect with custom status
	RedirectStatus(model any, status int) PageRoute
}

type ParsedForm interface {
	FormValues() url.Values                                             // Returns all form values
	FormValue(key string) string                                        // Returns a single form value
	FormFile(key string) (multipart.File, *multipart.FileHeader, error) // Returns an uploaded file
	Form() *multipart.Form                                              // Returns the underlying multipart form
}

type PathMatcher interface {
	// contains filtered or unexported methods
}

type PointerEvent = front.PointerEvent

type QueryMatcher interface {
	// contains filtered or unexported methods
}

type R interface {
	SetCookie(cookie *http.Cookie)
	GetCookie(name string) (*http.Cookie, error)
}

type RAfter interface {
	After(After) error
}

type RCall interface {
	RRawForm
	Body() io.ReadCloser // Returns the request body
	RAfter
}

type REvent[E any] interface {
	R
	Event() E // Returns the event data
	RAfter
}

type RForm[D any] interface {
	R
	Data() D // Returns the parsed form data
	RAfter
}

type RHook[D any] interface {
	R
	Data() D // Returns the hook data
	RAfter
}

type RPage[M any] interface {
	R
	// Returns the decoded URL model
	GetModel() M
	// Access to incoming request headers
	RequestHeader() http.Header
	// Access to outgoing response headers
	ResponseHeader() http.Header
}

type RRawForm interface {
	R
	W() http.ResponseWriter
	Reader() (*multipart.Reader, error)          // Returns a multipart reader for streaming
	ParseForm(maxMemory int) (ParsedForm, error) // Parses form data with memory limit
	RAfter
}

type RRawHook interface {
	RRawForm
	Body() io.ReadCloser // Returns the request body
}

type Router interface {
	http.Handler
	Use(...Mod)
}

type Scope = front.Scope

type ScopeSet = front.ScopeSet

type Selector interface {
	// contains filtered or unexported methods
}

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

type SourceBeam[T any] = beam.SourceBeam[T]

type SystemConf = common.SystemConf