-spec each(Fun, Source) -> no_return() when Fun :: fun(), Source :: term().

Parse transform stub. The parse transform replaces az:each(Fun, Source) with compiled iteration code; this runtime body is only reached if the parse transform did not run, in which case it errors with parse_transform_not_applied like the other stubs.

-spec get(Key, Bindings) -> term() when Key :: term(), Bindings :: map().

Alias for arizona_template:get/2.

-spec get(Key, Bindings, Default) -> term() when Key :: term(), Bindings :: map(), Default :: term().

Alias for arizona_template:get/3.

-spec get_lazy(Key, Bindings, DefaultFun) -> term()
                  when Key :: term(), Bindings :: map(), DefaultFun :: fun(() -> term()).

Alias for arizona_template:get_lazy/3.

-spec html(term()) -> no_return().

Parse transform stub. Calling this at runtime errors -- the parse transform replaces az:html(...) (or arizona_template:html(...)) calls with compiled template maps before code generation.

-spec inner_content(Bindings) -> term() when Bindings :: map().

Returns the inner_content binding from a layout's bindings map -- the rendered page this layout wraps. Used by stateless layout modules, normally through the ?inner_content macro, to place the wrapped page content.

Opaque, and it goes in a content slot whole. The value is a nested template (#{s := [Page], d := []}) -- not iodata, not a binary. That is what lets a content slot splice the page verbatim instead of copying and UTF-8-re-decoding it once per layout layer.

Placements that work, whether the slot is the layout's own or one it hands the page on to (the page renders as itself, unescaped, in all of them):

?html([~"<main>", ?inner_content, ~"</main>"])                      %% the slot
?html([case Hide of true -> ~""; false -> ?inner_content end])      %% a case tail
?html([?stateless(fun body/1, #{content => ?inner_content})])       %% a child's prop

Placements that raise, because the value is opaque:

• an attribute value -- bad_template_value, carrying the whole page in the error term (a rendered page inside an attribute has no meaning);
• measured or inspected -- iolist_size(az:inner_content(Bindings)) raises badarg, as does anything else expecting iodata;
• wrapped in ?raw/1 -- bad_template_value. There is nothing to opt out of: a content slot already splices the page unescaped, so ?raw(?inner_content) is redundant. Drop the wrapper;
• inside a list the template cannot see -- a comprehension, or a list built at runtime, is one opaque value and raises. A literal content-slot list such as [~"<hr>", ?inner_content] is fine: it compiles as a fragment, so the page gets a slot of its own.

The value stays opaque rather than paying the per-layer copy that would make those degrade quietly.

Errors with {badkey, inner_content} when the bindings carry no page, i.e. when the module was rendered as something other than a layout.

-spec local(Key, Init) -> map() when Key :: binary() | atom(), Init :: term().

Alias for arizona_template:local/2.

-spec native(term()) -> no_return().

Parse transform stub. The parse transform replaces az:native(...) (or arizona_template:native(...)) calls with compiled JSON template maps before code generation.

-spec raw(Value) -> {arizona_raw, term()} when Value :: term().

Alias for arizona_template:raw/1.

-spec stateful(Handler, Props) -> arizona_template:stateful_descriptor()
                  when Handler :: module(), Props :: map().

Alias for arizona_template:stateful/2.

-spec stateless(Callback, Props) -> arizona_template:stateless_descriptor()
                   when Callback :: fun((map()) -> arizona_template:template()), Props :: map().

Alias for arizona_template:stateless/2.

-spec stateless(Handler, Fun, Props) -> arizona_template:stateless_descriptor()
                   when Handler :: module(), Fun :: atom(), Props :: map().

Alias for arizona_template:stateless/3.

-spec terminal(term()) -> no_return().

Parse transform stub. The parse transform replaces az:terminal(...) (or arizona_template:terminal(...)) calls with compiled ANSI template maps before code generation.

-spec track(Key) -> ok when Key :: term().

Alias for arizona_template:track/1.

-spec with(Keys, Bindings) -> map() when Keys :: [term()], Bindings :: map().

Alias for arizona_template:with/2.