wire

type Action struct {
	// Transport selects the attribute dialect. Zero value renders as htmx.
	Transport Transport
	// Method is the HTTP verb. Zero value renders as GET in BOTH dialects
	// (hx-get / @get): an Action literal that omits Method silently turns a
	// write into a read. Set Method explicitly on every mutating action
	// (usually MethodPost); rely on the default only for reads (filters,
	// searches, fragment loads).
	Method Method
	// URL is the exchange endpoint. An empty URL wires nothing (Attributes
	// returns nil) — a component rendered without a backend endpoint must
	// stay inert, not emit a broken binding.
	URL string
	// Event is the triggering DOM event. Zero value uses the dialect default.
	Event Event
	// Target is the region to patch. Under htmx it renders as hx-target.
	// Under Datastar it is intentionally NOT rendered: Datastar v1.0.2 fetch
	// actions accept no target option — targeting is response-driven (see
	// HeaderDatastarSelector) or id-matched (a fragment root whose id equals
	// the target id patches it in the default outer mode). Handlers honor it
	// by echoing the selector back on HeaderDatastarSelector.
	Target string
	// ContentType selects how field values travel to the server. Under
	// Datastar, ContentTypeForm renders {contentType: 'form'} so the action
	// serializes the enclosing form's fields (validation gate, submitter
	// name/value, enctype-aware body); the zero value and ContentTypeJSON use
	// the runtime default (signals as JSON). htmx ignores this field — hx-*
	// requests serialize the enclosing form natively either way.
	ContentType ContentType
	// Selector selects which form serializes under Datastar ContentTypeForm:
	// rendered as the fetch option {selector: '<sel>'}, the runtime resolves
	// the enclosing form via that selector instead of the action element's
	// closest form (bundle-decoded: the option is read ONLY in the
	// form-encoding branch). It does NOT target patches — the pinned runtime
	// reads patch targeting exclusively from the datastar-selector response
	// header (browser-proven 2026-10-02: a client {selector} left a
	// header-less patch inert; see docs/datastar-runtime-facts.md) or from the
	// fragment root's id (outer/replace default). Use wire.Handler(PatchTarget)
	// server-side instead. Empty renders nothing (closest form).
	Selector string
	// Swap is the region-merge style for the exchange — how the response is
	// inserted relative to the target. It reuses the server-side PatchMode
	// vocabulary (the SAME enum as PatchTarget.Mode). Like Target, its effect
	// is transport-asymmetric (ADR-0036): under htmx it renders hx-swap
	// (innerHTML/outerHTML/afterbegin/…) client-side; under Datastar the
	// runtime reads the merge mode EXCLUSIVELY from the datastar-mode response
	// header (browser-proven 2026-10-02: a client {mode} option is ignored —
	// earlier bundles' contrary claim was a string-level misread, corrected in
	// docs/datastar-runtime-facts.md), so Swap renders nothing there and the
	// wire.Handler(PatchTarget.Mode) owns the mode. The zero value renders
	// nothing: htmx's default swap and the wire.Handler default mode are both
	// "inner", so an unspecified Swap behaves identically under both runtimes.
	//
	// Six modes map 1:1 (inner, outer, before, append, prepend, after, and
	// remove ↔ htmx delete); PatchModeReplace (Datastar-only) degrades to the
	// closest htmx style (outerHTML). Unknown values render nothing.
	Swap PatchMode
	// DebounceMS delays the wired exchange until the event has stopped
	// firing for this many milliseconds — the auto-submit filter-input
	// pattern. htmx renders it as the delay:<n>ms trigger modifier (plus
	// `changed` on value events — input, change, keyup — so an unchanged
	// value never re-requests); Datastar renders it as the __debounce.<n>ms
	// event modifier (spelling decoded from the pinned v1.0.3 bundle — see
	// docs/datastar-runtime-facts.md). Zero (the default) emits no debounce.
	// The modifier requires an explicit Event in BOTH dialects: with no
	// event trigger it is dropped (htmx cannot hang a delay on its implicit
	// default trigger; Datastar matches so the modifier never silently
	// re-targets the defaulted click).
	DebounceMS int
	// ThrottleMS bounds the wired exchange to at most one per this many
	// milliseconds — the rate-limit sibling of DebounceMS (throttle fires
	// immediately and then at most once per window; debounce waits for quiet).
	// htmx renders it as the throttle:<n>ms trigger modifier; Datastar as the
	// __throttle.<n>ms attribute-name modifier (bundle-decoded from the pinned
	// v0.6.1 bundle: duration parsing identical to debounce; the runtime's
	// noleading/trailing sub-modifiers are not modeled — the htmx-compatible
	// leading+trailing default is kept). Requires an explicit Event in both
	// dialects, like DebounceMS — an orphan modifier is dropped. htmx
	// documents delay and throttle as mutually
	// exclusive; setting both renders both (Datastar pipelines them
	// delay-then-throttle) — prefer one.
	ThrottleMS int
	// PreventDefault suppresses the triggering event's native default action
	// in the Datastar dialect (the __prevent event modifier). The runtime
	// auto-preventDefaults ONLY form+submit — decoded from the pinned v1.0.3
	// bundle — so a wired <a href> would otherwise BOTH patch and navigate,
	// and a wired submit button would double-submit. Set it on actions wired
	// onto anchors whose href is the no-JS fallback (NavLink, Calendar
	// MonthNav): it is the semantic twin of htmx's automatic interception of
	// hx-* clicks, which is why htmx ignores this field. Do NOT set it on
	// checkbox/radio/change wirings: preventDefault there would cancel the
	// native toggle/commit that htmx keeps.
	PreventDefault bool
	// Interval polls the endpoint on a repeating duration ("10s", "500ms",
	// "2m", "1h") — the polling pattern. NormalizedInterval converts m/h to
	// seconds (both runtimes would misparse them as milliseconds) and an
	// empty Interval means no polling. htmx renders it as the "every <n>"
	// hx-trigger token; Datastar as the data-on-interval__duration.<n>
	// attribute (bundle-decoded grammar). When Interval or Reveal is set and
	// Event is not, no event trigger is rendered — an interval-only Action
	// stays a pure poller instead of also firing on click.
	Interval string
	// Reveal fires the exchange when the element scrolls into view (the
	// lazy-load pattern). Nil (the zero value) means no reveal trigger.
	// htmx renders "revealed" (the zero Reveal) or explicit intersect
	// modifiers; Datastar renders data-on-intersect with its modifier set
	// (bundle-decoded). Reveal.Exit is Datastar-only — htmx degrades to the
	// entry trigger.
	Reveal *Reveal
}

