docs: private List<Endpoint> enrichWithPublicAddresses(List<Endpoint> endpoints) {
          try {
              String endpointsUrl = String.format("%s/api/v1/namespaces/%s/endpoints", kubernetesMaster, namespace);
              JsonObject endpointsJson = callGet(endpointsUrl);
  
              List<EndpointAddress> privateAddresses = privateAddresses(endpoints);
              Map<EndpointAddress, String> services = extractServices(endpointsJson, privateAddresses);
              Map<EndpointAddress, String> nodes = extractNodes(endpointsJson, privateAddresses);
  
              Map<EndpointAddress, String> publicIps = new HashMap<EndpointAddress, String>();
              Map<EndpointAddress, Integer> publicPorts = new HashMap<EndpointAddress, Integer>();
              Map<String, String> cachedNodePublicIps = new HashMap<String, String>();
  
              for (Map.Entry<EndpointAddress, String> serviceEntry : services.entrySet()) {
                  EndpointAddress privateAddress = serviceEntry.getKey();
                  String service = serviceEntry.getValue();
                  String serviceUrl = String.format("%s/api/v1/namespaces/%s/services/%s", kubernetesMaster, namespace, service);
                  JsonObject serviceJson = callGet(serviceUrl);
                  try {
                      String loadBalancerIp = extractLoadBalancerIp(serviceJson);
                      Integer servicePort = extractServicePort(serviceJson);
                      publicIps.put(privateAddress, loadBalancerIp);
                      publicPorts.put(privateAddress, servicePort);
                  } catch (Exception e) {
                      // Load Balancer public IP cannot be found, try using NodePort.
                      Integer nodePort = extractNodePort(serviceJson);
                      String node = nodes.get(privateAddress);
                      String nodePublicIp;
                      if (cachedNodePublicIps.containsKey(node)) {
                          nodePublicIp = cachedNodePublicIps.get(node);
                      } else {
                          String nodeUrl = String.format("%s/api/v1/nodes/%s", kubernetesMaster, node);
                          nodePublicIp = extractNodePublicIp(callGet(nodeUrl));
                          cachedNodePublicIps.put(node, nodePublicIp);
                      }
                      publicIps.put(privateAddress, nodePublicIp);
                      publicPorts.put(privateAddress, nodePort);
                  }
              }
  
              return createEndpoints(endpoints, publicIps, publicPorts);
          } catch (Exception e) {
              LOGGER.finest(e);
              // Log warning only once.
              if (!isNoPublicIpAlreadyLogged) {
                  LOGGER.warning(
                          "Cannot fetch public IPs of Hazelcast Member PODs, you won't be able to use Hazelcast Smart Client from "
                                  + "outside of the Kubernetes network");
                  isNoPublicIpAlreadyLogged = true;
              }
              return endpoints;
          }
      }