-module(glixir).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glixir.gleam").
-export([pubsub_start/1, pubsub_subscribe/4, pubsub_subscribe_with_registry_key/5, pubsub_broadcast/4, pubsub_unsubscribe/2, start_registry/1, start_registry_with_keys/2, register_subject/4, lookup_subject/3, unregister_subject/3, register_subject_string/3, lookup_subject_string/2, unregister_subject_string/2, start_dynamic_supervisor/0, get_all_dynamic_children/1, start_dynamic_supervisor_named/1, start_dynamic_supervisor_named_safe/1, child_spec/7, start_dynamic_child/4, terminate_dynamic_child/2, which_dynamic_children/1, count_dynamic_children/1, call_genserver/3, call_genserver_timeout/4, cast_genserver/2, start_genserver/2, start_genserver_named/3, ping_genserver/3, get_genserver_state/3, call_genserver_named/3, cast_genserver_named/2, lookup_genserver/1, stop_genserver/1, genserver_pid/1, start_agent/1, get_agent/3, get_agent_timeout/4, update_agent/2, cast_agent/2, get_and_update_agent/3, stop_agent/2, agent_pid/1, main/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(
    "\n"
    " glixir - Unified OTP interface for Gleam, now type safe!\n"
    " Bounded, phantom-typed supervisors! No more runtime surprises.\n"
    "\n"
).

-file("src/glixir.gleam", 116).
?DOC(" Start a phantom-typed PubSub system\n").
-spec pubsub_start(gleam@erlang@atom:atom_()) -> {ok,
        glixir@pubsub:pub_sub(any())} |
    {error, glixir@pubsub:pub_sub_error()}.
pubsub_start(Name) ->
    glixir@pubsub:start(Name).

-file("src/glixir.gleam", 121).
?DOC(" Subscribe to a topic with message handling\n").
-spec pubsub_subscribe(gleam@erlang@atom:atom_(), binary(), binary(), binary()) -> {ok,
        nil} |
    {error, glixir@pubsub:pub_sub_error()}.
pubsub_subscribe(Pubsub_name, Topic, Gleam_module, Gleam_function) ->
    glixir@pubsub:subscribe(Pubsub_name, Topic, Gleam_module, Gleam_function).

-file("src/glixir.gleam", 130).
-spec pubsub_subscribe_with_registry_key(
    gleam@erlang@atom:atom_(),
    binary(),
    binary(),
    binary(),
    binary()
) -> {ok, nil} | {error, glixir@pubsub:pub_sub_error()}.
pubsub_subscribe_with_registry_key(
    Pubsub_name,
    Topic,
    Gleam_module,
    Gleam_function,
    Registry_key
) ->
    glixir@pubsub:subscribe_with_registry_key(
        Pubsub_name,
        Topic,
        Gleam_module,
        Gleam_function,
        Registry_key
    ).

-file("src/glixir.gleam", 147).
?DOC(" Broadcast a message to all subscribers\n").
-spec pubsub_broadcast(
    gleam@erlang@atom:atom_(),
    binary(),
    FDE,
    fun((FDE) -> binary())
) -> {ok, nil} | {error, glixir@pubsub:pub_sub_error()}.
pubsub_broadcast(Pubsub_name, Topic, Message, Encode) ->
    glixir@pubsub:broadcast(Pubsub_name, Topic, Message, Encode).

-file("src/glixir.gleam", 157).
?DOC(" Unsubscribe from a topic\n").
-spec pubsub_unsubscribe(gleam@erlang@atom:atom_(), binary()) -> {ok, nil} |
    {error, glixir@pubsub:pub_sub_error()}.
pubsub_unsubscribe(Pubsub_name, Topic) ->
    glixir@pubsub:unsubscribe(Pubsub_name, Topic).

-file("src/glixir.gleam", 169).
?DOC(" Start a phantom-typed unique registry (you must specify key_type, message_type)\n").
-spec start_registry(gleam@erlang@atom:atom_()) -> {ok,
        glixir@registry:registry(any(), any())} |
    {error, glixir@registry:registry_error()}.
start_registry(Name) ->
    glixir@registry:start_unique_registry(Name).

-file("src/glixir.gleam", 176).
?DOC(" Start a registry with specific keys configuration\n").
-spec start_registry_with_keys(
    gleam@erlang@atom:atom_(),
    glixir@registry:registry_keys()
) -> {ok, glixir@registry:registry(any(), any())} |
    {error, glixir@registry:registry_error()}.
start_registry_with_keys(Name, Keys) ->
    glixir@registry:start_registry(Name, Keys).

-file("src/glixir.gleam", 184).
?DOC(" Register a subject with a typed key (requires key encoder)\n").
-spec register_subject(
    gleam@erlang@atom:atom_(),
    FDW,
    gleam@erlang@process:subject(any()),
    fun((FDW) -> binary())
) -> {ok, nil} | {error, glixir@registry:registry_error()}.
register_subject(Registry_name, Key, Subject, Encode_key) ->
    glixir@registry:register_subject(Registry_name, Key, Subject, Encode_key).

-file("src/glixir.gleam", 194).
?DOC(" Look up a subject by typed key (requires key encoder)\n").
-spec lookup_subject(gleam@erlang@atom:atom_(), FEC, fun((FEC) -> binary())) -> {ok,
        gleam@erlang@process:subject(any())} |
    {error, glixir@registry:registry_error()}.
lookup_subject(Registry_name, Key, Encode_key) ->
    glixir@registry:lookup_subject(Registry_name, Key, Encode_key).

-file("src/glixir.gleam", 203).
?DOC(" Unregister a subject by typed key (requires key encoder)\n").
-spec unregister_subject(gleam@erlang@atom:atom_(), FEI, fun((FEI) -> binary())) -> {ok,
        nil} |
    {error, glixir@registry:registry_error()}.
unregister_subject(Registry_name, Key, Encode_key) ->
    glixir@registry:unregister_subject(Registry_name, Key, Encode_key).

-file("src/glixir.gleam", 213).
?DOC(
    " SAFE: Register a subject with string key (no dynamic atom creation)\n"
    " Use this for user-generated keys to avoid atom table exhaustion\n"
).
-spec register_subject_string(
    gleam@erlang@atom:atom_(),
    binary(),
    gleam@erlang@process:subject(any())
) -> {ok, nil} | {error, glixir@registry:registry_error()}.
register_subject_string(Registry_name, Key, Subject) ->
    glixir@registry:register_subject_string(Registry_name, Key, Subject).

-file("src/glixir.gleam", 223).
?DOC(
    " SAFE: Look up a subject by string key (no dynamic atom creation)\n"
    " Use this for user-generated keys to avoid atom table exhaustion\n"
).
-spec lookup_subject_string(gleam@erlang@atom:atom_(), binary()) -> {ok,
        gleam@erlang@process:subject(any())} |
    {error, glixir@registry:registry_error()}.
lookup_subject_string(Registry_name, Key) ->
    glixir@registry:lookup_subject_string(Registry_name, Key).

-file("src/glixir.gleam", 232).
?DOC(
    " SAFE: Unregister a subject by string key (no dynamic atom creation)\n"
    " Use this for user-generated keys to avoid atom table exhaustion\n"
).
-spec unregister_subject_string(gleam@erlang@atom:atom_(), binary()) -> {ok,
        nil} |
    {error, glixir@registry:registry_error()}.
unregister_subject_string(Registry_name, Key) ->
    glixir@registry:unregister_subject_string(Registry_name, Key).

-file("src/glixir.gleam", 260).
?DOC(" Start an unnamed dynamic supervisor\n").
-spec start_dynamic_supervisor() -> {ok,
        glixir@supervisor:dynamic_supervisor(any(), any())} |
    {error, glixir@supervisor:supervisor_error()}.
start_dynamic_supervisor() ->
    glixir@utils:debug_log(
        info,
        <<"[glixir] Starting unnamed dynamic supervisor"/utf8>>
    ),
    glixir@supervisor:start_dynamic_supervisor().

-file("src/glixir.gleam", 269).
?DOC(" Get all child processes from a dynamic supervisor\n").
-spec get_all_dynamic_children(glixir@supervisor:dynamic_supervisor(any(), FFD)) -> {ok,
        list(gleam@erlang@process:subject(FFD))} |
    {error, binary()}.
get_all_dynamic_children(Sup) ->
    glixir@utils:debug_log(
        info,
        <<"[glixir] Getting all dynamic children"/utf8>>
    ),
    Result = glixir@supervisor:get_all_dynamic_children(Sup),
    case Result of
        {ok, Children} ->
            glixir@utils:debug_log(
                info,
                <<<<"[glixir] Found "/utf8,
                        (gleam@string:inspect(erlang:length(Children)))/binary>>/binary,
                    " children"/utf8>>
            );

        {error, E} ->
            glixir@utils:debug_log(
                error,
                <<"[glixir] Failed to get children: "/utf8, E/binary>>
            )
    end,
    Result.

-file("src/glixir.gleam", 289).
?DOC(" Start a named dynamic supervisor (you must always specify child_args, child_reply types)\n").
-spec start_dynamic_supervisor_named(gleam@erlang@atom:atom_()) -> {ok,
        glixir@supervisor:dynamic_supervisor(any(), any())} |
    {error, glixir@supervisor:supervisor_error()}.
start_dynamic_supervisor_named(Name) ->
    glixir@utils:debug_log(
        info,
        <<"[glixir] Starting dynamic supervisor: "/utf8,
            (erlang:atom_to_binary(Name))/binary>>
    ),
    case glixir@supervisor:start_dynamic_supervisor_named(Name) of
        {ok, Sup} ->
            glixir@utils:debug_log(
                info,
                <<"[glixir] Dynamic supervisor started successfully"/utf8>>
            ),
            {ok, Sup};

        {error, Error} ->
            glixir@utils:debug_log(
                error,
                <<"[glixir] Dynamic supervisor start failed: "/utf8,
                    (gleam@string:inspect(Error))/binary>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 314).
-spec start_dynamic_supervisor_named_safe(binary()) -> {ok,
        glixir@supervisor:dynamic_supervisor(any(), any())} |
    {error, glixir@supervisor:supervisor_error()}.
start_dynamic_supervisor_named_safe(Name) ->
    glixir@utils:debug_log(
        info,
        <<"[glixir] Starting dynamic supervisor: "/utf8, Name/binary>>
    ),
    case glixir@supervisor:start_dynamic_supervisor_named_safe(Name) of
        {ok, Sup} ->
            glixir@utils:debug_log(
                info,
                <<"[glixir] Dynamic supervisor started successfully"/utf8>>
            ),
            {ok, Sup};

        {error, Error} ->
            glixir@utils:debug_log(
                error,
                <<"[glixir] Dynamic supervisor start failed: "/utf8,
                    (gleam@string:inspect(Error))/binary>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 340).
?DOC(" Build a bounded, type-safe child spec\n").
-spec child_spec(
    binary(),
    binary(),
    binary(),
    FFW,
    glixir@supervisor:restart_strategy(),
    integer(),
    glixir@supervisor:child_type()
) -> glixir@supervisor:child_spec(FFW, any()).
child_spec(Id, Module, Function, Args, Restart, Shutdown_timeout, Child_type) ->
    glixir@supervisor:child_spec(
        Id,
        Module,
        Function,
        Args,
        Restart,
        Shutdown_timeout,
        Child_type
    ).

-file("src/glixir.gleam", 361).
?DOC(" Start a child process in the supervisor (requires encoder/decoder)\n").
-spec start_dynamic_child(
    glixir@supervisor:dynamic_supervisor(FGA, FGB),
    glixir@supervisor:child_spec(FGA, FGB),
    fun((FGA) -> list(gleam@dynamic:dynamic_())),
    fun((gleam@dynamic:dynamic_()) -> {ok, FGB} | {error, binary()})
) -> glixir@supervisor:start_child_result(FGB).
start_dynamic_child(Sup, Spec, Encode, Decode) ->
    glixir@utils:debug_log(
        info,
        <<"[glixir] Starting child: "/utf8, (erlang:element(2, Spec))/binary>>
    ),
    Result = glixir@supervisor:start_dynamic_child(Sup, Spec, Encode, Decode),
    case Result of
        {child_started, _, _} ->
            glixir@utils:debug_log(
                info,
                <<"[glixir] Child started successfully: "/utf8,
                    (erlang:element(2, Spec))/binary>>
            );

        {start_child_error, E} ->
            glixir@utils:debug_log(
                error,
                <<<<<<"[glixir] Child start failed: "/utf8,
                            (erlang:element(2, Spec))/binary>>/binary,
                        " - "/utf8>>/binary,
                    E/binary>>
            )
    end,
    Result.

-file("src/glixir.gleam", 384).
-spec terminate_dynamic_child(
    glixir@supervisor:dynamic_supervisor(any(), any()),
    gleam@erlang@process:pid_()
) -> {ok, nil} | {error, binary()}.
terminate_dynamic_child(Sup, Child_pid) ->
    glixir@utils:debug_log(
        info,
        <<"[glixir] Terminating child: "/utf8,
            (gleam@string:inspect(Child_pid))/binary>>
    ),
    Result = glixir@supervisor:terminate_dynamic_child(Sup, Child_pid),
    case Result of
        {ok, _} ->
            glixir@utils:debug_log(
                info,
                <<"[glixir] Child terminated successfully"/utf8>>
            );

        {error, E} ->
            glixir@utils:debug_log(
                error,
                <<"[glixir] Child termination failed: "/utf8, E/binary>>
            )
    end,
    Result.

-file("src/glixir.gleam", 406).
?DOC(" Get all dynamic children of the supervisor\n").
-spec which_dynamic_children(glixir@supervisor:dynamic_supervisor(any(), any())) -> list(gleam@dynamic:dynamic_()).
which_dynamic_children(Sup) ->
    glixir@utils:debug_log(info, <<"[glixir] Querying dynamic children"/utf8>>),
    glixir@supervisor:which_dynamic_children(Sup).

-file("src/glixir.gleam", 414).
?DOC(" Get the count of dynamic children\n").
-spec count_dynamic_children(glixir@supervisor:dynamic_supervisor(any(), any())) -> {ok,
        glixir@supervisor:child_counts()} |
    {error, binary()}.
count_dynamic_children(Sup) ->
    glixir@utils:debug_log(info, <<"[glixir] Counting dynamic children"/utf8>>),
    glixir@supervisor:count_dynamic_children(Sup).

-file("src/glixir.gleam", 424).
-spec call_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FHB),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FHB)
) -> {ok, FHB} | {error, glixir@genserver:gen_server_error()}.
call_genserver(Server, Request, Decoder) ->
    glixir@genserver:call(Server, Request, Decoder).

