String scrollId = jsonPath.getString("_scroll_id");
        while (true) {
            List<String> resultIds = jsonPath.getList("hits.hits._id");
            if (resultIds.size() == 0) {
                break;
            }
            docIds.addAll(resultIds);
            Map<String, Object> scrollBody = new HashMap<>();
            scrollBody.put("scroll", "1m");

 *
 * <p>Each {@code Artifact} instance is basically an exact pointer to a file in a Maven repository.
 * {@code Artifact} instances are created when <dfn>resolving</dfn> {@link ArtifactCoordinates} instances.
 * Resolving is the process that selects a {@linkplain #getVersion() particular version}
 * and downloads the artifact in the local repository.  This operation returns a {@link DownloadedArtifact}.
 * </p>
 *

    /**
     * Get the model based on the path when resolving the parent based on relativePath.
     *
     * @param from    the requiring model
     * @param pomFile the path to the pomFile
     * @return the model, otherwise {@code null}
     */
    Model getRawModel(Path from, Path pomFile);

    /**
     * Get the model from the reactor based on the groupId and artifactId when resolving reactor dependencies.
     *

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.execution;

import java.util.List;

/**
 * This class holds the information required to enable resuming a Maven build with {@code --resume}.
 */
public class BuildResumptionData {
    /**
     * The list of projects that remain to be built.
     */
    private final List<String> remainingProjects;

     * @param result Outcome of the current Maven build.
     * @return A {@link BuildResumptionData} instance or {@link Optional#empty()} if resuming the build is not possible.
     */
    Optional<BuildResumptionData> determineBuildResumptionData(MavenExecutionResult result);

          // Otherwise, an F -> T cycle will end up resolving both F and T
          // nondeterministically to either F or T.
          for (Type x = arg; x != null; x = mappings.remove(TypeVariableKey.forLookup(x))) {}
          return;
        }
      }
      mappings.put(var, arg);
    }
  }

  // This is needed when resolving types against a context with wildcards
  // For example:

   * Adds an edge connecting {@code nodeU} to {@code nodeV} if one is not already present, and sets
   * a value for that edge to {@code value} (overwriting the existing value, if any).
   *
   * <p>If the graph is directed, the resultant edge will be directed; otherwise, it will be
   * undirected.
   *
   * <p>Values do not have to be unique. However, values must be non-null.
   *

// For example, given:
//
// 	{
// 	  Addresses: [{"ip": "10.10.1.1"}, {"ip": "10.10.2.2"}],
// 	  Ports:     [{"name": "a", "port": 8675}, {"name": "b", "port": 309}]
// 	}
//
// The resulting set of endpoints can be viewed as:
//
// 	a: [ 10.10.1.1:8675, 10.10.2.2:8675 ],
// 	b: [ 10.10.1.1:309, 10.10.2.2:309 ]
message EndpointSubset {

                .collect(Collectors.toList());

        if (remainingProjects.isEmpty()) {
            LOGGER.info("No remaining projects found, resuming the build would not make sense.");
            return Optional.empty();
        }

        return Optional.of(new BuildResumptionData(remainingProjects));
    }

          // Otherwise, an F -> T cycle will end up resolving both F and T
          // nondeterministically to either F or T.
          for (Type x = arg; x != null; x = mappings.remove(TypeVariableKey.forLookup(x))) {}
          return;
        }
      }
      mappings.put(var, arg);
    }
  }

  // This is needed when resolving types against a context with wildcards
  // For example: