doors

type ABlur struct {
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[FocusEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestFocus) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type AChange struct {
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[ChangeEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestChange) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type AClick struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[PointerEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestPointer) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type AData struct {
	// Name of the data entry to read via JavaScript with $data(name).
	// Required.
	Name string
	// Value to expose to the client. Marshaled to JSON.
	// Required.
	Value any
}

type AFocus struct {
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[FocusEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestFocus) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type AFocusIn struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[FocusEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestFocus) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type AFocusOut struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[FocusEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestFocus) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type AGotPointerCapture struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[PointerEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestPointer) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type AHook[T any] struct {
	// Name of the hook to call from JavaScript via $hook(name, ...).
	// Required.
	Name string
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Backend handler for the hook.
	// Receives typed input (T, unmarshaled from JSON) through RequestHook,
	// and returns any output which will be marshaled to JSON.
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(ctx context.Context, r RequestHook[T]) (any, bool)
}

type AInput struct {
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[InputEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestInput) bool
	// If true, does not include value in event
	// Optional.
	ExcludeValue bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type AKeyDown struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Filters by event.key if provided.
	// Optional.
	Filter []string
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Backend event handler.
	// Receives a typed RequestEvent[KeyboardEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestKeyboard) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
	// Actions to run before the hook request.
	// Optional.
	Before Actions
}

type AKeyUp struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Filters by event.key if provided.
	// Optional.
	Filter []string
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Backend event handler.
	// Receives a typed RequestEvent[KeyboardEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestKeyboard) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
	// Actions to run before the hook request.
	// Optional.
	Before Actions
}

type ALink struct {
	// Target path model value. Required.
	Model any
	// Fragment identifier. Optional.
	Fragment string
	// Active link indicator configuration. Optional.
	Active Active
	// Stop event propagation (for dynamic links). Optional.
	StopPropagation bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running. Optional.
	Indicator Indicators
	// Actions to run before the hook request. Optional.
	Before Actions
	// Actions to run after the hook request. Optional.
	After Actions
	// Actions to run on error.
	// Default (nil) triggers a location reload.
	OnError Actions
}

type ALostPointerCapture struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[PointerEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestPointer) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type APointerCancel struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[PointerEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestPointer) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type APointerDown struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[PointerEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestPointer) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type APointerEnter struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[PointerEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestPointer) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type APointerLeave struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[PointerEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestPointer) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type APointerMove struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[PointerEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestPointer) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type APointerOut struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[PointerEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestPointer) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type APointerOver struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[PointerEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestPointer) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type APointerUp struct {
	// If true, stops the event from bubbling up the DOM.
	// Optional.
	StopPropagation bool
	// If true, prevents the browser's default action for the event.
	// Optional.
	PreventDefault bool
	// If true, only fires when the event occurs on this element itself.
	// Optional.
	ExactTarget bool
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend event handler.
	// Receives a typed RequestEvent[PointerEvent].
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestPointer) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type ARawHook struct {
	// Name of the hook to call from JavaScript via $hook(name, ...).
	// Required.
	Name string
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Backend handler for the hook.
	// Provides raw access via RRawHook (body reader, multipart parser).
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(ctx context.Context, r RequestRawHook) bool
}

type ARawSubmit struct {
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend form handler.
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestRawForm) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

type AShared = *aShared

type ASubmit[T any] struct {
	// MaxMemory sets the maximum number of bytes to parse into memory.
	// It is passed to ParseMultipartForm.
	// Defaults to 8 MB if zero.
	MaxMemory int
	// Defines how the hook is scheduled (e.g. blocking, debounce).
	// Optional.
	Scope Scopes
	// Visual indicators while the hook is running.
	// Optional.
	Indicator Indicators
	// Actions to run before the hook request.
	// Optional.
	Before Actions
	// Backend form handler.
	// Should return true when the hook is complete and can be removed.
	// Required.
	On func(context.Context, RequestForm[T]) bool
	// Actions to run on error.
	// Optional.
	OnError Actions
}

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

type ActionEmit struct {
	Name string
	Arg  any
}

type ActionIndicate struct {
	Indicator Indicators
	Duration  time.Duration
}

type ActionLocationAssign struct {
	Model any
}

type ActionLocationRawAssign struct {
	URL string
}

type ActionLocationReload struct{}

type ActionLocationReplace struct {
	Model any
}

type ActionScroll struct {
	// CSS selector for the element to scroll into view.
	Selector string
	// Browser scroll options forwarded to `scrollIntoView(...)`.
	Options any
}

type Actions interface {
	// Actions returns the flattened action list.
	Actions() []Action
	Joiner[Actions]
}

type Active struct {
	// PathMatcher controls path matching. Defaults to [PathMatcherFull].
	PathMatcher PathMatcher
	// QueryMatcher controls query matching. Matchers are applied sequentially;
	// any remaining parameters are compared after the configured matcher chain.
	QueryMatcher QueryMatcher
	// FragmentMatch includes the URL fragment in active matching.
	FragmentMatch bool
	// Indicator is applied to the link while it matches the current location.
	Indicator Indicators
}

type App interface {
	// Use appends middleware around the app handler.
	Use(middleware ...Use)
	http.Handler
}

type Attr interface {
	gox.Modify
	gox.Proxy
}

type Beam[T any] interface {
	// Effect returns the current value and rerenders the closest dynamic parent
	// when the value changes.
	Effect(ctx context.Context) (T, bool)

	// Bind renders f with the current value and rerenders that fragment when
	// the value changes.
	Bind(func(T) gox.Elem) gox.EditorComp

	// RouteBeam returns a renderable component that renders the first matching
	// read-only route for this beam.
	RouteBeam(routes ...RouteBeam[T]) gox.EditorComp

	// Sub subscribes to the value stream. onValue is called immediately with the
	// current value in the same goroutine, and again on every update.
	//
	// The subscription continues until:
	//   - onValue returns true, or
	//   - a dynamic parent is unmounted.
	//
	// It returns false if the context was already canceled or does not belong to
	// an instance runtime.
	Sub(ctx context.Context, onValue func(context.Context, T) bool) bool

	// Read returns the current value without creating a subscription.
	//
	// It returns false if the context was canceled or does not belong to an
	// instance runtime.
	Read(ctx context.Context) (T, bool)

	// ReadAndSub returns the current value and then subscribes to future
	// updates. onValue is called only for subsequent updates.
	//
	// It returns false if the context was canceled or does not belong to an
	// instance runtime.
	ReadAndSub(ctx context.Context, onValue func(context.Context, T) bool) (T, bool)

	// Watch attaches a low-level watcher for separate init, update, and
	// cancellation callbacks.
	Watch(ctx context.Context, w Watcher[T]) (context.CancelFunc, bool)

	// Get returns the most recently stored value without requiring a runtime
	// context.
	//
	// Unlike [Beam.Read], Get does not participate in render-cycle consistency
	// guarantees. Use Read when consistency across the component tree matters.
	Get() T
	// contains filtered or unexported methods
}

type CSP = common.CSP

type CallResult[T any] struct {
	Ok  T     // Result value
	Err error // Error if the call failed
}

type ChangeEvent = front.ChangeEvent

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

type Conf = common.Conf

type DeriveRoute[T1, T2 any] struct {
	// contains filtered or unexported fields
}

type Door = door.Door

type ESProfile struct {
	// External lists module specifiers that esbuild should leave external.
	External []string
	// Minify enables esbuild syntax, whitespace, and identifier minification.
	Minify bool
	// JSX configures JSX transformation.
	JSX JSX
}

type ErrorPage = app.ErrorPage

type FocusEvent = front.FocusEvent

type Indicator = front.Indicator

type IndicatorAttr struct {
	Selector Selector // Target element
	Name     string   // Attribute name
	Value    string   // Attribute value
}

type IndicatorClass struct {
	Selector Selector // Target element
	Class    string   // Space-separated classes
}

type IndicatorClassRemove struct {
	Selector Selector // Target element
	Class    string   // Space-separated classes
}

type IndicatorContent struct {
	Selector Selector // Target element
	Content  string   // Replacement content
}

type Indicators interface {
	Indicators() []Indicator
	Joiner[Indicators]
}

type InputEvent = front.InputEvent

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

type Joiner[T any] interface {
	// And returns a value that applies the receiver followed by T.
	And(T) T
}

type KeyboardEvent = front.KeyboardEvent

type Location = path.Location

type LocationEncoder = path.Encoder

type MatchRoute[T any] struct {
	// contains filtered or unexported fields
}

type ParsedForm interface {
	// FormValues returns all parsed form values.
	FormValues() url.Values
	// FormValue returns the first value for the given key.
	FormValue(key string) string
	// FormFile returns the uploaded file for the given key.
	FormFile(key string) (multipart.File, *multipart.FileHeader, error)
	// Form returns the underlying multipart.Form.
	Form() *multipart.Form
}

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

type PointerEvent = front.PointerEvent

type QueryMatcher interface {
	Joiner[QueryMatcher]
	// contains filtered or unexported methods
}

type Request interface {
	RequestCommon
	// RequestHeader returns the incoming request headers.
	RequestHeader() http.Header
	// ResponseHeader returns the outgoing response headers.
	ResponseHeader() http.Header
}

type RequestAfter interface {
	// After appends client-side actions to the successful response.
	After(a Actions) error
}

type RequestChange = RequestEvent[ChangeEvent]

type RequestCommon interface {
	// SetCookie adds a cookie to the response.
	SetCookie(cookie *http.Cookie)
	// GetCookie retrieves a cookie by name.
	GetCookie(name string) (*http.Cookie, error)
	// Context returns the underlying HTTP request context.
	// It is not the Doors runtime context passed to handlers.
	Context() context.Context
}

type RequestEvent[E any] interface {
	RequestCommon
	RequestAfter
	// Event returns the event payload.
	Event() E
}

type RequestFocus = RequestEvent[FocusEvent]

type RequestForm[D any] interface {
	RequestCommon
	RequestAfter
	// Data returns the parsed form payload.
	Data() D
}

type RequestHook[D any] interface {
	RequestCommon
	RequestAfter
	// Data returns the parsed hook payload.
	Data() D
}

type RequestInput = RequestEvent[InputEvent]

type RequestKeyboard = RequestEvent[KeyboardEvent]

type RequestPointer = RequestEvent[PointerEvent]

type RequestRawForm interface {
	RequestCommon
	RequestAfter
	// ResponseWriter returns the HTTP response writer.
	ResponseWriter() http.ResponseWriter
	// Reader returns a multipart reader for streaming form parts.
	Reader() (*multipart.Reader, error)
	// ParseForm parses the form data with a memory limit.
	ParseForm(maxMemory int) (ParsedForm, error)
}

type RequestRawHook interface {
	RequestRawForm
	// Body returns the raw request body reader.
	Body() io.ReadCloser
}

type Resource = printer.SourceHandler

type ResourceExternal = printer.SourceExternal

type ResourceStatic = printer.SourceStatic

type RouteBeam[T1 any] interface {
	RouteSource[T1]
	// contains filtered or unexported methods
}

type RouteSource[T1 any] interface {
	// contains filtered or unexported methods
}

type Scope = front.Scope

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

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

type ScopeDebounce struct {
	// Duration is the quiet period before a request is sent.
	Duration time.Duration
	// Limit is the maximum delay before a pending request must be sent.
	Limit time.Duration
	// contains filtered or unexported fields
}

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

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

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

type Scopes interface {
	// Scopes returns the low-level client scopes for this app core.
	Scopes(core core.Core) []Scope
	Joiner[Scopes]
}

type Selector = front.Selector

type SessionTracker = app.SessionTracker

type Source[T any] interface {
	Beam[T]

	// RouteSource returns a renderable component that renders the first matching
	// writable route for this source.
	RouteSource(routes ...RouteSource[T]) gox.EditorComp

	// Update sets a new value and propagates it to subscribers and derived
	// beams through the underlying source. Any context is allowed.
	Update(context.Context, T)

	// XUpdate behaves like [Source.Update] and returns a channel that reports
	// when propagation has finished.
	//
	// The channel receives nil on successful propagation or an error if the
	// context is invalid or the instance ends before propagation finishes. Do
	// not wait on it during rendering. If you need to wait, use [Go] or your
	// own goroutine with [Free].
	XUpdate(context.Context, T) <-chan error

	// Mutate computes the next value from the current value and propagates it
	// through the underlying source. The function receives a copy of the
	// current value and must return the next value. Returning an unchanged copy
	// is a no-op when the underlying source treats the resulting parent value as
	// equal. Any context is allowed.
	Mutate(context.Context, func(T) T)

	// XMutate behaves like [Source.Mutate] and returns a channel that reports
	// when propagation has finished.
	//
	// The channel receives nil on successful propagation or an error if the
	// context is invalid or the instance ends before propagation finishes. Do
	// not wait on it during rendering. If you need to wait, use [Go] or your
	// own goroutine with [Free].
	XMutate(context.Context, func(T) T) <-chan error
	// contains filtered or unexported methods
}

type Store = ctex.Store

type Use = func(http.Handler) http.Handler

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

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