-module(telega).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/telega.gleam").
-export([is_webhook_path/2, is_secret_token_valid/2, get_api_config/1, new/4, handle_all/2, wait_any/4, handle_command/3, wait_command/5, handle_commands/3, wait_commands/5, handle_text/2, wait_text/4, handle_hears/3, wait_hears/5, handle_message/2, wait_message/4, handle_callback_query/3, wait_callback_query/5, handle_voice/2, wait_voice/4, handle_audio/2, wait_audio/4, handle_video/2, wait_video/4, handle_photos/2, wait_photos/4, handle_web_app_data/2, wait_web_app_data/4, with_catch_handler/2, handle_chat_member/2, log_context/3, with_session_settings/4, set_drop_pending_updates/2, set_max_connections/2, set_ip_address/2, set_allowed_updates/2, set_certificate/2, set_api_client/2, init/1, init_nil_session/1, handle_update/2]).
-export_type([telega/2, telega_builder/2]).

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

-opaque telega(ALRN, ALRO) :: {telega,
        telega@internal@config:config(),
        telega@model:user(),
        gleam@erlang@process:subject(telega@bot:bot_message())} |
    {gleam_phantom, ALRN, ALRO}.

-opaque telega_builder(ALRP, ALRQ) :: {telega_builder,
        telega@internal@config:config(),
        list(telega@bot:handler(ALRP, ALRQ)),
        gleam@option:option(telega@bot:session_settings(ALRP, ALRQ)),
        gleam@option:option(gleam@erlang@process:subject(telega@bot:bot_message())),
        gleam@option:option(fun((telega@bot:context(ALRP, ALRQ), ALRQ) -> {ok,
                nil} |
            {error, ALRQ})),
        gleam@option:option(boolean()),
        gleam@option:option(integer()),
        gleam@option:option(binary()),
        gleam@option:option(list(binary())),
        gleam@option:option(telega@model:file())}.

-file("src/telega.gleam", 51).
?DOC(
    " Check if a path is the webhook path for the bot.\n"
    "\n"
    " Useful if you plan to implement own adapter.\n"
).
-spec is_webhook_path(telega(any(), any()), binary()) -> boolean().
is_webhook_path(Telega, Path) ->
    erlang:element(3, erlang:element(2, Telega)) =:= Path.

-file("src/telega.gleam", 58).
?DOC(
    " Check if a secret token is valid.\n"
    "\n"
    " Useful if you plan to implement own adapter.\n"
).
-spec is_secret_token_valid(telega(any(), any()), binary()) -> boolean().
is_secret_token_valid(Telega, Token) ->
    erlang:element(4, erlang:element(2, Telega)) =:= Token.

-file("src/telega.gleam", 63).
?DOC(" Helper to get the config for API requests.\n").
-spec get_api_config(telega(any(), any())) -> telega@client:telegram_client().
get_api_config(Telega) ->
    erlang:element(5, erlang:element(2, Telega)).

-file("src/telega.gleam", 68).
?DOC(" Create a new Telega instance.\n").
-spec new(binary(), binary(), binary(), gleam@option:option(binary())) -> telega_builder(any(), any()).
new(Token, Server_url, Webhook_path, Secret_token) ->
    Url = telega@internal@utils:normalize_url(Server_url),
    Webhook_path@1 = telega@internal@utils:normalize_webhook_path(Webhook_path),
    {telega_builder,
        telega@internal@config:new(Token, Url, Webhook_path@1, Secret_token),
        [],
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none}.

