}

            class RegisterComponentRules extends RuleSource {
                @ComponentType
                void register1(TypeBuilder<UnmanagedComponentSpec> builder) {
                    builder.defaultImplementation(DefaultUnmanagedComponentSpec)
                }

                @ComponentType
                void register2(TypeBuilder<SampleComponentSpec> builder) {

        if (value == null) {
            append("null");
        } else if (value.getClass().isArray()) {
            Class<?> componentType = value.getClass().getComponentType();
            if (componentType.isPrimitive()) {
                append(value.toString());
            } else {
                appendValues((Object[]) value);
            }

            public TypeOf<?> apply(ModelType<?> it) {
                return typeOf(it);
            }
        });
    }

    private static <U> TypeOf<U> typeOf(ModelType<U> componentType) {
        return new TypeOf<U>(componentType) {
        };
    }

    private TypeOf<?> nullableTypeOf(Class<?> type) {
        return type != null
            ? typeOf(type)
            : null;
    }

      return pickInstance(rawType.getEnumConstants(), null);
    }
    if (type.isArray()) {
      TypeToken<?> componentType = requireNonNull(type.getComponentType());
      Object array = Array.newInstance(componentType.getRawType(), 1);
      Array.set(array, 0, generate(componentType));
      return array;
    }
    Method emptyGenerate = EMPTY_GENERATORS.get(rawType);
    if (emptyGenerate != null) {

      return pickInstance(rawType.getEnumConstants(), null);
    }
    if (type.isArray()) {
      TypeToken<?> componentType = requireNonNull(type.getComponentType());
      Object array = Array.newInstance(componentType.getRawType(), 1);
      Array.set(array, 0, generate(componentType));
      return array;
    }
    Method emptyGenerate = EMPTY_GENERATORS.get(rawType);
    if (emptyGenerate != null) {

// getSupportedComponentConfigKinds returns all currently supported component config API object names
func getSupportedComponentConfigKinds() []string {
	objects := []string{}
	for componentType := range legacyKindToGroupMap {
		objects = append(objects, componentType)
	}
	sort.Strings(objects)
	return objects
}

func mapLegacyKindsToGroups(kinds []string) ([]string, error) {
	groups := []string{}
	for _, kind := range kinds {

        .where(new TypeParameter<V>() {}, valueType);
  }

  private static <T> TypeToken<T[]> arrayOf(Class<T> componentType) {
    return new TypeToken<T[]>() {}.where(new TypeParameter<T>() {}, componentType);
  }

  public <T> void testNulls() {
    new NullPointerTester().testAllPublicStaticMethods(TypeToken.class);
    new NullPointerTester()

        .where(new TypeParameter<V>() {}, valueType);
  }

  private static <T> TypeToken<T[]> arrayOf(Class<T> componentType) {
    return new TypeToken<T[]>() {}.where(new TypeParameter<T>() {}, componentType);
  }

  public <T> void testNulls() {
    new NullPointerTester().testAllPublicStaticMethods(TypeToken.class);
    new NullPointerTester()

Class <org.gradle.buildinit.plugins.internal.modifiers.ComponentType> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ComponentType.java:0)
Class <org.gradle.buildinit.plugins.internal.modifiers.Language> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (Language.java:0)

  );

  let results = (outs
    Res<Variadic<TF_Tensor>, [{One or more tensors that were dequeued as a tuple.}]>:$components
  );

  TF_DerivedResultTypeListAttr component_types = TF_DerivedResultTypeListAttr<0>;
}

def TF_RFFTOp : TF_Op<"RFFT", [Pure]> {
  let summary = "Real-valued fast Fourier transform.";

  let description = [{