}

    @get:Input
    abstract val version: Property<String>

    @get:Input
    abstract val baseVersion: Property<String>

    @get:Input
    @get:Optional
    abstract val commitId: Property<String>

    @get:Input
    abstract val snapshot: Property<Boolean>

    @get:Input
    abstract val promotionBuild: Property<Boolean>

    @get:Input
    @get:Optional

	unmarshaled     bool
	format          string
}

// IsEmpty - returns whether input serialization is empty or not.
func (input *InputSerialization) IsEmpty() bool {
	return !input.unmarshaled
}

// UnmarshalXML - decodes XML data.
func (input *InputSerialization) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	// Make subtype to avoid recursive UnmarshalXML().

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String paths;

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String includedPaths;

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String excludedPaths;

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String includedDocPaths;

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String excludedDocPaths;

  - type: input
    id: Mobile
    attributes:
      label: Mobile device
      placeholder: e.g., Linux Ubuntu 16.04
  - type: input
    id: Python
    attributes:
      label: Python version
      placeholder: e.g., 3.9
  - type: input
    id: Bazel
    attributes:
      label: Bazel version
      description: If compiling from source
  - type: input
    id: Compiler
    attributes:

  private static final Predicate<@Nullable String> NOT_LENGTH_3 =
      input -> input == null || input.length() != 3;
  private static final Predicate<@Nullable Integer> EVEN = input -> input == null || input % 2 == 0;
  static final Predicate<Entry<String, Integer>> CORRECT_LENGTH =
      input -> input.getKey().length() == input.getValue();

  abstract Map<String, Integer> createUnfiltered();

  private static final Predicate<@Nullable String> NOT_LENGTH_3 =
      input -> input == null || input.length() != 3;
  private static final Predicate<@Nullable Integer> EVEN = input -> input == null || input % 2 == 0;
  static final Predicate<Entry<String, Integer>> CORRECT_LENGTH =
      input -> input.getKey().length() == input.getValue();

  abstract Map<String, Integer> createUnfiltered();

// Creates parameters (placeholders) in the tracing `ctx` using the shape and
// dtype of `inputs`.
Status CreateParamsForInputs(AbstractContext* ctx,
                             absl::Span<AbstractTensorHandle* const> inputs,
                             std::vector<AbstractTensorHandle*>* params);

// A callable that takes tensor inputs and returns zero or more tensor outputs.
using Model = std::function<Status(AbstractContext*,

            field=param,
            schema_generator=schema_generator,
            model_name_map=model_name_map,
            field_mapping=field_mapping,
            separate_input_output_schemas=separate_input_output_schemas,
        )
        parameter = {
            "name": param.alias,
            "in": field_info.in_.value,
            "required": param.required,
            "schema": param_schema,

    List<List<Integer>> input = newArrayList(list1, list2);

    FluentIterable<Integer> result = FluentIterable.concat(input);
    assertEquals(asList(1, 4), newArrayList(result));

    // Now change the inputs and see result dynamically change as well

    list1.add(2);
    List<Integer> list3 = newArrayList(3);
    input.add(1, list3);

  static <V extends @Nullable Object, X extends Throwable> ListenableFuture<V> create(
      ListenableFuture<? extends V> input,
      Class<X> exceptionType,
      Function<? super X, ? extends V> fallback,
      Executor executor) {
    CatchingFuture<V, X> future = new CatchingFuture<>(input, exceptionType, fallback);
    input.addListener(future, rejectionPropagatingExecutor(executor, future));
    return future;
  }