-file("src/telega.gleam", 92).
?DOC(" Handles all messages.\n").
-spec handle_all(
    telega_builder(ALSI, ALSJ),
    fun((telega@bot:context(ALSI, ALSJ), telega@update:update()) -> {ok,
            telega@bot:context(ALSI, ALSJ)} |
        {error, ALSJ})
) -> telega_builder(ALSI, ALSJ).
handle_all(Builder, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_all, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 103).
?DOC(
    " Stops bot message handling from current chat and waits for any message.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_any(
    telega@bot:context(ALSU, ALSV),
    gleam@option:option(telega@bot:handler(ALSU, ALSV)),
    gleam@option:option(integer()),
    fun((telega@bot:context(ALSU, ALSV), telega@update:update()) -> {ok,
            telega@bot:context(ALSU, ALSV)} |
        {error, ALSV})
) -> {ok, telega@bot:context(ALSU, ALSV)} | {error, ALSV}.
wait_any(Ctx, Handle_else, Timeout, Handler) ->
    telega@bot:wait_handler(Ctx, {handle_all, Handler}, Handle_else, Timeout).

-file("src/telega.gleam", 114).
?DOC(" Handles a specific command.\n").
-spec handle_command(
    telega_builder(ALTM, ALTN),
    binary(),
    fun((telega@bot:context(ALTM, ALTN), telega@update:command()) -> {ok,
            telega@bot:context(ALTM, ALTN)} |
        {error, ALTN})
) -> telega_builder(ALTM, ALTN).
handle_command(Builder, Command, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_command, Command, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 129).
?DOC(
    " Stops bot message handling from current chat and waits for a specific command.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_command(
    telega@bot:context(ALTX, ALTY),
    binary(),
    gleam@option:option(telega@bot:handler(ALTX, ALTY)),
    gleam@option:option(integer()),
    fun((telega@bot:context(ALTX, ALTY), telega@update:command()) -> {ok,
            telega@bot:context(ALTX, ALTY)} |
        {error, ALTY})
) -> {ok, telega@bot:context(ALTX, ALTY)} | {error, ALTY}.
wait_command(Ctx, Command, Handle_else, Timeout, Continue) ->
    telega@bot:wait_handler(
        Ctx,
        {handle_command, Command, Continue},
        Handle_else,
        Timeout
    ).

-file("src/telega.gleam", 146).
?DOC(" Handles multiple commands.\n").
-spec handle_commands(
    telega_builder(ALUP, ALUQ),
    list(binary()),
    fun((telega@bot:context(ALUP, ALUQ), telega@update:command()) -> {ok,
            telega@bot:context(ALUP, ALUQ)} |
        {error, ALUQ})
) -> telega_builder(ALUP, ALUQ).
handle_commands(Builder, Commands, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_commands, Commands, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 161).
?DOC(
    " Stops bot message handling from current chat and waits for a specific command.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_commands(
    telega@bot:context(ALVB, ALVC),
    list(binary()),
    gleam@option:option(telega@bot:handler(ALVB, ALVC)),
    gleam@option:option(integer()),
    fun((telega@bot:context(ALVB, ALVC), telega@update:command()) -> {ok,
            telega@bot:context(ALVB, ALVC)} |
        {error, ALVC})
) -> {ok, telega@bot:context(ALVB, ALVC)} | {error, ALVC}.
wait_commands(Ctx, Commands, Handle_else, Timeout, Continue) ->
    telega@bot:wait_handler(
        Ctx,
        {handle_commands, Commands, Continue},
        Handle_else,
        Timeout
    ).

-file("src/telega.gleam", 178).
?DOC(" Handles text messages.\n").
-spec handle_text(
    telega_builder(ALVU, ALVV),
    fun((telega@bot:context(ALVU, ALVV), binary()) -> {ok,
            telega@bot:context(ALVU, ALVV)} |
        {error, ALVV})
) -> telega_builder(ALVU, ALVV).
handle_text(Builder, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_text, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 189).
?DOC(
    " Stops bot message handling from current chat and waits for a text message.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_text(
    telega@bot:context(ALWF, ALWG),
    gleam@option:option(telega@bot:handler(ALWF, ALWG)),
    gleam@option:option(integer()),
    fun((telega@bot:context(ALWF, ALWG), binary()) -> {ok,
            telega@bot:context(ALWF, ALWG)} |
        {error, ALWG})
) -> {ok, telega@bot:context(ALWF, ALWG)} | {error, ALWG}.
wait_text(Ctx, Handle_else, Timeout, Continue) ->
    telega@bot:wait_handler(Ctx, {handle_text, Continue}, Handle_else, Timeout).

