docs: 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