@get:JvmName("immutable") val immutable: Boolean,
  internal var headerValue: String?,
) {
  @JvmName("-deprecated_noCache")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "noCache"),
    level = DeprecationLevel.ERROR,
  )
  fun noCache(): Boolean = noCache

  @JvmName("-deprecated_noStore")
  @Deprecated(
    message = "moved to val",

     * @return The dependency constraint.
     * @see [DependencyConstraintHandler.add]
     * @since 8.5
     */
    @Incubating
    @JvmName("invokeDependencyScope")
    operator fun NamedDomainObjectProvider<DependencyScopeConfiguration>.invoke(dependencyConstraintNotation: Any): DependencyConstraint =
        constraints.add(name, dependencyConstraintNotation)

			VolumeID: volumeName,
			FSType:   "ext4",
		}
	}
	return pv
}

func getFakePersistentVolumeClaim(pvcName, volumeName, statusSize, requestSize string, uid types.UID) *v1.PersistentVolumeClaim {
	pvc := &v1.PersistentVolumeClaim{
		ObjectMeta: metav1.ObjectMeta{Name: pvcName, Namespace: "default", UID: uid},
		Spec: v1.PersistentVolumeClaimSpec{
			Resources: v1.VolumeResourceRequirements{

    def "mutating managed inputs of a rule is not allowed"() {
        when:
        buildScript '''
            @Managed
            interface Person {
                String getName()
                void setName(String name)
            }

            class RulePlugin extends RuleSource {
                @Model
                void person(Person person) {
                }

                @Model

        def pattern = new M2ResourcePattern("prefix/[organisation]/[module]/[revision]/[type]s/[revision]/[artifact].[ext]")
        def ivyName = new DefaultIvyArtifactName("projectA", "pom", "pom")
        def moduleId = DefaultModuleIdentifier.newId(group, module)

        expect:
        pattern.toVersionListPattern(moduleId, ivyName).path == expectedPath

        where:
        group       | module     | expectedPath

    authParams["charset"] = charset.name()
    return Challenge(scheme, authParams)
  }

  @JvmName("-deprecated_scheme")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "scheme"),
    level = DeprecationLevel.ERROR,
  )
  fun scheme(): String = scheme

  @JvmName("-deprecated_authParams")
  @Deprecated(
    message = "moved to val",

	ctx := r.Context()

	objAPI, cred := validateAdminReq(ctx, w, r, policy.SetTierAction)
	if objAPI == nil {
		return
	}
	vars := mux.Vars(r)
	scName := vars["tier"]

	password := cred.SecretKey
	reqBytes, err := madmin.DecryptData(password, io.LimitReader(r.Body, r.ContentLength))
	if err != nil {

		},
	}
}

func unscheduled(pod *v1.Pod) *v1.Pod {
	pod.Spec.NodeName = ""
	return pod
}

func withPVC(pvcName string, pod *v1.Pod) *v1.Pod {
	volume := v1.Volume{
		Name: pvcName,
		VolumeSource: v1.VolumeSource{
			PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
				ClaimName: pvcName,
			},
		},
	}
	pod.Spec.Volumes = append(pod.Spec.Volumes, volume)
	return pod
}

        String runtimeName = metadata.get(ProbedSystemProperty.RUNTIME_NAME);
        String runtimeVersion = metadata.get(ProbedSystemProperty.RUNTIME_VERSION);
        String jvmName = metadata.get(ProbedSystemProperty.VM_NAME);
        String jvmVersion = metadata.get(ProbedSystemProperty.VM_VERSION);
        String jvmVendor = metadata.get(ProbedSystemProperty.VM_VENDOR);

                javaVendor: jdkMetadata.vendor.displayName,
                runtimeName: jdkMetadata.runtimeName,
                runtimeVersion: jdkMetadata.runtimeVersion,
                jvmName: jdkMetadata.jvmName,
                jvmVersion: jdkMetadata.jvmVersion,
                jvmVendor: jdkMetadata.jvmVendor,
                architecture: jdkMetadata.architecture,
            ]
        }
    }