<artifactId>opensearch</artifactId>
			<version>${opensearch.version}</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.lucene</groupId>
			<artifactId>lucene-queryparser</artifactId>
			<version>${lucene.version}</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-api</artifactId>

	KubernetesObjectString string
	// If provided, these configs will be used directly
	Configs []config.Config
	// If provided, the yaml string will be parsed and used as configs
	ConfigString string
	// If provided, the ConfigString will be treated as a go template, with this as input params
	ConfigTemplateInput any
	// If provided, this mesh config will be used
	MeshConfig      *meshconfig.MeshConfig
	NetworksWatcher mesh.NetworksWatcher

org.slf4j:log4j-over-slf4j:1.7.10
  Variant compile:
    | Attribute Name                 | Provided | Requested    |
    |--------------------------------|----------|--------------|
    | org.gradle.status              | release  |              |
    | org.gradle.category            | library  | library      |
    | org.gradle.libraryelements     | jar      | classes      |
    | org.gradle.usage               | java-api | java-api     |

// WithConditions adds the given value to the Conditions field in the declarative configuration
// and returns the receiver, so that objects can be build by chaining "With" function invocations.
// If called multiple times, values provided by each call will be appended to the Conditions field.
func (b *NodeStatusApplyConfiguration) WithConditions(values ...*NodeConditionApplyConfiguration) *NodeStatusApplyConfiguration {
	for i := range values {

     */
    void kill(boolean killTree) {
        println "Killing process with pid: $pid"
        if (pid == null) {
            throw new RuntimeException("Unable to force kill the process because provided pid is null!")
        }
        if (!(OperatingSystem.current().unix || OperatingSystem.current().windows)) {

apply plugin: 'eclipse'

${mavenCentralRepository()}

configurations {
    provided
}

dependencies {
    ${implementationConfiguration} project(':a')
    ${implementationConfiguration} 'com.google.guava:guava:17.0'
    provided 'org.slf4j:slf4j-log4j12:1.7.12'
}

eclipse {
    classpath {
        plusConfigurations += [ configurations.provided ]
    }
}

configure(project(':a')){
    apply plugin:'java'
}"""

public interface FileHasher {
    /**
     * Returns the hash of the current content of the given file. The provided file must exist and be a file (rather than, say, a directory).
     */
    HashCode hash(File file);

    /**
     * Returns the hash of the current content of the given file, assuming the given file metadata. The provided file must exist and be a file (rather than, say, a directory).
     */

 * limitations under the License.
 */

package org.gradle.jvm.application.scripts;

import org.gradle.api.resources.TextResource;

/**
 * Interface for generating scripts with the provided details based on a provided template.
 */
public interface TemplateBasedScriptGenerator extends ScriptGenerator {

    /**
     * Sets the template text resource used for generating script.
     *

# WebSockets

When defining WebSockets, you normally declare a parameter of type `WebSocket` and with it you can read data from the client and send data to it.

It is provided directly by Starlette, but you can import it from `fastapi`:

```python
from fastapi import WebSocket
```

!!! tip

package org.gradle.api.internal.artifacts.transform;

import org.gradle.api.artifacts.component.ComponentIdentifier;

/**
 * Factory for {@link TransformUpstreamDependenciesResolver} that relies on the information provided to its {@code create} method.
 */
public interface TransformUpstreamDependenciesResolverFactory {
    /**