-file("src/telega.gleam", 200).
?DOC(" Handles messages that match the given `Hears`.\n").
-spec handle_hears(
    telega_builder(ALWX, ALWY),
    telega@bot:hears(),
    fun((telega@bot:context(ALWX, ALWY), binary()) -> {ok,
            telega@bot:context(ALWX, ALWY)} |
        {error, ALWY})
) -> telega_builder(ALWX, ALWY).
handle_hears(Builder, Hears, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_hears, Hears, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 215).
?DOC(
    " Stops bot message handling from current chat and waits for a message that matches the given `Hears`.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_hears(
    telega@bot:context(ALXI, ALXJ),
    telega@bot:hears(),
    gleam@option:option(telega@bot:handler(ALXI, ALXJ)),
    gleam@option:option(integer()),
    fun((telega@bot:context(ALXI, ALXJ), binary()) -> {ok,
            telega@bot:context(ALXI, ALXJ)} |
        {error, ALXJ})
) -> {ok, telega@bot:context(ALXI, ALXJ)} | {error, ALXJ}.
wait_hears(Ctx, Hears, Handle_else, Timeout, Continue) ->
    telega@bot:wait_handler(
        Ctx,
        {handle_hears, Hears, Continue},
        Handle_else,
        Timeout
    ).

-file("src/telega.gleam", 232).
?DOC(" Handles any message.\n").
-spec handle_message(
    telega_builder(ALYA, ALYB),
    fun((telega@bot:context(ALYA, ALYB), telega@model:message()) -> {ok,
            telega@bot:context(ALYA, ALYB)} |
        {error, ALYB})
) -> telega_builder(ALYA, ALYB).
handle_message(Builder, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_message, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 246).
?DOC(
    " Stops bot message handling from current chat and waits for any message.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_message(
    telega@bot:context(ALYM, ALYN),
    gleam@option:option(telega@bot:handler(ALYM, ALYN)),
    gleam@option:option(integer()),
    fun((telega@bot:context(ALYM, ALYN), telega@model:message()) -> {ok,
            telega@bot:context(ALYM, ALYN)} |
        {error, ALYN})
) -> {ok, telega@bot:context(ALYM, ALYN)} | {error, ALYN}.
wait_message(Ctx, Handle_else, Timeout, Continue) ->
    telega@bot:wait_handler(
        Ctx,
        {handle_message, Continue},
        Handle_else,
        Timeout
    ).

-file("src/telega.gleam", 264).
?DOC(
    " Handles messages from inline keyboard callback.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec handle_callback_query(
    telega_builder(ALZE, ALZF),
    telega@bot:callback_query_filter(),
    fun((telega@bot:context(ALZE, ALZF), binary(), binary()) -> {ok,
            telega@bot:context(ALZE, ALZF)} |
        {error, ALZF})
) -> telega_builder(ALZE, ALZF).
handle_callback_query(Builder, Filter, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_callback_query, Filter, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 279).
?DOC(
    " Wait for a callback query and continue with the given function.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_callback_query(
    telega@bot:context(ALZQ, ALZR),
    telega@bot:callback_query_filter(),
    gleam@option:option(telega@bot:handler(ALZQ, ALZR)),
    gleam@option:option(integer()),
    fun((telega@bot:context(ALZQ, ALZR), binary(), binary()) -> {ok,
            telega@bot:context(ALZQ, ALZR)} |
        {error, ALZR})
) -> {ok, telega@bot:context(ALZQ, ALZR)} | {error, ALZR}.
wait_callback_query(Ctx, Filter, Handle_else, Timeout, Continue) ->
    telega@bot:wait_handler(
        Ctx,
        {handle_callback_query, Filter, Continue},
        Handle_else,
        Timeout
    ).

