return newOption("nodeID", value)
}

func NodeType(value string) Instance {
	ntype := strings.Split(value, "~")[0]
	return newOption("nodeType", ntype)
}

func XdsType(value string) Instance {
	return newOption("xds_type", value)
}

func Region(value string) Instance {
	return newOptionOrSkipIfZero("region", value)
}

func Zone(value string) Instance {
	return newOptionOrSkipIfZero("zone", value)
}

        private
        val propertyOriginalTypes = mutableMapOf<KClass<*>, MutableMap<String, KType>>()

        private
        val claimedFunctions = mutableMapOf<KClass<*>, MutableSet<KFunction<*>>>()

        fun addType(kClass: KClass<*>) {
            properties.getOrPut(kClass) { mutableMapOf() }
            propertyOriginalTypes.getOrPut(kClass) { mutableMapOf() }
        }

			addType(T.Elem())
		case *types.Slice:
			addType(T.Elem())
		case *types.Array:
			addType(T.Elem())
		case *types.Chan:
			addType(T.Elem())
		case *types.Map:
			addType(T.Key())
			addType(T.Elem())
		case *types.Signature:
			addType(T.Params())
			addType(T.Results())
			if tparams := T.TypeParams(); tparams != nil {
				for i := 0; i < tparams.Len(); i++ {
					addType(tparams.At(i))
				}
			}

            } else {
                val rhsType = getDataType(rhsResolution)
                val lhsExpectedType = resolveRef(lhsResolution.property.valueType)
                if (rhsType is DataType.UnitType) {
                    errorCollector.collect(ResolutionError(assignment, ErrorReason.UnitAssignment))
                    hasErrors = true
                }
                if (!checkIsAssignable(rhsType, lhsExpectedType)) {

        rng.uniform(low=0.0, high=1.0, size=static_input_shape).astype(
            np.float32
        )
    )

    def data_gen() -> repr_dataset.RepresentativeDataset:
      for _ in range(100):
        yield {
            'input_tensor': rng.uniform(
                low=0.0, high=1.0, size=static_input_shape
            ).astype(np.float32)
        }

            String type = null
            if (it != key) {
                type = StringUtils.substringAfter(it, "@")
            }
            assert dependency.hasType(type)
        }
    }

    void assertOptionalDependencies(String... expected) {
        assertDependencies(optionalDependencies, expected)
    }

    void assertDependencyManagement(String... expected) {

            if (leftValue.isMissing()) {
                return leftValue.asType();
            }
            Value<? extends B> rightValue = right.calculateValue(consumer);
            if (rightValue.isMissing()) {
                return rightValue.asType();
            }

        static <T> Value<T> ofNullable(@Nullable T value) {
            if (value == null) {
                return MISSING.asType();
            }
            return new Present<>(value);
        }

        static <T> Value<T> missing() {
            return MISSING.asType();
        }

        static <T> Value<T> of(T value) {
            if (value == null) {

    String groupId
    String artifactId
    String version
    String classifier
    String type
    boolean optional
    Collection<MavenDependencyExclusion> exclusions = []

    MavenDependency hasType(def type) {
        assert this.type == type
        return this
    }

    @Override
    public String toString() {

        mavenHttpRepo.module("test", "provider", "1.0")
            .hasPackaging("pom")
            .hasType("pom")
            .dependsOn("test", "other", "1.0")
            .publish()
            .allowAll()
        mavenHttpRepo.module("test", "other", "1.0")
            .hasPackaging("pom")
            .hasType("pom")
            .publish()
            .allowAll()
    }

    def expectDownloadOtherTypes() {