-file("src/glixir.gleam", 432).
-spec call_genserver_timeout(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FHH),
    gleam@dynamic:dynamic_(),
    integer(),
    gleam@dynamic@decode:decoder(FHH)
) -> {ok, FHH} | {error, glixir@genserver:gen_server_error()}.
call_genserver_timeout(Server, Request, Timeout, Decoder) ->
    glixir@genserver:call_timeout(Server, Request, Timeout, Decoder).

-file("src/glixir.gleam", 441).
-spec cast_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any()),
    gleam@dynamic:dynamic_()
) -> {ok, nil} | {error, glixir@genserver:gen_server_error()}.
cast_genserver(Server, Request) ->
    glixir@genserver:cast(Server, Request).

-file("src/glixir.gleam", 448).
-spec start_genserver(binary(), gleam@dynamic:dynamic_()) -> {ok,
        glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any())} |
    {error, glixir@genserver:gen_server_error()}.
start_genserver(Module, Args) ->
    glixir@genserver:start_link(Module, Args).

-file("src/glixir.gleam", 455).
-spec start_genserver_named(
    binary(),
    gleam@erlang@atom:atom_(),
    gleam@dynamic:dynamic_()
) -> {ok, glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any())} |
    {error, glixir@genserver:gen_server_error()}.
