     :ok
   end
 
-  @doc """
-  Sends a sync event notification to the event `manager`.
-
-  In other words, this function only returns `:ok` after the event manager
-  invokes the `c:handle_event/2` callback on each installed event handler.
-
-  See `notify/2` for more info.
-  """
   @spec sync_notify(manager, term) :: :ok
   def sync_notify(manager, event) do
     rpc(manager, {:sync_notify, event})
   end
 
-  @doc """
-  Sends an ack event notification to the event `manager`.
-
-  In other words, this function only returns `:ok` as soon as the
-  event manager starts processing this event, but it does not wait
-  for event handlers to process the sent event.
-
-  See `notify/2` for more info. Note this function is specific
-  to Elixir's GenEvent and does not work with Erlang ones.
-  """
   @spec ack_notify(manager, term) :: :ok
   def ack_notify(manager, event) do
     rpc(manager, {:ack_notify, event})
   end
 
-  @doc """
-  Makes a synchronous call to the event `handler` installed in `manager`.
-
-  The given `request` is sent and the caller waits until a reply arrives or
-  a timeout occurs. The event manager will call `c:handle_call/2` to handle
-  the request.
-
-  The return value `reply` is defined in the return value of `c:handle_call/2`.
-  If the specified event handler is not installed, the function returns
-  `{:error, :not_found}`.
-  """
   @spec call(manager, handler, term, timeout) ::  term | {:error, term}
   def call(manager, handler, request, timeout \\ 5000) do
     try do

    end
  end

  @doc """
  Starts an event manager linked to the current process.

  This is often used to start the `GenEvent` as part of a supervision tree.

  It accepts the `:name` option which is described under the `Name Registration`
  section in the `GenServer` module docs.

  If the event manager is successfully created and initialized, the function
  returns `{:ok, pid}`, where `pid` is the PID of the server. If a process with
  the specified server name already exists, the function returns
  `{:error, {:already_started, pid}}` with the PID of that process.

  Note that a `GenEvent` started with `start_link/1` is linked to the
  parent process and will exit not only on crashes but also if the parent
  process exits with `:normal` reason.
  """
  @spec start_link(options) :: on_start
  def start_link(options \\ []) when is_list(options) do
    do_start(:link, options)
  end

  @doc """
  Starts an event manager process without links (outside of a supervision tree).

  See `start_link/1` for more information.
  """
  @spec start(options) :: on_start
  def start(options \\ []) when is_list(options) do
    do_start(:nolink, options)

defmodule GenEvent do
  # TODO: Deprecate by 1.6 (hard deprecation)

  @moduledoc """
  WARNING: this module is deprecated.

  If you need the same functionality, you can use the `:gen_event` Erlang
  module.
  """

  @callback init(args :: term) ::
    {:ok, state} |
    {:ok, state, :hibernate} |
    {:error, reason :: any} when state: any

  @callback handle_event(event :: term, state :: term) ::
    {:ok, new_state} |
    {:ok, new_state, :hibernate} |
    :remove_handler when new_state: term

  @callback handle_call(request :: term, state :: term) ::
    {:ok, reply, new_state} |
    {:ok, reply, new_state, :hibernate} |
    {:remove_handler, reply} when reply: term, new_state: term

  @callback handle_info(msg :: term, state :: term) ::
    {:ok, new_state} |
    {:ok, new_state, :hibernate} |
    :remove_handler when new_state: term

  @callback terminate(reason, state :: term) ::
    term when reason: :stop | {:stop, term} | :remove_handler | {:error, term} | term

  @callback code_change(old_vsn, state :: term, extra :: term) ::
    {:ok, new_state :: term} when old_vsn: term | {:down, term}

  @type on_start :: {:ok, pid} | {:error, {:already_started, pid}}

  @type name :: atom | {:global, term} | {:via, module, term}

  @type options :: [name: name]

  @type manager :: pid | name | {atom, node}

  @type handler :: atom | {atom, term}

  @doc false
