async def create(self, session, *, dc=None):
        """Creates a new session

        Parameters:
            session (Object): Session definition
            dc (str): Specify datacenter that will be used.
                      Defaults to the agent's local datacenter.

        Returns:
            Object: ID of the created session

        The create endpoint is used to initialize a new session.
        Sessions must be associated with a node and may be associated
        with any number of checks.

        The session object must look like::

            {
                "LockDelay": timedelta(seconds=15),
                "Name": "my-service-lock",
                "Node": "foobar",
                "Checks": ["a", "b", "c"],
                "Behavior": "release",
                "TTL": timedelta(seconds=0)
            }

        **LockDelay** can be specified as a duration string using a "s"
        suffix for seconds. The default is 15s.

        **Node** must refer to a node that is already registered, if specified.
        By default, the agent's own node name is used.

        **Name** can be used to provide a human-readable name for the Session.

        **Checks** is used to provide a list of associated health checks.
        It is highly recommended that, if you override this list, you include
        the default "serfHealth".

        **Behavior** can be set to either ``release`` or ``delete``.
        This controls the behavior when a session is invalidated.
        By default, this is ``release``, causing any locks that are held to be
        released. Changing this to ``delete`` causes any locks that are held
        to be deleted. ``delete`` is useful for creating ephemeral key/value
        entries.

        **TTL** field is a duration string, and like ``LockDelay`` it can use
        "s" as a suffix for seconds. If specified, it must be between 10s and
        86400s currently. When provided, the session is invalidated if it is
        not renewed before the TTL expires. The lowest practical TTL should be
        used to keep the number of managed sessions low.
        When locks are forcibly expired, such as during a leader election,
        sessions may not be reaped for up to double this TTL, so long TTL
        values (>1 hour) should be avoided.
        """
        response = await self._api.put(
            "/v1/session/create",
            data=session,
            params={"dc": dc})
        return response.body