start_genserver_named(Module, Name, Args) ->
    glixir@genserver:start_link_named(Module, erlang:atom_to_binary(Name), Args).

-file("src/glixir.gleam", 463).
-spec ping_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FIC),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FIC)
) -> {ok, FIC} | {error, glixir@genserver:gen_server_error()}.
ping_genserver(Server, Msg, Decoder) ->
    glixir@genserver:call(Server, Msg, Decoder).

-file("src/glixir.gleam", 471).
-spec get_genserver_state(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FII),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FII)
) -> {ok, FII} | {error, glixir@genserver:gen_server_error()}.
get_genserver_state(Server, Msg, Decoder) ->
    glixir@genserver:call(Server, Msg, Decoder).

-file("src/glixir.gleam", 479).
-spec call_genserver_named(
    gleam@erlang@atom:atom_(),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FIO)
) -> {ok, FIO} | {error, glixir@genserver:gen_server_error()}.
call_genserver_named(Name, Request, Decoder) ->
    glixir@genserver:call_named(Name, Request, Decoder).

-file("src/glixir.gleam", 487).
-spec cast_genserver_named(gleam@erlang@atom:atom_(), gleam@dynamic:dynamic_()) -> {ok,
        nil} |
    {error, glixir@genserver:gen_server_error()}.
