new HierarchicalClassLoaderStructure(classLoaderRegistry.getGradleWorkerExtensionSpec())
                .withChild(getMinimalGradleFilter())
                .withChild(targetGroovyClasspath)
                .withChild(gradleAndUserFilter)
                .withChild(compilerClasspath);

        return new DaemonForkOptionsBuilder(forkOptionsFactory)
            .javaForkOptions(javaForkOptions)

	return &LinuxContainerUserApplyConfiguration{}
}

// WithUID sets the UID field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the UID field is set to the value of the last call.
func (b *LinuxContainerUserApplyConfiguration) WithUID(value int64) *LinuxContainerUserApplyConfiguration {
	b.UID = &value
	return b

        HierarchicalClassLoaderStructure classLoaderStructure = new HierarchicalClassLoaderStructure(classLoaderRegistry.getGradleWorkerExtensionSpec())
                .withChild(getScalaFilterSpec())
                .withChild(new VisitableURLClassLoader.Spec("compiler", compilerClasspath.getAsURLs()));

        return new DaemonForkOptionsBuilder(forkOptionsFactory)
            .javaForkOptions(javaForkOptions)

        this.self = self;
        this.parent = parent;
    }

    public HierarchicalClassLoaderStructure withChild(ClassLoaderSpec spec) {
        HierarchicalClassLoaderStructure childNode = new HierarchicalClassLoaderStructure(spec, this);
        return childNode;
    }

    @Override
    public ClassLoaderSpec getSpec() {

    def "can serialize and deserialize a classloader structure"() {
        def classLoaderStructure = new HierarchicalClassLoaderStructure(filteringClassloaderSpec())
                .withChild(visitableUrlClassloaderSpec())

        when:
        serializer.write(encoder, classLoaderStructure)
        encoder.flush()

        and:

		},
	}
	pod.Spec.Volumes = append(pod.Spec.Volumes, volume)
	return pod
}

func withStatus(phase v1.PodPhase, pod *v1.Pod) *v1.Pod {
	pod.Status.Phase = phase
	return pod
}

func withUID(uid types.UID, pod *v1.Pod) *v1.Pod {
	pod.ObjectMeta.UID = uid
	return pod
}

func pvc() *v1.PersistentVolumeClaim {
	return &v1.PersistentVolumeClaim{
		ObjectMeta: metav1.ObjectMeta{

        Count of active and pending proxies managed by each instance.
        Pending is expected to converge to zero.
      |||
      ),
    ]),
  ], panelHeight=8)
)

        return new VisitableURLClassLoader.Spec("test", urls)
    }

    def classLoaderStructure() {
        return new HierarchicalClassLoaderStructure(filteringClassloaderSpec())
                .withChild(visitableUrlClassloaderSpec())
    }

    def flatClassLoaderStructure() {
        return new FlatClassLoaderStructure(visitableUrlClassloaderSpec())
    }

        |||
      ),
      panels.timeSeries.simple(
        'Injection', queries.injectionWebhook, |||
          Size of each xDS push.
        |||
      ),
    ]),
  ],  startY=100)
)

	b.Namespace = &value
	return b
}

// WithUID sets the UID field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the UID field is set to the value of the last call.
func (b *ExampleApplyConfiguration) WithUID(value types.UID) *ExampleApplyConfiguration {