-file("src/telega.gleam", 296).
?DOC(" Handles voice messages.\n").
-spec handle_voice(
    telega_builder(AMAI, AMAJ),
    fun((telega@bot:context(AMAI, AMAJ), telega@model:voice()) -> {ok,
            telega@bot:context(AMAI, AMAJ)} |
        {error, AMAJ})
) -> telega_builder(AMAI, AMAJ).
handle_voice(Builder, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_voice, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 307).
?DOC(
    " Stops bot message handling from current chat and waits for a voice message.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_voice(
    telega@bot:context(AMAU, AMAV),
    gleam@option:option(telega@bot:handler(AMAU, AMAV)),
    gleam@option:option(integer()),
    fun((telega@bot:context(AMAU, AMAV), telega@model:voice()) -> {ok,
            telega@bot:context(AMAU, AMAV)} |
        {error, AMAV})
) -> {ok, telega@bot:context(AMAU, AMAV)} | {error, AMAV}.
wait_voice(Ctx, Handle_else, Timeout, Continue) ->
    telega@bot:wait_handler(Ctx, {handle_voice, Continue}, Handle_else, Timeout).

-file("src/telega.gleam", 318).
?DOC(" Handles audio messages.\n").
-spec handle_audio(
    telega_builder(AMBM, AMBN),
    fun((telega@bot:context(AMBM, AMBN), telega@model:audio()) -> {ok,
            telega@bot:context(AMBM, AMBN)} |
        {error, AMBN})
) -> telega_builder(AMBM, AMBN).
handle_audio(Builder, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_audio, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 329).
?DOC(
    " Stops bot message handling from current chat and waits for an audio message.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_audio(
    telega@bot:context(AMBX, AMBY),
    gleam@option:option(telega@bot:handler(AMBX, AMBY)),
    gleam@option:option(integer()),
    fun((telega@bot:context(AMBX, AMBY), telega@model:audio()) -> {ok,
            telega@bot:context(AMBX, AMBY)} |
        {error, AMBY})
) -> {ok, telega@bot:context(AMBX, AMBY)} | {error, AMBY}.
wait_audio(Ctx, Handle_else, Timeout, Continue) ->
    telega@bot:wait_handler(Ctx, {handle_audio, Continue}, Handle_else, Timeout).

-file("src/telega.gleam", 340).
?DOC(" Handles video messages.\n").
-spec handle_video(
    telega_builder(AMCP, AMCQ),
    fun((telega@bot:context(AMCP, AMCQ), telega@model:video()) -> {ok,
            telega@bot:context(AMCP, AMCQ)} |
        {error, AMCQ})
) -> telega_builder(AMCP, AMCQ).
handle_video(Builder, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_video, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 351).
?DOC(
    " Stops bot message handling from current chat and waits for a video message.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_video(
    telega@bot:context(AMDA, AMDB),
    gleam@option:option(telega@bot:handler(AMDA, AMDB)),
    gleam@option:option(integer()),
    fun((telega@bot:context(AMDA, AMDB), telega@model:video()) -> {ok,
            telega@bot:context(AMDA, AMDB)} |
        {error, AMDB})
) -> {ok, telega@bot:context(AMDA, AMDB)} | {error, AMDB}.
wait_video(Ctx, Handle_else, Timeout, Continue) ->
    telega@bot:wait_handler(Ctx, {handle_video, Continue}, Handle_else, Timeout).

-file("src/telega.gleam", 362).
?DOC(" Handles photo messages.\n").
-spec handle_photos(
    telega_builder(AMDS, AMDT),
    fun((telega@bot:context(AMDS, AMDT), list(telega@model:photo_size())) -> {ok,
            telega@bot:context(AMDS, AMDT)} |
        {error, AMDT})
) -> telega_builder(AMDS, AMDT).
handle_photos(Builder, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_photos, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 373).
?DOC(
    " Stops bot message handling from current chat and waits for a photo message.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_photos(
    telega@bot:context(AMEE, AMEF),
    gleam@option:option(telega@bot:handler(AMEE, AMEF)),
    gleam@option:option(integer()),
    fun((telega@bot:context(AMEE, AMEF), list(telega@model:photo_size())) -> {ok,
            telega@bot:context(AMEE, AMEF)} |
        {error, AMEF})
) -> {ok, telega@bot:context(AMEE, AMEF)} | {error, AMEF}.
wait_photos(Ctx, Handle_else, Timeout, Continue) ->
    telega@bot:wait_handler(
        Ctx,
        {handle_photos, Continue},
        Handle_else,
        Timeout
    ).

