defmodule Cryptoid.Application do
  @moduledoc "Description of Application"
  @doc "Head of config_change/3"
  @spec config_change(changed :: any, _new :: any, removed :: any) :: any
  def config_change(changed, _new, removed)

  def config_change(changed, _new, removed) do
  end

  @doc "Head of start/2"
  @spec start(_type :: any, _args :: any) :: any
  def start(_type, _args)

  def start(_type, _args) do
  end
end

defmodule Cryptoid.ApplicationTest do
  use ExUnit.Case, async: true
  alias Cryptoid.Application

  describe("config_change / 3") do
    test "fun config_change" do
    end
  end

  describe("start / 2") do
    test "fun start" do
    end
  end
end

defmodule Cryptoid.Mailer do
  @moduledoc "Description of Mailer"
end

defmodule Cryptoid.MailerTest do
  use ExUnit.Case, async: true
  alias Cryptoid.Mailer
end

defmodule Cryptoid.Rates do
  @moduledoc "Rates parser"
  @path [] = list
  @doc "Head of get/0"
  @spec get() :: any
  def get()

  def get() do
  end

  @doc "Head of parse/1"
  @spec parse(map :: map) :: any
  def parse(map)

  def parse(map) do
  end
end

defmodule Cryptoid.RatesTest do
  use ExUnit.Case, async: true
  alias Cryptoid.Rates

  describe("get / 0") do
    test "fun get" do
    end
  end

  describe("parse / 1") do
    test "fun parse" do
    end
  end
end

defmodule Cryptoid.Request do
  @moduledoc "CoinMarketCap api request"
  @base_url [] = list
  @doc "Head of get/1"
  @spec get(path :: any) :: any
  def get(path)

  def get(path) do
  end

  @doc "Head of handle_response/1"
  @spec handle_response(tuple :: tuple) :: any
  def handle_response(tuple)

  def handle_response(tuple) do
  end
end

defmodule Cryptoid.RequestTest do
  use ExUnit.Case, async: true
  alias Cryptoid.Request

  describe("get / 1") do
    test "fun get" do
    end
  end

  describe("handle_response / 1") do
    test "fun handle_response" do
    end
  end
end

defmodule Cryptoid.Scheduler do
  @moduledoc "Description of Scheduler"
  @timeout 60000
  @doc "Head of handle_info/2"
  @spec handle_info(atom :: atom, state :: any) :: any
  def handle_info(atom, state)

  def handle_info(atom, state) do
  end

  @doc "Head of init/1"
  @spec init(count :: any) :: any
  def init(count)

  def init(count) do
  end

  @doc "Head of start_link/1"
  @spec start_link(count :: any) :: any
  def start_link(count)

  def start_link(count) do
  end
end

defmodule Cryptoid.SchedulerTest do
  use ExUnit.Case, async: true
  alias Cryptoid.Scheduler

  describe("handle_info / 2") do
    test "fun handle_info" do
    end
  end

  describe("init / 1") do
    test "fun init" do
    end
  end

  describe("start_link / 1") do
    test "fun start_link" do
    end
  end
end

defmodule Cryptoid.Storage do
  @moduledoc "Counter module, which accepts stream"
  @doc "Head of currencies/0"
  @spec currencies() :: any
  def currencies()

  def currencies() do
  end

  @doc "Head of rate/1"
  @spec rate(currency :: any) :: any
  def rate(currency)

  def rate(currency) do
  end

  @doc "Head of start_link/1"
  @spec start_link(_initial_value :: any) :: any
  def start_link(_initial_value)

  def start_link(_initial_value) do
  end

  @doc "Head of update/1"
  @spec update(rates :: any) :: any
  def update(rates)

  def update(rates) do
  end
end

defmodule Cryptoid.StorageTest do
  use ExUnit.Case, async: true
  alias Cryptoid.Storage

  describe("currencies / 0") do
    test "fun currencies" do
    end
  end

  describe("rate / 1") do
    test "fun rate" do
    end
  end

  describe("start_link / 1") do
    test "fun start_link" do
    end
  end

  describe("update / 1") do
    test "fun update" do
    end
  end
end

defmodule Cryptoid.System do
  @moduledoc "Supervisor for Cache"
  @doc "Head of child_spec/1"
  @spec child_spec(_ :: any) :: any
  def child_spec(_)

  def child_spec(_) do
  end

  @doc "Head of start_link/0"
  @spec start_link() :: any
  def start_link()

  def start_link() do
  end

  @doc "Head of start_link/2"
  @spec start_link(_type :: any, _args :: any) :: any
  def start_link(_type, _args)

  def start_link(_type, _args) do
  end
end

defmodule Cryptoid.SystemTest do
  use ExUnit.Case, async: true
  alias Cryptoid.System

  describe("child_spec / 1") do
    test "fun child_spec" do
    end
  end

  describe("start_link / 0") do
    test "fun start_link" do
    end
  end

  describe("start_link / 2") do
    test "fun start_link" do
    end
  end
end