cast_genserver_named(Name, Request) ->
    glixir@genserver:cast_named(Name, Request).

-file("src/glixir.gleam", 494).
-spec lookup_genserver(gleam@erlang@atom:atom_()) -> {ok,
        glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any())} |
    {error, glixir@genserver:gen_server_error()}.
lookup_genserver(Name) ->
    glixir@genserver:lookup_name(Name).

-file("src/glixir.gleam", 500).
-spec stop_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any())
) -> {ok, nil} | {error, glixir@genserver:gen_server_error()}.
stop_genserver(Server) ->
    glixir@genserver:stop(Server).

-file("src/glixir.gleam", 506).
-spec genserver_pid(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any())
) -> gleam@erlang@process:pid_().
genserver_pid(Server) ->
    glixir@genserver:pid(Server).

-file("src/glixir.gleam", 513).
-spec start_agent(fun(() -> FJH)) -> {ok, glixir@agent:agent(FJH)} |
    {error, glixir@agent:agent_error()}.
start_agent(State) ->
    glixir@agent:start(State).

-file("src/glixir.gleam", 517).
-spec get_agent(
    glixir@agent:agent(FJL),
    fun((FJL) -> FJN),
    gleam@dynamic@decode:decoder(FJN)
) -> {ok, FJN} | {error, glixir@agent:agent_error()}.
get_agent(Agent, Fun, Decoder) ->
    glixir@agent:get(Agent, Fun, Decoder).