-file("src/telega.gleam", 389).
?DOC(" Handles web app data messages.\n").
-spec handle_web_app_data(
    telega_builder(AMEX, AMEY),
    fun((telega@bot:context(AMEX, AMEY), telega@model:web_app_data()) -> {ok,
            telega@bot:context(AMEX, AMEY)} |
        {error, AMEY})
) -> telega_builder(AMEX, AMEY).
handle_web_app_data(Builder, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_web_app_data, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 403).
?DOC(
    " Stops bot message handling from current chat and waits for a web app data message.\n"
    "\n"
    " See [conversation](/docs/conversation)\n"
).
-spec wait_web_app_data(
    telega@bot:context(AMFI, AMFJ),
    gleam@option:option(telega@bot:handler(AMFI, AMFJ)),
    gleam@option:option(integer()),
    fun((telega@bot:context(AMFI, AMFJ), telega@model:web_app_data()) -> {ok,
            telega@bot:context(AMFI, AMFJ)} |
        {error, AMFJ})
) -> {ok, telega@bot:context(AMFI, AMFJ)} | {error, AMFJ}.
wait_web_app_data(Ctx, Handle_else, Timeout, Continue) ->
    telega@bot:wait_handler(
        Ctx,
        {handle_web_app_data, Continue},
        Handle_else,
        Timeout
    ).

-file("src/telega.gleam", 422).
?DOC(
    " Set a catch handler for all handlers.\n"
    "\n"
    " If handler returns `Error`, the chat instance will be stopped and the error will be logged\n"
    " The default handler is `fn(_) -> Ok(Nil)`, which will do nothing if handler returns an error\n"
).
-spec with_catch_handler(
    telega_builder(AMGA, AMGB),
    fun((telega@bot:context(AMGA, AMGB), AMGB) -> {ok, nil} | {error, AMGB})
) -> telega_builder(AMGA, AMGB).
with_catch_handler(Builder, Catch_handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        {some, Catch_handler},
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 430).
?DOC(" Handles chat member update (when user joins/leaves a group). The bot must be an administrator in the chat and must explicitly specify \"chat_member\" in the list of `allowed_updates` to receive these updates.\n").
-spec handle_chat_member(
    telega_builder(AMGI, AMGJ),
    fun((telega@bot:context(AMGI, AMGJ), telega@model:chat_member_updated()) -> {ok,
            telega@bot:context(AMGI, AMGJ)} |
        {error, AMGJ})
) -> telega_builder(AMGI, AMGJ).
handle_chat_member(Builder, Handler) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        [{handle_chat_member, Handler} | erlang:element(3, Builder)],
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 442).
?DOC(" Log the message and error message if the handler fails.\n").
-spec log_context(
    telega@bot:context(AMGU, AMGV),
    binary(),
    fun(() -> {ok, telega@bot:context(AMGU, AMGV)} | {error, AMGV})
) -> {ok, telega@bot:context(AMGU, AMGV)} | {error, AMGV}.
log_context(Ctx, Prefix, Handler) ->
    Id = telega@internal@utils:random_string(5),
    Prefix@1 = <<<<<<<<"["/utf8, Prefix/binary>>/binary, ":"/utf8>>/binary,
            Id/binary>>/binary,
        "] "/utf8>>,
    telega@internal@log:info(
        <<<<Prefix@1/binary, "received update: "/utf8>>/binary,
            (telega@update:to_string(erlang:element(3, Ctx)))/binary>>
    ),
    Start_time = gleam@time@timestamp:system_time(),
    Result = begin
        _pipe = Handler(),
        gleam@result:map_error(
            _pipe,
            fun(E) ->
                telega@internal@log:error(
                    <<<<Prefix@1/binary, "handler failed: "/utf8>>/binary,
                        (gleam@string:inspect(E))/binary>>
                ),
                E
            end
        )
    end,
    End_time = gleam@time@timestamp:system_time(),
    Time = begin
        _pipe@1 = Start_time,
        _pipe@2 = gleam@time@timestamp:difference(_pipe@1, End_time),
        _pipe@3 = gleam@time@duration:to_seconds(_pipe@2),
        _pipe@4 = telega@internal@utils:seconds_to_milliseconds(_pipe@3),
        _pipe@5 = erlang:trunc(_pipe@4),
        erlang:integer_to_binary(_pipe@5)
    end,
    telega@internal@log:info(
        <<<<<<Prefix@1/binary, "handler completed in "/utf8>>/binary,
                Time/binary>>/binary,
            "ms"/utf8>>
    ),
    Result.

