code: async def create(
              cls, architecture: str, mac_addresses: typing.Sequence[str],
              power_type: str,
              power_parameters: typing.Mapping[str, typing.Any] = None, *,
              subarchitecture: str = None, min_hwe_kernel: str = None,
              hostname: str = None, domain: typing.Union[int, str] = None):
          
          params = {
              "architecture": architecture,
              "mac_addresses": mac_addresses,
              "power_type": power_type,
          }
          if power_parameters is not None:
              params["power_parameters"] = json.dumps(
                  power_parameters, sort_keys=True)
          if subarchitecture is not None:
              params["subarchitecture"] = subarchitecture
          if min_hwe_kernel is not None:
              params["min_hwe_kernel"] = min_hwe_kernel
          if hostname is not None:
              params["hostname"] = hostname
          if domain is not None:
              params["domain"] = domain
          return cls._object(await cls._handler.create(**params))
docs: Create a new machine.
  
          :param architecture: The architecture of the machine (required).
          :type architecture: `str`
          :param mac_addresses: The MAC address of the machine (required).
          :type mac_addresses: sequence of `str`
          :param power_type: The power type of the machine (required).
          :type power_type: `str`
          :param power_parameters: The power parameters for the machine
              (optional).
          :type power_parameters: mapping of `str` to any value.
          :param subarchitecture: The subarchitecture of the machine (optional).
          :type subarchitecture: `str`
          :param min_hwe_kernel: The minimal HWE kernel for the machine
              (optional).
          :param hostname: The hostname for the machine (optional).
          :type hostname: `str`
          :param domain: The domain for the machine (optional).
          :type domain: `int` or `str`