ssevents

-module(ssevents).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/ssevents.gleam").
-export([default_limits/0, name_of/1, data_of/1, id_of/1, retry_of/1, event/2, new/1, from_parts/4, message/1, named/2, id/2, event_checked/2, id_checked/2, named_checked/2, comment_checked/1, retry/2, retry_clamp/2, data/2, event_item/1, heartbeat/0, comment/1, is_event/1, is_comment/1, event_of_item/1, comment_text_of_item/1, events_of/1, comment_texts_of/1, default_line_ending/0, encode/1, encode_bytes/1, encode_item/1, encode_item_bytes/1, encode_items/1, encode_items_bytes/1, encode_with_line_ending/2, encode_item_with_line_ending/2, encode_items_with_line_ending/2, decode/1, decode_bytes/1, decode_with_limits/2, decode_bytes_with_limits/2, new_decoder/0, new_decoder_with_limits/1, push/2, finish/1, limits/0, new_limits/4, max_line_bytes/1, max_event_bytes/1, max_event_size/1, with_max_event_size/2, max_data_lines/1, max_retry_value/1, strict_retry_cap/1, with_strict_retry_cap/2, validate_event_name/1, validate_id/1, validate_retry/1, max_data_bytes/2, new_reconnect_state/0, update_reconnect/2, last_event_id/1, retry_interval/1, last_event_id_header/1, empty_iterator/0, iterator_from_list/1, iterator_to_list/1, iterator_next/1, encode_stream/1, decode_stream/1, decode_stream_with_limits/2, error_to_string/1, content_type/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " Canonical public surface for the `ssevents` package.\n"
    "\n"
    " The focused modules (`ssevents/event`, `ssevents/encoder`,\n"
    " `ssevents/decoder`, `ssevents/reconnect`, `ssevents/validate`,\n"
    " `ssevents/limit`, `ssevents/heartbeat`, `ssevents/stream`,\n"
    " `ssevents/error`) carry the actual implementation, but they are an\n"
    " implementation detail: external code should prefer the spellings\n"
    " re-exported here. This is the surface the README and the published\n"
    " HexDocs documentation consider authoritative, and it is the surface\n"
    " that follows semver — the submodule shapes may be reorganized\n"
    " between releases.\n"
    "\n"
    " Reach into a submodule directly only when the facade does not yet\n"
    " expose what you need; in that case, opening an issue so the\n"
    " missing entry point can be added at this level is preferred to\n"
    " scattering submodule imports across user code.\n"
).

-file("src/ssevents.gleam", 69).
-spec default_limits() -> ssevents@limit:limits().
default_limits() ->
    ssevents@limit:default().

-file("src/ssevents.gleam", 94).
-spec name_of(ssevents@event:event()) -> gleam@option:option(binary()).
name_of(Event) ->
    ssevents@event:name_of(Event).

-file("src/ssevents.gleam", 98).
-spec data_of(ssevents@event:event()) -> binary().
data_of(Event) ->
    ssevents@event:data_of(Event).

-file("src/ssevents.gleam", 102).
-spec id_of(ssevents@event:event()) -> gleam@option:option(binary()).
id_of(Event) ->
    ssevents@event:id_of(Event).

-file("src/ssevents.gleam", 106).
-spec retry_of(ssevents@event:event()) -> gleam@option:option(integer()).
retry_of(Event) ->
    ssevents@event:retry_of(Event).

-file("src/ssevents.gleam", 110).
-spec event(ssevents@event:event(), binary()) -> ssevents@event:event().
event(Event, Name) ->
    ssevents@event:event(Event, Name).

-file("src/ssevents.gleam", 73).
-spec new(binary()) -> ssevents@event:event().
new(Data) ->
    ssevents@event:new(Data).

-file("src/ssevents.gleam", 77).
-spec from_parts(
    gleam@option:option(binary()),
    binary(),
    gleam@option:option(binary()),
    gleam@option:option(integer())
) -> ssevents@event:event().
from_parts(Event_name, Data, Id, Retry) ->
    ssevents@event:from_parts(Event_name, Data, Id, Retry).

-file("src/ssevents.gleam", 86).
-spec message(binary()) -> ssevents@event:event().
message(Data) ->
    ssevents@event:message(Data).

-file("src/ssevents.gleam", 90).
-spec named(binary(), binary()) -> ssevents@event:event().
named(Name, Data) ->
    ssevents@event:named(Name, Data).

-file("src/ssevents.gleam", 114).
-spec id(ssevents@event:event(), binary()) -> ssevents@event:event().
id(Event, Id) ->
    ssevents@event:id(Event, Id).

-file("src/ssevents.gleam", 124).
?DOC(
    " Strict counterpart of `event/2`: returns\n"
    " `Error(NameContainsControlBytes(value:))` when the name\n"
    " contains CR / LF / NUL bytes, otherwise sets the SSE\n"
    " `event:` field name. Use when the name comes from user-typed\n"
    " or upstream input and silent stripping would lose data the\n"
    " caller cares about. (#81)\n"
).
-spec event_checked(ssevents@event:event(), binary()) -> {ok,
        ssevents@event:event()} |
    {error, ssevents@event:event_error()}.
event_checked(Event, Name) ->
    ssevents@event:event_checked(Event, Name).

-file("src/ssevents.gleam", 135).
?DOC(
    " Strict counterpart of `id/2`: returns\n"
    " `Error(IdContainsControlBytes(value:))` when the id contains\n"
    " CR / LF / NUL bytes. The strip on id is especially dangerous —\n"
    " `id(_, \"ab\\u{0000}cd\")` produces an event with `id = \"abcd\"`,\n"
    " silently mutating an authorisation-relevant identifier on\n"
    " reconnect (Last-Event-ID resume). The strict variant catches\n"
    " this at the builder boundary. (#81)\n"
).
-spec id_checked(ssevents@event:event(), binary()) -> {ok,
        ssevents@event:event()} |
    {error, ssevents@event:event_error()}.
id_checked(Event, Id) ->
    ssevents@event:id_checked(Event, Id).

-file("src/ssevents.gleam", 143).
?DOC(
    " Strict counterpart of `named/2`: returns\n"
    " `Error(NameContainsControlBytes(value:))` when the name\n"
    " contains CR / LF / NUL bytes. Convenience for the common\n"
    " `new |> event_checked` pipeline. (#81)\n"
).
-spec named_checked(binary(), binary()) -> {ok, ssevents@event:event()} |
    {error, ssevents@event:event_error()}.
named_checked(Name, Data) ->
    ssevents@event:named_checked(Name, Data).

-file("src/ssevents.gleam", 153).
?DOC(
    " Strict counterpart of `comment/1`: returns\n"
    " `Error(CommentContainsControlBytes(value:))` when the comment\n"
    " text contains CR / LF / NUL bytes. The non-strict `comment/1`\n"
    " silently strips these bytes; WHATWG SSE §9.2.6 has no notion\n"
    " of a multi-line comment, so embedded line breaks would fan out\n"
    " into multiple comments on the wire. (#81)\n"
).
-spec comment_checked(binary()) -> {ok, ssevents@event:item()} |
    {error, ssevents@event:event_error()}.
comment_checked(Text) ->
    case ssevents@event:comment_checked(Text) of
        {ok, Comment} ->
            {ok, ssevents@event:comment_item_of(Comment)};

        {error, Error_value} ->
            {error, Error_value}
    end.

-file("src/ssevents.gleam", 169).
?DOC(
    " Set the SSE `retry:` reconnection time on an event.\n"
    "\n"
    " `milliseconds` must be `>= 0`. WHATWG SSE §9.2.6 only recognises a\n"
    " retry value whose textual form \"consists of only ASCII digits\", so a\n"
    " negative value would be either dropped on the wire (the leading `-`\n"
    " breaks the digits-only check) or interpreted as `0` and trigger a\n"
    " tight reconnect loop against the server. The builder panics on\n"
    " `ms < 0`; reach for `retry_clamp/2` when the caller wants the\n"
    " lenient (clamp-to-`0`) posture.\n"
).
-spec retry(ssevents@event:event(), integer()) -> ssevents@event:event().
retry(Event, Milliseconds) ->
    ssevents@event:retry(Event, Milliseconds).

-file("src/ssevents.gleam", 177).
?DOC(
    " Like `retry/2`, but clamps `milliseconds < 0` to `0` instead of\n"
    " panicking. Use this when forwarding a value computed from possibly-\n"
    " noisy input (e.g. a CLI flag, a deserialised config) and the caller\n"
    " would rather \"publish a spec-valid retry\" than crash.\n"
).
-spec retry_clamp(ssevents@event:event(), integer()) -> ssevents@event:event().
retry_clamp(Event, Milliseconds) ->
    ssevents@event:retry_clamp(Event, Milliseconds).

-file("src/ssevents.gleam", 181).
-spec data(ssevents@event:event(), binary()) -> ssevents@event:event().
data(Event, Data) ->
    ssevents@event:data(Event, Data).

-file("src/ssevents.gleam", 185).
-spec event_item(ssevents@event:event()) -> ssevents@event:item().
event_item(Event) ->
    ssevents@event:event_item(Event).

-file("src/ssevents.gleam", 193).
-spec heartbeat() -> ssevents@event:item().
heartbeat() ->
    ssevents@heartbeat:heartbeat().

-file("src/ssevents.gleam", 189).
-spec comment(binary()) -> ssevents@event:item().
comment(Text) ->
    ssevents@heartbeat:comment(Text).

-file("src/ssevents.gleam", 205).
?DOC(
    " Issue #77: Item-level inspection helpers exposed through the\n"
    " facade. The `Item` type is re-exported as a type alias from this\n"
    " module, but Gleam's type aliases do not carry the underlying\n"
    " `EventItem` / `CommentItem` constructors — pattern-matching on a\n"
    " decoded `Item` therefore requires reaching into\n"
    " `ssevents/event` for the variants. These accessors let callers stay\n"
    " inside the facade for the common cases.\n"
    " `True` when the item is an event (carries an SSE `Event` payload).\n"
).
-spec is_event(ssevents@event:item()) -> boolean().
is_event(Item) ->
    ssevents@event:is_event(Item).

-file("src/ssevents.gleam", 210).
?DOC(" `True` when the item is a `:`-prefixed comment line.\n").
-spec is_comment(ssevents@event:item()) -> boolean().
is_comment(Item) ->
    ssevents@event:is_comment(Item).

-file("src/ssevents.gleam", 217).
?DOC(
    " Return the event payload when the item is an event, `None`\n"
    " otherwise. Pairs with `comment_text_of_item/1` for the comment\n"
    " side.\n"
).
-spec event_of_item(ssevents@event:item()) -> gleam@option:option(ssevents@event:event()).
event_of_item(Item) ->
    ssevents@event:event_of_item(Item).

-file("src/ssevents.gleam", 223).
?DOC(
    " Return the comment text when the item is a comment, `None`\n"
    " otherwise.\n"
).
-spec comment_text_of_item(ssevents@event:item()) -> gleam@option:option(binary()).
comment_text_of_item(Item) ->
    ssevents@event:comment_text_of_item(Item).

-file("src/ssevents.gleam", 230).
?DOC(
    " Filter a decoded item list down to its events, dropping comments.\n"
    " Convenience for the common \"I just want the events\" pattern after\n"
    " `decode/1`.\n"
).
-spec events_of(list(ssevents@event:item())) -> list(ssevents@event:event()).
events_of(Items) ->
    gleam@list:filter_map(
        Items,
        fun(Item) -> case ssevents@event:event_of_item(Item) of
                {some, Ev} ->
                    {ok, Ev};

                none ->
                    {error, nil}
            end end
    ).

-file("src/ssevents.gleam", 241).
?DOC(
    " Filter a decoded item list down to its comment texts, dropping\n"
    " events. Pairs with `events_of/1`.\n"
).
-spec comment_texts_of(list(ssevents@event:item())) -> list(binary()).
comment_texts_of(Items) ->
    gleam@list:filter_map(
        Items,
        fun(Item) -> case ssevents@event:comment_text_of_item(Item) of
                {some, Text} ->
                    {ok, Text};

                none ->
                    {error, nil}
            end end
    ).

-file("src/ssevents.gleam", 250).
-spec default_line_ending() -> ssevents@encoder:line_ending().
default_line_ending() ->
    ssevents@encoder:default_line_ending().

-file("src/ssevents.gleam", 258).
?DOC(
    " Encode one semantic SSE `Event` to its wire-format `String`.\n"
    "\n"
    " Use this when you want a text representation for logging,\n"
    " inspection, fixtures, or a caller that still expects `String`.\n"
).
-spec encode(ssevents@event:event()) -> binary().
encode(Event) ->
    ssevents@encoder:encode(Event).

-file("src/ssevents.gleam", 265).
?DOC(
    " Encode one semantic SSE `Event` to its wire-format `BitArray`.\n"
    "\n"
    " Use this for HTTP responses and other byte-oriented transports.\n"
).
-spec encode_bytes(ssevents@event:event()) -> bitstring().
encode_bytes(Event) ->
    ssevents@encoder:encode_bytes(Event).

-file("src/ssevents.gleam", 270).
?DOC(" Encode one `Item` (either an event or a comment) to `String`.\n").
-spec encode_item(ssevents@event:item()) -> binary().
encode_item(Item) ->
    ssevents@encoder:encode_item(Item).

-file("src/ssevents.gleam", 275).
?DOC(" Encode one `Item` (either an event or a comment) to `BitArray`.\n").
-spec encode_item_bytes(ssevents@event:item()) -> bitstring().
encode_item_bytes(Item) ->
    ssevents@encoder:encode_item_bytes(Item).

-file("src/ssevents.gleam", 280).
?DOC(" Encode a whole sequence of SSE items to one `String`.\n").
-spec encode_items(list(ssevents@event:item())) -> binary().
encode_items(Items) ->
    ssevents@encoder:encode_items(Items).

-file("src/ssevents.gleam", 285).
?DOC(" Encode a whole sequence of SSE items to one `BitArray`.\n").
-spec encode_items_bytes(list(ssevents@event:item())) -> bitstring().
encode_items_bytes(Items) ->
    ssevents@encoder:encode_items_bytes(Items).

-file("src/ssevents.gleam", 289).
-spec encode_with_line_ending(
    ssevents@event:event(),
    ssevents@encoder:line_ending()
) -> binary().
encode_with_line_ending(Event, Line_ending) ->
    ssevents@encoder:encode_with_line_ending(Event, Line_ending).

-file("src/ssevents.gleam", 293).
-spec encode_item_with_line_ending(
    ssevents@event:item(),
    ssevents@encoder:line_ending()
) -> binary().
encode_item_with_line_ending(Item, Line_ending) ->
    ssevents@encoder:encode_item_with_line_ending(Item, Line_ending).

-file("src/ssevents.gleam", 300).
-spec encode_items_with_line_ending(
    list(ssevents@event:item()),
    ssevents@encoder:line_ending()
) -> binary().
encode_items_with_line_ending(Items, Line_ending) ->
    ssevents@encoder:encode_items_with_line_ending(Items, Line_ending).

-file("src/ssevents.gleam", 307).
-spec decode(binary()) -> {ok, list(ssevents@event:item())} |
    {error, ssevents@error:sse_error()}.
decode(Input) ->
    ssevents@decoder:decode(Input).

-file("src/ssevents.gleam", 311).
-spec decode_bytes(bitstring()) -> {ok, list(ssevents@event:item())} |
    {error, ssevents@error:sse_error()}.
decode_bytes(Input) ->
    ssevents@decoder:decode_bytes(Input).

-file("src/ssevents.gleam", 315).
-spec decode_with_limits(binary(), ssevents@limit:limits()) -> {ok,
        list(ssevents@event:item())} |
    {error, ssevents@error:sse_error()}.
decode_with_limits(Input, Limits) ->
    ssevents@decoder:decode_with_limits(Input, Limits).

-file("src/ssevents.gleam", 322).
-spec decode_bytes_with_limits(bitstring(), ssevents@limit:limits()) -> {ok,
        list(ssevents@event:item())} |
    {error, ssevents@error:sse_error()}.
decode_bytes_with_limits(Input, Limits) ->
    ssevents@decoder:decode_bytes_with_limits(Input, Limits).

-file("src/ssevents.gleam", 329).
-spec new_decoder() -> ssevents@decoder:decode_state().
new_decoder() ->
    ssevents@decoder:new_decoder().

-file("src/ssevents.gleam", 333).
-spec new_decoder_with_limits(ssevents@limit:limits()) -> ssevents@decoder:decode_state().
new_decoder_with_limits(Limits) ->
    ssevents@decoder:new_decoder_with_limits(Limits).

-file("src/ssevents.gleam", 337).
-spec push(ssevents@decoder:decode_state(), bitstring()) -> {ok,
        {ssevents@decoder:decode_state(), list(ssevents@event:item())}} |
    {error, ssevents@error:sse_error()}.
push(State, Chunk) ->
    ssevents@decoder:push(State, Chunk).

-file("src/ssevents.gleam", 344).
-spec finish(ssevents@decoder:decode_state()) -> {ok,
        list(ssevents@event:item())} |
    {error, ssevents@error:sse_error()}.
finish(State) ->
    ssevents@decoder:finish(State).

-file("src/ssevents.gleam", 348).
-spec limits() -> ssevents@limit:limits().
limits() ->
    ssevents@limit:default().

-file("src/ssevents.gleam", 352).
-spec new_limits(integer(), integer(), integer(), integer()) -> ssevents@limit:limits().
new_limits(Max_line_bytes, Max_event_bytes, Max_data_lines, Max_retry_value) ->
    ssevents@limit:new(
        Max_line_bytes,
        Max_event_bytes,
        Max_data_lines,
        Max_retry_value
    ).

-file("src/ssevents.gleam", 366).
-spec max_line_bytes(ssevents@limit:limits()) -> integer().
max_line_bytes(Limits) ->
    ssevents@limit:max_line_bytes(Limits).

-file("src/ssevents.gleam", 370).
-spec max_event_bytes(ssevents@limit:limits()) -> integer().
max_event_bytes(Limits) ->
    ssevents@limit:max_event_bytes(Limits).

-file("src/ssevents.gleam", 377).
?DOC(
    " Alias of `max_event_bytes/1`. Pairs with `with_max_event_size/2`\n"
    " so callers that raise the per-event cap can read it back using the\n"
    " same spelling. (#96)\n"
).
-spec max_event_size(ssevents@limit:limits()) -> integer().
max_event_size(Limits) ->
    ssevents@limit:max_event_size(Limits).

-file("src/ssevents.gleam", 401).
?DOC(
    " Override the per-event byte cap on a `Limits` value.\n"
    "\n"
    " The default decoder (`decode/1`, `decode_bytes/1`) runs with a\n"
    " 65_536-byte cap and fails the whole stream with\n"
    " `Error(EventTooLarge(65_536))` for any event above that. The\n"
    " encoder never rejects an event for sheer size, so a 100 KB event\n"
    " the package's own encoder produced would be unreachable on the\n"
    " decode side without this override. Pair with `decode_with_limits`\n"
    " (or `decode_bytes_with_limits`) to raise the cap:\n"
    "\n"
    " ```gleam\n"
    " let limits =\n"
    "   ssevents.default_limits()\n"
    "   |> ssevents.with_max_event_size(200_000)\n"
    " ssevents.decode_with_limits(wire, limits: limits)\n"
    " ```\n"
    "\n"
    " The default `decode/1` keeps the 65_536-byte ceiling as a\n"
    " memory-bound safety net for untrusted input. Panics on\n"
    " `bytes < 1`. (#96)\n"
).
-spec with_max_event_size(ssevents@limit:limits(), integer()) -> ssevents@limit:limits().
with_max_event_size(Limits, Bytes) ->
    ssevents@limit:with_max_event_size(Limits, Bytes).

-file("src/ssevents.gleam", 405).
-spec max_data_lines(ssevents@limit:limits()) -> integer().
max_data_lines(Limits) ->
    ssevents@limit:max_data_lines(Limits).

-file("src/ssevents.gleam", 409).
-spec max_retry_value(ssevents@limit:limits()) -> integer().
max_retry_value(Limits) ->
    ssevents@limit:max_retry_value(Limits).

-file("src/ssevents.gleam", 419).
?DOC(
    " Read the `strict_retry_cap` flag from a `Limits` value.\n"
    "\n"
    " When `True`, the decoder errors with `InvalidRetry(_)` on\n"
    " `retry:` values above `max_retry_value`. When `False` (the\n"
    " default), the decoder silently drops the offending field to\n"
    " `None` and the surrounding event still dispatches. (#95)\n"
).
-spec strict_retry_cap(ssevents@limit:limits()) -> boolean().
strict_retry_cap(Limits) ->
    ssevents@limit:strict_retry_cap(Limits).

-file("src/ssevents.gleam", 433).
?DOC(
    " Toggle the decoder's `retry:` cap-overrun posture.\n"
    "\n"
    " `False` (the default) keeps the decoder lenient: a `retry:` value\n"
    " above `max_retry_value` is silently dropped to `None` and the\n"
    " surrounding event still dispatches, mirroring the encoder's\n"
    " `retry_clamp/2` and matching WHATWG SSE's lenient parser thesis.\n"
    " `True` re-enables the strict posture: an above-cap value fails\n"
    " the whole decode with `Error(InvalidRetry(_))`, so callers that\n"
    " want to detect adversarial retry values explicitly can do so.\n"
    " (#95)\n"
).
-spec with_strict_retry_cap(ssevents@limit:limits(), boolean()) -> ssevents@limit:limits().
with_strict_retry_cap(Limits, Strict) ->
    ssevents@limit:with_strict_retry_cap(Limits, Strict).

-file("src/ssevents.gleam", 437).
-spec validate_event_name(binary()) -> {ok, binary()} |
    {error, ssevents@error:sse_error()}.
validate_event_name(Name) ->
    ssevents@validate:validate_event_name(Name).

-file("src/ssevents.gleam", 441).
-spec validate_id(binary()) -> {ok, binary()} |
    {error, ssevents@error:sse_error()}.
validate_id(Id) ->
    ssevents@validate:validate_id(Id).

-file("src/ssevents.gleam", 445).
-spec validate_retry(integer()) -> {ok, integer()} |
    {error, ssevents@error:sse_error()}.
validate_retry(Milliseconds) ->
    ssevents@validate:validate_retry(Milliseconds).

-file("src/ssevents.gleam", 449).
-spec max_data_bytes(ssevents@event:event(), integer()) -> {ok,
        ssevents@event:event()} |
    {error, ssevents@error:sse_error()}.
max_data_bytes(Event, Max) ->
    ssevents@validate:max_data_bytes(Event, Max).

-file("src/ssevents.gleam", 453).
-spec new_reconnect_state() -> ssevents@reconnect:reconnect_state().
new_reconnect_state() ->
    ssevents@reconnect:new().

-file("src/ssevents.gleam", 457).
-spec update_reconnect(
    ssevents@reconnect:reconnect_state(),
    ssevents@event:item()
) -> ssevents@reconnect:reconnect_state().
update_reconnect(State, Item) ->
    ssevents@reconnect:update(State, Item).

-file("src/ssevents.gleam", 461).
-spec last_event_id(ssevents@reconnect:reconnect_state()) -> gleam@option:option(binary()).
last_event_id(State) ->
    ssevents@reconnect:last_event_id(State).

-file("src/ssevents.gleam", 465).
-spec retry_interval(ssevents@reconnect:reconnect_state()) -> gleam@option:option(integer()).
retry_interval(State) ->
    ssevents@reconnect:retry(State).

-file("src/ssevents.gleam", 469).
-spec last_event_id_header(ssevents@reconnect:reconnect_state()) -> gleam@option:option({binary(),
    binary()}).
last_event_id_header(State) ->
    ssevents@reconnect:last_event_id_header(State).

-file("src/ssevents.gleam", 473).
-spec empty_iterator() -> ssevents@stream:iterator(any()).
empty_iterator() ->
    ssevents@stream:empty().

-file("src/ssevents.gleam", 477).
-spec iterator_from_list(list(EOX)) -> ssevents@stream:iterator(EOX).
iterator_from_list(Items) ->
    ssevents@stream:from_list(Items).

-file("src/ssevents.gleam", 481).
-spec iterator_to_list(ssevents@stream:iterator(EPA)) -> list(EPA).
iterator_to_list(Iterator) ->
    ssevents@stream:to_list(Iterator).

-file("src/ssevents.gleam", 485).
-spec iterator_next(ssevents@stream:iterator(EPD)) -> ssevents@stream:step(EPD).
iterator_next(Iterator) ->
    ssevents@stream:next(Iterator).

-file("src/ssevents.gleam", 489).
-spec encode_stream(ssevents@stream:iterator(ssevents@event:item())) -> ssevents@stream:iterator(bitstring()).
encode_stream(Items) ->
    ssevents@stream:encode_stream(Items).

-file("src/ssevents.gleam", 493).
-spec decode_stream(ssevents@stream:iterator(bitstring())) -> ssevents@stream:iterator({ok,
        ssevents@event:item()} |
    {error, ssevents@error:sse_error()}).
decode_stream(Chunks) ->
    ssevents@stream:decode_stream(Chunks).

-file("src/ssevents.gleam", 499).
-spec decode_stream_with_limits(
    ssevents@stream:iterator(bitstring()),
    ssevents@limit:limits()
) -> ssevents@stream:iterator({ok, ssevents@event:item()} |
    {error, ssevents@error:sse_error()}).
decode_stream_with_limits(Chunks, Limits) ->
    ssevents@stream:decode_stream_with_limits(Chunks, Limits).

-file("src/ssevents.gleam", 506).
-spec error_to_string(ssevents@error:sse_error()) -> binary().
error_to_string(Error) ->
    ssevents@error:to_string(Error).

-file("src/ssevents.gleam", 65).
-spec content_type() -> binary().
content_type() ->
    <<"text/event-stream"/utf8>>.