-file("src/telega.gleam", 476).
?DOC(
    " Construct a session settings.\n"
    "\n"
    " `get_session` should return `Ok(None)` if there is no session for the given key `default_session` will be used in this case. `Error` will crash chat actor.\n"
).
-spec with_session_settings(
    telega_builder(AMHG, AMHH),
    fun((binary(), AMHG) -> {ok, AMHG} | {error, AMHH}),
    fun((binary()) -> {ok, gleam@option:option(AMHG)} | {error, AMHH}),
    fun(() -> AMHG)
) -> telega_builder(AMHG, AMHH).
with_session_settings(Builder, Persist_session, Get_session, Default_session) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        erlang:element(3, _record),
        {some,
            {session_settings, Persist_session, Get_session, Default_session}},
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 513).
?DOC(" Set the drop pending updates flag as set webhook parameter.\n").
-spec set_drop_pending_updates(telega_builder(AMHY, AMHZ), boolean()) -> telega_builder(AMHY, AMHZ).
set_drop_pending_updates(Builder, Drop_pending_updates) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        {some, Drop_pending_updates},
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 521).
?DOC(" Set the max connections as set webhook parameter.\n").
-spec set_max_connections(telega_builder(AMIE, AMIF), integer()) -> telega_builder(AMIE, AMIF).
set_max_connections(Builder, Max_connections) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        {some, Max_connections},
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 529).
?DOC(" Set the ip address as set webhook parameter.\n").
-spec set_ip_address(telega_builder(AMIK, AMIL), binary()) -> telega_builder(AMIK, AMIL).
set_ip_address(Builder, Ip_address) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        {some, Ip_address},
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 537).
?DOC(" Set the allowed updates as set webhook parameter.\n").
-spec set_allowed_updates(telega_builder(AMIQ, AMIR), list(binary())) -> telega_builder(AMIQ, AMIR).
set_allowed_updates(Builder, Allowed_updates) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        {some, Allowed_updates},
        erlang:element(11, _record)}.

-file("src/telega.gleam", 545).
?DOC(" Set the certificate as set webhook parameter.\n").
-spec set_certificate(telega_builder(AMIX, AMIY), telega@model:file()) -> telega_builder(AMIX, AMIY).
set_certificate(Builder, Certificate) ->
    _record = Builder,
    {telega_builder,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        {some, Certificate}}.

-file("src/telega.gleam", 555).
?DOC(
    " Pass custom api client to the builder.\n"
    "\n"
    " Useful if you want set custom fetch function or pass your api client options\n"
).
-spec set_api_client(
    telega_builder(AMJD, AMJE),
    telega@client:telegram_client()
) -> telega_builder(AMJD, AMJE).
set_api_client(Builder, Api_client) ->
    _record = Builder,
    {telega_builder,
        begin
            _record@1 = erlang:element(2, Builder),
            {config,
                erlang:element(2, _record@1),
                erlang:element(3, _record@1),
                erlang:element(4, _record@1),
                Api_client}
        end,
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record)}.

-file("src/telega.gleam", 605).
-spec nil_catch_handler(any(), any()) -> {ok, nil} | {error, any()}.
nil_catch_handler(_, _) ->
    {ok, nil}.

-file("src/telega.gleam", 565).
?DOC(
    " Initialize a Telega instance.\n"
    " This function should be called **only** after all handlers are added to the builder.\n"
    " It will set the webhook and start handling messages.\n"
).
-spec init(telega_builder(AMJJ, AMJK)) -> {ok, telega(AMJJ, AMJK)} |
    {error, telega@error:telega_error()}.
init(Builder) ->
    gleam@result:'try'(
        telega@api:set_webhook(
            erlang:element(5, erlang:element(2, Builder)),
            {set_webhook_parameters,
                <<<<(erlang:element(2, erlang:element(2, Builder)))/binary,
                        "/"/utf8>>/binary,
                    (erlang:element(3, erlang:element(2, Builder)))/binary>>,
                erlang:element(11, Builder),
                erlang:element(8, Builder),
                erlang:element(9, Builder),
                erlang:element(10, Builder),
                erlang:element(7, Builder),
                {some, erlang:element(4, erlang:element(2, Builder))}}
        ),
        fun(Is_ok) ->
            gleam@bool:guard(
                not Is_ok,
                {error, set_webhook_error},
                fun() ->
                    gleam@result:'try'(
                        telega@api:get_me(
                            erlang:element(5, erlang:element(2, Builder))
                        ),
                        fun(Bot_info) ->
                            Session_settings = gleam@option:to_result(
                                erlang:element(4, Builder),
                                no_session_settings_error
                            ),
                            gleam@result:'try'(
                                Session_settings,
                                fun(Session_settings@1) ->
                                    gleam@result:'try'(
                                        telega@internal@registry:start(),
                                        fun(Registry_subject) ->
                                            Catch_handler = gleam@option:lazy_unwrap(
                                                erlang:element(6, Builder),
                                                fun() ->
                                                    fun nil_catch_handler/2
                                                end
                                            ),
                                            gleam@result:'try'(
                                                telega@bot:start(
                                                    Registry_subject,
                                                    erlang:element(2, Builder),
                                                    Bot_info,
                                                    erlang:element(3, Builder),
                                                    Session_settings@1,
                                                    Catch_handler
                                                ),
                                                fun(Bot_subject) ->
                                                    {ok,
                                                        {telega,
                                                            erlang:element(
                                                                2,
                                                                Builder
                                                            ),
                                                            Bot_info,
                                                            Bot_subject}}
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/telega.gleam", 494).
?DOC(
    " Initialize a Telega instance with a `Nil` session.\n"
    " Useful when you don't need to persist the session.\n"
).
-spec init_nil_session(telega_builder(nil, AMHR)) -> {ok, telega(nil, AMHR)} |
    {error, telega@error:telega_error()}.
init_nil_session(Builder) ->
    Persist_session = fun(_, _) -> {ok, nil} end,
    Get_session = fun(_) -> {ok, {some, nil}} end,
    Default_session = fun() -> nil end,
    _pipe = begin
        _record = Builder,
        {telega_builder,
            erlang:element(2, _record),
            erlang:element(3, _record),
            {some,
                {session_settings,
                    Persist_session,
                    Get_session,
                    Default_session}},
            erlang:element(5, _record),
            erlang:element(6, _record),
            erlang:element(7, _record),
            erlang:element(8, _record),
            erlang:element(9, _record),
            erlang:element(10, _record),
            erlang:element(11, _record)}
    end,
    init(_pipe).

-file("src/telega.gleam", 610).
?DOC(" Handle an update from the Telegram API.\n").
-spec handle_update(telega(any(), any()), telega@model:update()) -> boolean().
handle_update(Telega, Raw_update) ->
    _pipe = telega@update:raw_to_update(Raw_update),
    telega@bot:handle_update(erlang:element(4, Telega), _pipe).