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, start_dynamic_supervisor_named_safed/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", 115).
?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", 120).
?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", 129).
-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", 146).
?DOC(" Broadcast a message to all subscribers\n").
-spec pubsub_broadcast(
    gleam@erlang@atom:atom_(),
    binary(),
    FJA,
    fun((FJA) -> 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", 156).
?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", 168).
?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", 175).
?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", 183).
?DOC(" Register a subject with a typed key (requires key encoder)\n").
-spec register_subject(
    gleam@erlang@atom:atom_(),
    FJS,
    gleam@erlang@process:subject(any()),
    fun((FJS) -> 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", 193).
?DOC(" Look up a subject by typed key (requires key encoder)\n").
-spec lookup_subject(gleam@erlang@atom:atom_(), FJY, fun((FJY) -> 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", 202).
?DOC(" Unregister a subject by typed key (requires key encoder)\n").
-spec unregister_subject(gleam@erlang@atom:atom_(), FKE, fun((FKE) -> 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", 212).
?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", 222).
?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", 231).
?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", 259).
?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", 284).
-spec start_dynamic_supervisor_named_safed(binary()) -> {ok,
        glixir@supervisor:dynamic_supervisor(any(), any())} |
    {error, glixir@supervisor:supervisor_error()}.
start_dynamic_supervisor_named_safed(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", 310).
?DOC(" Build a bounded, type-safe child spec\n").
-spec child_spec(
    binary(),
    binary(),
    binary(),
    FLE,
    glixir@supervisor:restart_strategy(),
    integer(),
    glixir@supervisor:child_type()
) -> glixir@supervisor:child_spec(FLE, 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", 331).
?DOC(" Start a child process in the supervisor (requires encoder/decoder)\n").
-spec start_dynamic_child(
    glixir@supervisor:dynamic_supervisor(FLI, FLJ),
    glixir@supervisor:child_spec(FLI, FLJ),
    fun((FLI) -> list(gleam@dynamic:dynamic_())),
    fun((gleam@dynamic:dynamic_()) -> {ok, FLJ} | {error, binary()})
) -> glixir@supervisor:start_child_result(FLJ).
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", 354).
-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", 376).
?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", 384).
?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", 394).
-spec call_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FMJ),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FMJ)
) -> {ok, FMJ} | {error, glixir@genserver:gen_server_error()}.
call_genserver(Server, Request, Decoder) ->
    glixir@genserver:call(Server, Request, Decoder).

-file("src/glixir.gleam", 402).
-spec call_genserver_timeout(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FMP),
    gleam@dynamic:dynamic_(),
    integer(),
    gleam@dynamic@decode:decoder(FMP)
) -> {ok, FMP} | {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", 411).
-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", 418).
-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", 425).
-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", 433).
-spec ping_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FNK),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FNK)
) -> {ok, FNK} | {error, glixir@genserver:gen_server_error()}.
ping_genserver(Server, Msg, Decoder) ->
    glixir@genserver:call(Server, Msg, Decoder).

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

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

-file("src/glixir.gleam", 457).
-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", 464).
-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", 470).
-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", 476).
-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", 483).
-spec start_agent(fun(() -> FOP)) -> {ok, glixir@agent:agent(FOP)} |
    {error, glixir@agent:agent_error()}.
start_agent(State) ->
    glixir@agent:start(State).

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

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

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

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

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

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

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