traccar

# NOTE: This class is auto generated by the swagger code generator program.
# https://github.com/swagger-api/swagger-codegen.git
# Do not edit the class manually.

defmodule Traccar.Api.Default do
  @moduledoc """
  API calls for all endpoints tagged `Default`.
  """

  alias Traccar.Connection
  import Traccar.RequestBuilder


  @doc """
  Fetch a list of Attributes
  Without params, it returns a list of Attributes the user has access to

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :all (boolean()): Can only be used by admins or managers to fetch all entities
    - :user_id (integer()): Standard users can use this only with their own _userId_
    - :device_id (integer()): Standard users can use this only with _deviceId_s, they have access to
    - :group_id (integer()): Standard users can use this only with _groupId_s, they have access to
    - :refresh (boolean()): 

  ## Returns

  {:ok, [%Attribute{}, ...]} on success
  {:error, info} on failure
  """
  @spec attributes_computed_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.Attribute.t)} | {:error, Tesla.Env.t}
  def attributes_computed_get(connection, opts \\ []) do
    optional_params = %{
      :"all" => :query,
      :"userId" => :query,
      :"deviceId" => :query,
      :"groupId" => :query,
      :"refresh" => :query
    }
    %{}
    |> method(:get)
    |> url("/attributes/computed")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Attribute{}])
  end

  @doc """
  Delete an Attribute

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec attributes_computed_id_delete(Tesla.Env.client, integer(), keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def attributes_computed_id_delete(connection, id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/attributes/computed/#{id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Update an Attribute

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - body (Attribute): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Attribute{}} on success
  {:error, info} on failure
  """
  @spec attributes_computed_id_put(Tesla.Env.client, integer(), Traccar.Model.Attribute.t, keyword()) :: {:ok, Traccar.Model.Attribute.t} | {:error, Tesla.Env.t}
  def attributes_computed_id_put(connection, id, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/attributes/computed/#{id}")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Attribute{})
  end

  @doc """
  Create an Attribute

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Attribute): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Attribute{}} on success
  {:error, info} on failure
  """
  @spec attributes_computed_post(Tesla.Env.client, Traccar.Model.Attribute.t, keyword()) :: {:ok, Traccar.Model.Attribute.t} | {:error, Tesla.Env.t}
  def attributes_computed_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/attributes/computed")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Attribute{})
  end

  @doc """
  Fetch a list of Calendars
  Without params, it returns a list of Calendars the user has access to

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :all (boolean()): Can only be used by admins or managers to fetch all entities
    - :user_id (integer()): Standard users can use this only with their own _userId_

  ## Returns

  {:ok, [%Calendar{}, ...]} on success
  {:error, info} on failure
  """
  @spec calendars_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.Calendar.t)} | {:error, Tesla.Env.t}
  def calendars_get(connection, opts \\ []) do
    optional_params = %{
      :"all" => :query,
      :"userId" => :query
    }
    %{}
    |> method(:get)
    |> url("/calendars")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Calendar{}])
  end

  @doc """
  Delete a Calendar

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec calendars_id_delete(Tesla.Env.client, integer(), keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def calendars_id_delete(connection, id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/calendars/#{id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Update a Calendar

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - body (Calendar): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Calendar{}} on success
  {:error, info} on failure
  """
  @spec calendars_id_put(Tesla.Env.client, integer(), Traccar.Model.Calendar.t, keyword()) :: {:ok, Traccar.Model.Calendar.t} | {:error, Tesla.Env.t}
  def calendars_id_put(connection, id, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/calendars/#{id}")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Calendar{})
  end

  @doc """
  Create a Calendar

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Calendar): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Calendar{}} on success
  {:error, info} on failure
  """
  @spec calendars_post(Tesla.Env.client, Traccar.Model.Calendar.t, keyword()) :: {:ok, Traccar.Model.Calendar.t} | {:error, Tesla.Env.t}
  def calendars_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/calendars")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Calendar{})
  end

  @doc """
  Fetch a list of Saved Commands
  Without params, it returns a list of Drivers the user has access to

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :all (boolean()): Can only be used by admins or managers to fetch all entities
    - :user_id (integer()): Standard users can use this only with their own _userId_
    - :device_id (integer()): Standard users can use this only with _deviceId_s, they have access to
    - :group_id (integer()): Standard users can use this only with _groupId_s, they have access to
    - :refresh (boolean()): 

  ## Returns

  {:ok, [%Command{}, ...]} on success
  {:error, info} on failure
  """
  @spec commands_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.Command.t)} | {:error, Tesla.Env.t}
  def commands_get(connection, opts \\ []) do
    optional_params = %{
      :"all" => :query,
      :"userId" => :query,
      :"deviceId" => :query,
      :"groupId" => :query,
      :"refresh" => :query
    }
    %{}
    |> method(:get)
    |> url("/commands")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Command{}])
  end

  @doc """
  Delete a Saved Command

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec commands_id_delete(Tesla.Env.client, integer(), keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def commands_id_delete(connection, id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/commands/#{id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Update a Saved Command

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - body (Command): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Command{}} on success
  {:error, info} on failure
  """
  @spec commands_id_put(Tesla.Env.client, integer(), Traccar.Model.Command.t, keyword()) :: {:ok, Traccar.Model.Command.t} | {:error, Tesla.Env.t}
  def commands_id_put(connection, id, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/commands/#{id}")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Command{})
  end

  @doc """
  Create a Saved Command

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Command): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Command{}} on success
  {:error, info} on failure
  """
  @spec commands_post(Tesla.Env.client, Traccar.Model.Command.t, keyword()) :: {:ok, Traccar.Model.Command.t} | {:error, Tesla.Env.t}
  def commands_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/commands")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Command{})
  end

  @doc """
  Fetch a list of Saved Commands supported by Device at the moment
  Return a list of saved commands linked to Device and its groups, filtered by current Device protocol support

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :device_id (integer()): Standard users can use this only with _deviceId_s, they have access to

  ## Returns

  {:ok, [%Command{}, ...]} on success
  {:error, info} on failure
  """
  @spec commands_send_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.Command.t)} | {:error, Tesla.Env.t}
  def commands_send_get(connection, opts \\ []) do
    optional_params = %{
      :"deviceId" => :query
    }
    %{}
    |> method(:get)
    |> url("/commands/send")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Command{}])
  end

  @doc """
  Dispatch commands to device
  Dispatch a new command or Saved Command if _body.id_ set

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Command): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Command{}} on success
  {:error, info} on failure
  """
  @spec commands_send_post(Tesla.Env.client, Traccar.Model.Command.t, keyword()) :: {:ok, Traccar.Model.Command.t} | {:error, Tesla.Env.t}
  def commands_send_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/commands/send")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Command{})
  end

  @doc """
  Fetch a list of available Commands for the Device or all possible Commands if Device ommited

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :device_id (integer()): 
    - :text_channel (boolean()): 

  ## Returns

  {:ok, [%CommandType{}, ...]} on success
  {:error, info} on failure
  """
  @spec commands_types_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.CommandType.t)} | {:error, Tesla.Env.t}
  def commands_types_get(connection, opts \\ []) do
    optional_params = %{
      :"deviceId" => :query,
      :"textChannel" => :query
    }
    %{}
    |> method(:get)
    |> url("/commands/types")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.CommandType{}])
  end

  @doc """
  Fetch a list of Devices
  Without any params, returns a list of the user's devices

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :all (boolean()): Can only be used by admins or managers to fetch all entities
    - :user_id (integer()): Standard users can use this only with their own _userId_
    - :id (integer()): To fetch one or more devices. Multiple params can be passed like `id=31&id=42`
    - :unique_id (String.t): To fetch one or more devices. Multiple params can be passed like `uniqueId=333331&uniqieId=44442`

  ## Returns

  {:ok, [%Device{}, ...]} on success
  {:error, info} on failure
  """
  @spec devices_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.Device.t)} | {:error, Tesla.Env.t}
  def devices_get(connection, opts \\ []) do
    optional_params = %{
      :"all" => :query,
      :"userId" => :query,
      :"id" => :query,
      :"uniqueId" => :query
    }
    %{}
    |> method(:get)
    |> url("/devices")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Device{}])
  end

  @doc """
  Delete a Device

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec devices_id_delete(Tesla.Env.client, integer(), keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def devices_id_delete(connection, id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/devices/#{id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Update the distance counter of the Device

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - body (DeviceTotalDistance): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec devices_id_distance_put(Tesla.Env.client, integer(), Traccar.Model.DeviceTotalDistance.t, keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def devices_id_distance_put(connection, id, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/devices/#{id}/distance")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Update a Device

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - body (Device): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Device{}} on success
  {:error, info} on failure
  """
  @spec devices_id_put(Tesla.Env.client, integer(), Traccar.Model.Device.t, keyword()) :: {:ok, Traccar.Model.Device.t} | {:error, Tesla.Env.t}
  def devices_id_put(connection, id, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/devices/#{id}")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Device{})
  end

  @doc """
  Create a Device

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Device): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Device{}} on success
  {:error, info} on failure
  """
  @spec devices_post(Tesla.Env.client, Traccar.Model.Device.t, keyword()) :: {:ok, Traccar.Model.Device.t} | {:error, Tesla.Env.t}
  def devices_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/devices")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Device{})
  end

  @doc """
  Fetch a list of Drivers
  Without params, it returns a list of Drivers the user has access to

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :all (boolean()): Can only be used by admins or managers to fetch all entities
    - :user_id (integer()): Standard users can use this only with their own _userId_
    - :device_id (integer()): Standard users can use this only with _deviceId_s, they have access to
    - :group_id (integer()): Standard users can use this only with _groupId_s, they have access to
    - :refresh (boolean()): 

  ## Returns

  {:ok, [%Driver{}, ...]} on success
  {:error, info} on failure
  """
  @spec drivers_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.Driver.t)} | {:error, Tesla.Env.t}
  def drivers_get(connection, opts \\ []) do
    optional_params = %{
      :"all" => :query,
      :"userId" => :query,
      :"deviceId" => :query,
      :"groupId" => :query,
      :"refresh" => :query
    }
    %{}
    |> method(:get)
    |> url("/drivers")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Driver{}])
  end

  @doc """
  Delete a Driver

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec drivers_id_delete(Tesla.Env.client, integer(), keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def drivers_id_delete(connection, id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/drivers/#{id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Update a Driver

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - body (Driver): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Driver{}} on success
  {:error, info} on failure
  """
  @spec drivers_id_put(Tesla.Env.client, integer(), Traccar.Model.Driver.t, keyword()) :: {:ok, Traccar.Model.Driver.t} | {:error, Tesla.Env.t}
  def drivers_id_put(connection, id, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/drivers/#{id}")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Driver{})
  end

  @doc """
  Create a Driver

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Driver): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Driver{}} on success
  {:error, info} on failure
  """
  @spec drivers_post(Tesla.Env.client, Traccar.Model.Driver.t, keyword()) :: {:ok, Traccar.Model.Driver.t} | {:error, Tesla.Env.t}
  def drivers_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/drivers")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Driver{})
  end

  @doc """

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Event{}} on success
  {:error, info} on failure
  """
  @spec events_id_get(Tesla.Env.client, integer(), keyword()) :: {:ok, Traccar.Model.Event.t} | {:error, Tesla.Env.t}
  def events_id_get(connection, id, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/events/#{id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Event{})
  end

  @doc """
  Fetch a list of Geofences
  Without params, it returns a list of Geofences the user has access to

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :all (boolean()): Can only be used by admins or managers to fetch all entities
    - :user_id (integer()): Standard users can use this only with their own _userId_
    - :device_id (integer()): Standard users can use this only with _deviceId_s, they have access to
    - :group_id (integer()): Standard users can use this only with _groupId_s, they have access to
    - :refresh (boolean()): 

  ## Returns

  {:ok, [%Geofence{}, ...]} on success
  {:error, info} on failure
  """
  @spec geofences_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.Geofence.t)} | {:error, Tesla.Env.t}
  def geofences_get(connection, opts \\ []) do
    optional_params = %{
      :"all" => :query,
      :"userId" => :query,
      :"deviceId" => :query,
      :"groupId" => :query,
      :"refresh" => :query
    }
    %{}
    |> method(:get)
    |> url("/geofences")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Geofence{}])
  end

  @doc """
  Delete a Geofence

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec geofences_id_delete(Tesla.Env.client, integer(), keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def geofences_id_delete(connection, id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/geofences/#{id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Update a Geofence

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - body (Geofence): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Geofence{}} on success
  {:error, info} on failure
  """
  @spec geofences_id_put(Tesla.Env.client, integer(), Traccar.Model.Geofence.t, keyword()) :: {:ok, Traccar.Model.Geofence.t} | {:error, Tesla.Env.t}
  def geofences_id_put(connection, id, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/geofences/#{id}")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Geofence{})
  end

  @doc """
  Create a Geofence

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Geofence): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Geofence{}} on success
  {:error, info} on failure
  """
  @spec geofences_post(Tesla.Env.client, Traccar.Model.Geofence.t, keyword()) :: {:ok, Traccar.Model.Geofence.t} | {:error, Tesla.Env.t}
  def geofences_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/geofences")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Geofence{})
  end

  @doc """
  Fetch a list of Groups
  Without any params, returns a list of the Groups the user belongs to

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :all (boolean()): Can only be used by admins or managers to fetch all entities
    - :user_id (integer()): Standard users can use this only with their own _userId_

  ## Returns

  {:ok, [%Group{}, ...]} on success
  {:error, info} on failure
  """
  @spec groups_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.Group.t)} | {:error, Tesla.Env.t}
  def groups_get(connection, opts \\ []) do
    optional_params = %{
      :"all" => :query,
      :"userId" => :query
    }
    %{}
    |> method(:get)
    |> url("/groups")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Group{}])
  end

  @doc """
  Delete a Group

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec groups_id_delete(Tesla.Env.client, integer(), keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def groups_id_delete(connection, id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/groups/#{id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Update a Group

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - body (Group): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Group{}} on success
  {:error, info} on failure
  """
  @spec groups_id_put(Tesla.Env.client, integer(), Traccar.Model.Group.t, keyword()) :: {:ok, Traccar.Model.Group.t} | {:error, Tesla.Env.t}
  def groups_id_put(connection, id, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/groups/#{id}")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Group{})
  end

  @doc """
  Create a Group

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Group): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Group{}} on success
  {:error, info} on failure
  """
  @spec groups_post(Tesla.Env.client, Traccar.Model.Group.t, keyword()) :: {:ok, Traccar.Model.Group.t} | {:error, Tesla.Env.t}
  def groups_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/groups")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Group{})
  end

  @doc """
  Fetch a list of Maintenances
  Without params, it returns a list of Maintenances the user has access to

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :all (boolean()): Can only be used by admins or managers to fetch all entities
    - :user_id (integer()): Standard users can use this only with their own _userId_
    - :device_id (integer()): Standard users can use this only with _deviceId_s, they have access to
    - :group_id (integer()): Standard users can use this only with _groupId_s, they have access to
    - :refresh (boolean()): 

  ## Returns

  {:ok, [%Maintenance{}, ...]} on success
  {:error, info} on failure
  """
  @spec maintenances_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.Maintenance.t)} | {:error, Tesla.Env.t}
  def maintenances_get(connection, opts \\ []) do
    optional_params = %{
      :"all" => :query,
      :"userId" => :query,
      :"deviceId" => :query,
      :"groupId" => :query,
      :"refresh" => :query
    }
    %{}
    |> method(:get)
    |> url("/maintenances")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Maintenance{}])
  end

  @doc """
  Delete a Maintenance

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec maintenances_id_delete(Tesla.Env.client, integer(), keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def maintenances_id_delete(connection, id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/maintenances/#{id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Update a Maintenance

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - body (Maintenance): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Maintenance{}} on success
  {:error, info} on failure
  """
  @spec maintenances_id_put(Tesla.Env.client, integer(), Traccar.Model.Maintenance.t, keyword()) :: {:ok, Traccar.Model.Maintenance.t} | {:error, Tesla.Env.t}
  def maintenances_id_put(connection, id, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/maintenances/#{id}")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Maintenance{})
  end

  @doc """
  Create a Maintenance

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Maintenance): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Maintenance{}} on success
  {:error, info} on failure
  """
  @spec maintenances_post(Tesla.Env.client, Traccar.Model.Maintenance.t, keyword()) :: {:ok, Traccar.Model.Maintenance.t} | {:error, Tesla.Env.t}
  def maintenances_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/maintenances")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Maintenance{})
  end

  @doc """
  Fetch a list of Notifications
  Without params, it returns a list of Notifications the user has access to

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :all (boolean()): Can only be used by admins or managers to fetch all entities
    - :user_id (integer()): Standard users can use this only with their own _userId_
    - :device_id (integer()): Standard users can use this only with _deviceId_s, they have access to
    - :group_id (integer()): Standard users can use this only with _groupId_s, they have access to
    - :refresh (boolean()): 

  ## Returns

  {:ok, [%Notification{}, ...]} on success
  {:error, info} on failure
  """
  @spec notifications_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.Notification.t)} | {:error, Tesla.Env.t}
  def notifications_get(connection, opts \\ []) do
    optional_params = %{
      :"all" => :query,
      :"userId" => :query,
      :"deviceId" => :query,
      :"groupId" => :query,
      :"refresh" => :query
    }
    %{}
    |> method(:get)
    |> url("/notifications")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Notification{}])
  end

  @doc """
  Delete a Notification

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec notifications_id_delete(Tesla.Env.client, integer(), keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def notifications_id_delete(connection, id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/notifications/#{id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Update a Notification

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - body (Notification): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Notification{}} on success
  {:error, info} on failure
  """
  @spec notifications_id_put(Tesla.Env.client, integer(), Traccar.Model.Notification.t, keyword()) :: {:ok, Traccar.Model.Notification.t} | {:error, Tesla.Env.t}
  def notifications_id_put(connection, id, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/notifications/#{id}")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Notification{})
  end

  @doc """
  Create a Notification

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Notification): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Notification{}} on success
  {:error, info} on failure
  """
  @spec notifications_post(Tesla.Env.client, Traccar.Model.Notification.t, keyword()) :: {:ok, Traccar.Model.Notification.t} | {:error, Tesla.Env.t}
  def notifications_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/notifications")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Notification{})
  end

  @doc """
  Send test notification to current user via Email and SMS

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec notifications_test_post(Tesla.Env.client, keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def notifications_test_post(connection, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/notifications/test")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Fetch a list of available Notification types

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, [%NotificationType{}, ...]} on success
  {:error, info} on failure
  """
  @spec notifications_types_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.NotificationType.t)} | {:error, Tesla.Env.t}
  def notifications_types_get(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/notifications/types")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.NotificationType{}])
  end

  @doc """
  Unlink an Object from another Object

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Permission): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec permissions_delete(Tesla.Env.client, Traccar.Model.Permission.t, keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def permissions_delete(connection, body, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/permissions")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Link an Object to another Object

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Permission): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Permission{}} on success
  {:error, info} on failure
  """
  @spec permissions_post(Tesla.Env.client, Traccar.Model.Permission.t, keyword()) :: {:ok, Traccar.Model.Permission.t} | {:error, Tesla.Env.t}
  def permissions_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/permissions")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Permission{})
  end

  @doc """
  Fetches a list of Positions
  Without any params, it returns a list of last known positions for all the user's Devices. _from_ and _to_ fields are not required with _id_

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :device_id (integer()): _deviceId_ is optional, but requires the _from_ and _to_ parameters when used
    - :from (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
    - :to (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
    - :id (integer()): To fetch one or more positions. Multiple params can be passed like `id=31&id=42`

  ## Returns

  {:ok, [%Position{}, ...]} on success
  {:error, info} on failure
  """
  @spec positions_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.Position.t)} | {:error, Tesla.Env.t}
  def positions_get(connection, opts \\ []) do
    optional_params = %{
      :"deviceId" => :query,
      :"from" => :query,
      :"to" => :query,
      :"id" => :query
    }
    %{}
    |> method(:get)
    |> url("/positions")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Position{}])
  end

  @doc """
  Fetch a list of Events within the time period for the Devices or Groups
  At least one _deviceId_ or one _groupId_ must be passed

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - from (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - to (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - opts (KeywordList): [optional] Optional parameters
    - :device_id ([integer()]): 
    - :group_id ([integer()]): 
    - :type ([String.t]): % can be used to return events of all types

  ## Returns

  {:ok, [%Event{}, ...]} on success
  {:error, info} on failure
  """
  @spec reports_events_get(Tesla.Env.client, DateTime.t, DateTime.t, keyword()) :: {:ok, list(Traccar.Model.Event.t)} | {:error, Tesla.Env.t}
  def reports_events_get(connection, from, to, opts \\ []) do
    optional_params = %{
      :"deviceId" => :query,
      :"groupId" => :query,
      :"type" => :query
    }
    %{}
    |> method(:get)
    |> url("/reports/events")
    |> add_param(:query, :"from", from)
    |> add_param(:query, :"to", to)
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Event{}])
  end

  @doc """
  Fetch a list of Positions within the time period for the Devices or Groups
  At least one _deviceId_ or one _groupId_ must be passed

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - from (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - to (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - opts (KeywordList): [optional] Optional parameters
    - :device_id ([integer()]): 
    - :group_id ([integer()]): 

  ## Returns

  {:ok, [%Position{}, ...]} on success
  {:error, info} on failure
  """
  @spec reports_route_get(Tesla.Env.client, DateTime.t, DateTime.t, keyword()) :: {:ok, list(Traccar.Model.Position.t)} | {:error, Tesla.Env.t}
  def reports_route_get(connection, from, to, opts \\ []) do
    optional_params = %{
      :"deviceId" => :query,
      :"groupId" => :query
    }
    %{}
    |> method(:get)
    |> url("/reports/route")
    |> add_param(:query, :"from", from)
    |> add_param(:query, :"to", to)
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Position{}])
  end

  @doc """
  Fetch a list of ReportStops within the time period for the Devices or Groups
  At least one _deviceId_ or one _groupId_ must be passed

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - from (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - to (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - opts (KeywordList): [optional] Optional parameters
    - :device_id ([integer()]): 
    - :group_id ([integer()]): 

  ## Returns

  {:ok, [%ReportStops{}, ...]} on success
  {:error, info} on failure
  """
  @spec reports_stops_get(Tesla.Env.client, DateTime.t, DateTime.t, keyword()) :: {:ok, list(Traccar.Model.ReportStops.t)} | {:error, Tesla.Env.t}
  def reports_stops_get(connection, from, to, opts \\ []) do
    optional_params = %{
      :"deviceId" => :query,
      :"groupId" => :query
    }
    %{}
    |> method(:get)
    |> url("/reports/stops")
    |> add_param(:query, :"from", from)
    |> add_param(:query, :"to", to)
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.ReportStops{}])
  end

  @doc """
  Fetch a list of ReportSummary within the time period for the Devices or Groups
  At least one _deviceId_ or one _groupId_ must be passed

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - from (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - to (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - opts (KeywordList): [optional] Optional parameters
    - :device_id ([integer()]): 
    - :group_id ([integer()]): 

  ## Returns

  {:ok, [%ReportSummary{}, ...]} on success
  {:error, info} on failure
  """
  @spec reports_summary_get(Tesla.Env.client, DateTime.t, DateTime.t, keyword()) :: {:ok, list(Traccar.Model.ReportSummary.t)} | {:error, Tesla.Env.t}
  def reports_summary_get(connection, from, to, opts \\ []) do
    optional_params = %{
      :"deviceId" => :query,
      :"groupId" => :query
    }
    %{}
    |> method(:get)
    |> url("/reports/summary")
    |> add_param(:query, :"from", from)
    |> add_param(:query, :"to", to)
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.ReportSummary{}])
  end

  @doc """
  Fetch a list of ReportTrips within the time period for the Devices or Groups
  At least one _deviceId_ or one _groupId_ must be passed

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - from (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - to (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - opts (KeywordList): [optional] Optional parameters
    - :device_id ([integer()]): 
    - :group_id ([integer()]): 

  ## Returns

  {:ok, [%ReportTrips{}, ...]} on success
  {:error, info} on failure
  """
  @spec reports_trips_get(Tesla.Env.client, DateTime.t, DateTime.t, keyword()) :: {:ok, list(Traccar.Model.ReportTrips.t)} | {:error, Tesla.Env.t}
  def reports_trips_get(connection, from, to, opts \\ []) do
    optional_params = %{
      :"deviceId" => :query,
      :"groupId" => :query
    }
    %{}
    |> method(:get)
    |> url("/reports/trips")
    |> add_param(:query, :"from", from)
    |> add_param(:query, :"to", to)
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.ReportTrips{}])
  end

  @doc """
  Fetch Server information

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Server{}} on success
  {:error, info} on failure
  """
  @spec server_get(Tesla.Env.client, keyword()) :: {:ok, Traccar.Model.Server.t} | {:error, Tesla.Env.t}
  def server_get(connection, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/server")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Server{})
  end

  @doc """
  Update Server information

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (Server): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.Server{}} on success
  {:error, info} on failure
  """
  @spec server_put(Tesla.Env.client, Traccar.Model.Server.t, keyword()) :: {:ok, Traccar.Model.Server.t} | {:error, Tesla.Env.t}
  def server_put(connection, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/server")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.Server{})
  end

  @doc """
  Close the Session

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec session_delete(Tesla.Env.client, keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def session_delete(connection, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/session")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Fetch Session information

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :token (String.t): 

  ## Returns

  {:ok, %Traccar.Model.User{}} on success
  {:error, info} on failure
  """
  @spec session_get(Tesla.Env.client, keyword()) :: {:ok, Traccar.Model.User.t} | {:error, Tesla.Env.t}
  def session_get(connection, opts \\ []) do
    optional_params = %{
      :"token" => :query
    }
    %{}
    |> method(:get)
    |> url("/session")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.User{})
  end

  @doc """
  Create a new Session

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - email (String.t): 
  - password (String.t): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.User{}} on success
  {:error, info} on failure
  """
  @spec session_post(Tesla.Env.client, String.t, String.t, keyword()) :: {:ok, Traccar.Model.User.t} | {:error, Tesla.Env.t}
  def session_post(connection, email, password, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/session")
    |> add_param(:form, :"email", email)
    |> add_param(:form, :"password", password)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.User{})
  end

  @doc """
  Fetch server Statistics

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - from (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - to (DateTime.t): in IS0 8601 format. eg. `1963-11-22T18:30:00Z`
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, [%Statistics{}, ...]} on success
  {:error, info} on failure
  """
  @spec statistics_get(Tesla.Env.client, DateTime.t, DateTime.t, keyword()) :: {:ok, list(Traccar.Model.Statistics.t)} | {:error, Tesla.Env.t}
  def statistics_get(connection, from, to, _opts \\ []) do
    %{}
    |> method(:get)
    |> url("/statistics")
    |> add_param(:query, :"from", from)
    |> add_param(:query, :"to", to)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.Statistics{}])
  end

  @doc """
  Fetch a list of Users

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - opts (KeywordList): [optional] Optional parameters
    - :user_id (String.t): Can only be used by admin or manager users

  ## Returns

  {:ok, [%User{}, ...]} on success
  {:error, info} on failure
  """
  @spec users_get(Tesla.Env.client, keyword()) :: {:ok, list(Traccar.Model.User.t)} | {:error, Tesla.Env.t}
  def users_get(connection, opts \\ []) do
    optional_params = %{
      :"userId" => :query
    }
    %{}
    |> method(:get)
    |> url("/users")
    |> add_optional_params(optional_params, opts)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode([%Traccar.Model.User{}])
  end

  @doc """
  Delete a User

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %{}} on success
  {:error, info} on failure
  """
  @spec users_id_delete(Tesla.Env.client, integer(), keyword()) :: {:ok, nil} | {:error, Tesla.Env.t}
  def users_id_delete(connection, id, _opts \\ []) do
    %{}
    |> method(:delete)
    |> url("/users/#{id}")
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(false)
  end

  @doc """
  Update a User

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - id (integer()): 
  - body (User): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.User{}} on success
  {:error, info} on failure
  """
  @spec users_id_put(Tesla.Env.client, integer(), Traccar.Model.User.t, keyword()) :: {:ok, Traccar.Model.User.t} | {:error, Tesla.Env.t}
  def users_id_put(connection, id, body, _opts \\ []) do
    %{}
    |> method(:put)
    |> url("/users/#{id}")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.User{})
  end

  @doc """
  Create a User

  ## Parameters

  - connection (Traccar.Connection): Connection to server
  - body (User): 
  - opts (KeywordList): [optional] Optional parameters

  ## Returns

  {:ok, %Traccar.Model.User{}} on success
  {:error, info} on failure
  """
  @spec users_post(Tesla.Env.client, Traccar.Model.User.t, keyword()) :: {:ok, Traccar.Model.User.t} | {:error, Tesla.Env.t}
  def users_post(connection, body, _opts \\ []) do
    %{}
    |> method(:post)
    |> url("/users")
    |> add_param(:body, :"body", body)
    |> Enum.into([])
    |> (&Connection.request(connection, &1)).()
    |> decode(%Traccar.Model.User{})
  end
end