-file("src/glixir.gleam", 525).
-spec get_agent_timeout(
    glixir@agent:agent(FJR),
    fun((FJR) -> FJT),
    integer(),
    gleam@dynamic@decode:decoder(FJT)
) -> {ok, FJT} | {error, glixir@agent:agent_error()}.
get_agent_timeout(Agent, Fun, Timeout, Decoder) ->
    glixir@agent:get_timeout(Agent, Fun, Timeout, Decoder).

-file("src/glixir.gleam", 534).
-spec update_agent(glixir@agent:agent(FJX), fun((FJX) -> FJX)) -> {ok, nil} |
    {error, glixir@agent:agent_error()}.
update_agent(Agent, Fun) ->
    glixir@agent:update(Agent, Fun).

-file("src/glixir.gleam", 538).
-spec cast_agent(glixir@agent:agent(FKB), fun((FKB) -> FKB)) -> nil.
cast_agent(Agent, Fun) ->
    glixir@agent:cast(Agent, Fun).

-file("src/glixir.gleam", 542).
-spec get_and_update_agent(
    glixir@agent:agent(FKD),
    fun((FKD) -> {FKF, FKD}),
    gleam@dynamic@decode:decoder(FKF)
) -> {ok, FKF} | {error, glixir@agent:agent_error()}.
get_and_update_agent(Agent, Fun, Decoder) ->
    glixir@agent:get_and_update(Agent, Fun, Decoder).

-file("src/glixir.gleam", 550).
-spec stop_agent(glixir@agent:agent(any()), gleam@erlang@atom:atom_()) -> {ok,
        nil} |
    {error, glixir@agent:agent_error()}.
stop_agent(Agent, Reason) ->
    glixir@agent:stop(Agent, Reason).

-file("src/glixir.gleam", 554).
-spec agent_pid(glixir@agent:agent(any())) -> gleam@erlang@process:pid_().
agent_pid(Agent) ->
    glixir@agent:pid(Agent).

-file("src/glixir.gleam", 561).
-spec main() -> nil.
main() ->
    logging_ffi:configure().