glixir

-module(glixir).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-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_named/1, child_spec/8, 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", 118).
?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", 123).
?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", 132).
-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", 149).
?DOC(" Broadcast a message to all subscribers\n").
-spec pubsub_broadcast(
    gleam@erlang@atom:atom_(),
    binary(),
    FJI,
    fun((FJI) -> 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", 159).
?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", 171).
?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", 178).
?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", 186).
?DOC(" Register a subject with a typed key (requires key encoder)\n").
-spec register_subject(
    gleam@erlang@atom:atom_(),
    FKA,
    gleam@erlang@process:subject(any()),
    fun((FKA) -> 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", 196).
?DOC(" Look up a subject by typed key (requires key encoder)\n").
-spec lookup_subject(gleam@erlang@atom:atom_(), FKG, fun((FKG) -> 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", 205).
?DOC(" Unregister a subject by typed key (requires key encoder)\n").
-spec unregister_subject(gleam@erlang@atom:atom_(), FKM, fun((FKM) -> 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", 215).
?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", 225).
?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", 234).
?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", 262).
?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", 288).
?DOC(" Build a bounded, type-safe child spec\n").
-spec child_spec(
    binary(),
    binary(),
    binary(),
    FLG,
    glixir@supervisor:restart_strategy(),
    integer(),
    glixir@supervisor:child_type(),
    fun((FLG) -> list(gleam@dynamic:dynamic_()))
) -> glixir@supervisor:child_spec(FLG, any()).
child_spec(
    Id,
    Module,
    Function,
    Args,
    Restart,
    Shutdown_timeout,
    Child_type,
    Encode
) ->
    glixir@supervisor:child_spec(
        Id,
        Module,
        Function,
        Args,
        Restart,
        Shutdown_timeout,
        Child_type,
        Encode
    ).

-file("src/glixir.gleam", 311).
?DOC(" Start a child process in the supervisor (requires encoder/decoder)\n").
-spec start_dynamic_child(
    glixir@supervisor:dynamic_supervisor(FLL, FLM),
    glixir@supervisor:child_spec(FLL, FLM),
    fun((FLL) -> list(gleam@dynamic:dynamic_())),
    fun((gleam@dynamic:dynamic_()) -> {ok, FLM} | {error, binary()})
) -> glixir@supervisor:start_child_result(FLM).
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, Pid, Reply} ->
            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", 334).
-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", 356).
?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", 364).
?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", 374).
-spec call_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FMM),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FMM)
) -> {ok, FMM} | {error, glixir@genserver:gen_server_error()}.
call_genserver(Server, Request, Decoder) ->
    glixir@genserver:call(Server, Request, Decoder).

-file("src/glixir.gleam", 382).
-spec call_genserver_timeout(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FMS),
    gleam@dynamic:dynamic_(),
    integer(),
    gleam@dynamic@decode:decoder(FMS)
) -> {ok, FMS} | {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", 391).
-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", 398).
-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", 405).
-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", 413).
-spec ping_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FNN),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FNN)
) -> {ok, FNN} | {error, glixir@genserver:gen_server_error()}.
ping_genserver(Server, Msg, Decoder) ->
    glixir@genserver:call(Server, Msg, Decoder).

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

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

-file("src/glixir.gleam", 437).
-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", 444).
-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", 450).
-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", 456).
-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", 463).
-spec start_agent(fun(() -> FOS)) -> {ok, glixir@agent:agent(FOS)} |
    {error, glixir@agent:agent_error()}.
start_agent(State) ->
    glixir@agent:start(State).

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

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

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

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

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

-file("src/glixir.gleam", 500).
-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", 504).
-spec agent_pid(glixir@agent:agent(any())) -> gleam@erlang@process:pid_().
agent_pid(Agent) ->
    glixir@agent:pid(Agent).

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