docs: def create_network(self, name, driver=None, options=None, ipam=None,
                         check_duplicate=None, internal=False, labels=None,
                         enable_ipv6=False, attachable=None, scope=None,
                         ingress=None):
          """
          Create a network. Similar to the ``docker network create``.
  
          Args:
              name (str): Name of the network
              driver (str): Name of the driver used to create the network
              options (dict): Driver options as a key-value dictionary
              ipam (IPAMConfig): Optional custom IP scheme for the network.
              check_duplicate (bool): Request daemon to check for networks with
                  same name. Default: ``None``.
              internal (bool): Restrict external access to the network. Default
                  ``False``.
              labels (dict): Map of labels to set on the network. Default
                  ``None``.
              enable_ipv6 (bool): Enable IPv6 on the network. Default ``False``.
              attachable (bool): If enabled, and the network is in the global
                  scope,  non-service containers on worker nodes will be able to
                  connect to the network.
              scope (str): Specify the network's scope (``local``, ``global`` or
                  ``swarm``)
              ingress (bool): If set, create an ingress network which provides
                  the routing-mesh in swarm mode.
  
          Returns:
              (dict): The created network reference object
  
          Raises:
              :py:class:`docker.errors.APIError`
                  If the server returns an error.
  
          Example:
              A network using the bridge driver:
  
                  >>> client.create_network("network1", driver="bridge")
  
              You can also create more advanced networks with custom IPAM
              configurations. For example, setting the subnet to
              ``192.168.52.0/24`` and gateway address to ``192.168.52.254``.
  
              .. code-block:: python
  
                  >>> ipam_pool = docker.types.IPAMPool(
                      subnet='192.168.52.0/24',
                      gateway='192.168.52.254'
                  )
                  >>> ipam_config = docker.types.IPAMConfig(
                      pool_configs=[ipam_pool]
                  )
                  >>> docker_client.create_network("network1", driver="bridge",
                                                   ipam=ipam_config)
          """
          if options is not None and not isinstance(options, dict):
              raise TypeError('options must be a dictionary')
  
          data = {
              'Name': name,
              'Driver': driver,
              'Options': options,
              'IPAM': ipam,
              'CheckDuplicate': check_duplicate,
          }
  
          if labels is not None:
              if version_lt(self._version, '1.23'):
                  raise InvalidVersion(
                      'network labels were introduced in API 1.23'
                  )
              if not isinstance(labels, dict):
                  raise TypeError('labels must be a dictionary')
              data["Labels"] = labels
  
          if enable_ipv6:
              if version_lt(self._version, '1.23'):
                  raise InvalidVersion(
                      'enable_ipv6 was introduced in API 1.23'
                  )
              data['EnableIPv6'] = True
  
          if internal:
              if version_lt(self._version, '1.22'):
                  raise InvalidVersion('Internal networks are not '
                                       'supported in API version < 1.22')
              data['Internal'] = True
  
          if attachable is not None:
              if version_lt(self._version, '1.24'):
                  raise InvalidVersion(
                      'attachable is not supported in API version < 1.24'
                  )
              data['Attachable'] = attachable
  
          if ingress is not None:
              if version_lt(self._version, '1.29'):
                  raise InvalidVersion(
                      'ingress is not supported in API version < 1.29'
                  )
  
              data['Ingress'] = ingress
  
          if scope is not None:
              if version_lt(self._version, '1.30'):
                  raise InvalidVersion(
                      'scope is not supported in API version < 1.30'
                  )
              data['Scope'] = scope
  
          url = self._url("/networks/create")
          res = self._post_json(url, data=data)
          return self._result(res, json=True)