type ContentType string

type Event string

type Method string

type PatchMode string

type PatchTarget struct {
	// Selector is the CSS selector of the patch region, e.g. "#out".
	Selector string
	// Mode is the merge mode. Zero value renders as inner.
	Mode PatchMode
	// UseViewTransitions wraps this patch in the browser's View Transitions
	// API (document.startViewTransition) — the animated same-document
	// cross-fade/slide vocabulary. Response-header driven like everything
	// else: Handler stamps HeaderDatastarUseViewTransition and the runtime
	// turns it into the useViewTransition dataline (bundle-decoded from the
	// pinned v0.6.1 bundle: the header name is the kebab-cased dataline name;
	// the value coerces through a boolean check). It is patch-scoped — per
	// request, not per page — which is the deliberate contrast to htmx's
	// global htmx.ViewTransitions config flag.
	UseViewTransitions bool
}

type Reveal struct {
	// ThresholdPercent is how much of the element must be visible before the
	// trigger fires: 0 (the default) = any part enters the viewport, 50 =
	// half visible, 100 = fully visible. Values are clamped to [0, 100].
	// Datastar renders named modifiers at the special values (50 → half,
	// 100 → full) and threshold.<n> otherwise; htmx renders
	// threshold:<fraction> only when nonzero.
	ThresholdPercent int

	// EveryEntry re-fires the trigger on EVERY viewport entry instead of the
	// zero-value fire-once behavior (htmx "revealed" = intersect once; the
	// Datastar __once modifier is omitted only when this is set).
	EveryEntry bool

	// Exit fires when the element LEAVES the viewport instead of entering.
	// Datastar renders __exit (bundle-verified). htmx has no exit semantics:
	// it degrades to the entry trigger (documented, like PatchModeReplace's
	// degradation) — a leave-only action cannot be expressed under htmx.
	Exit bool
}

type Transport string