newerThan: "7d10h31s" # match objects newer than this value (e.g. 7d10h31s)
      olderThan: "7d" # match objects older than this value (e.g. 7d10h31s)
#      createdAfter: "date" # match objects created after "date"
#      createdBefore: "date" # match objects created before "date"

      ## NOTE: tags are not supported when "source" is remote.
      tags:
         - key: "name"

 *    default to their previous value.
 *
 * Every [edit] call must be matched by a call to [Editor.commit] or [Editor.abort]. Committing is
 * atomic: a read observes the full set of values as they were before or after the commit, but never
 * a mix of values.
 *
 * Clients call [get] to read a snapshot of an entry. The read will observe the value at the time

      extends SimpleImmutableEntry<Range<K>, V> {
    RangeMapEntry(Cut<K> lowerBound, Cut<K> upperBound, V value) {
      this(Range.create(lowerBound, upperBound), value);
    }

    RangeMapEntry(Range<K> range, V value) {
      super(range, value);
    }

    boolean contains(K value) {
      return getKey().contains(value);
    }

    Cut<K> getLowerBound() {
      return getKey().lowerBound;
    }

     * Creates a {@link StreamOf} instance from the provided values.
     * If the input array is {@code null}, an empty stream is returned.
     *
     * @param <T> The type of elements in the stream.
     * @param values The elements to be included in the stream. Can be {@code null}.
     * @return A {@link StreamOf} instance containing the provided values, or an empty stream if {@code values} is {@code null}.
     */
    @SafeVarargs

  }

  /**
   * Returns the total number of times that {@link Cache} lookup methods attempted to load new
   * values. This includes both successful load operations and those that threw exceptions. This is
   * defined as {@code loadSuccessCount + loadExceptionCount}.
   *
   * <p><b>Note:</b> the values of the metrics are undefined in case of overflow (though it is

   *
   * @param initialValue the initial value
   */
  public AtomicDouble(double initialValue) {
    value = doubleToRawLongBits(initialValue);
  }

  /** Creates a new {@code AtomicDouble} with initial value {@code 0.0}. */
  public AtomicDouble() {
    // assert doubleToRawLongBits(0.0) == 0L;
  }

  /**
   * Gets the current value.
   *
   * @return the current value
   */
  public final double get() {

     * {@return whether resources are filtered to replace tokens with parameterized values}.
     * The default value is {@code false}.
     */
    default boolean stringFiltering() {
        return false;
    }

    /**
     * {@return whether the directory described by this source element should be included in the build}.
     * The default value is {@code true}.
     */
    default boolean enabled() {
        return true;

		tx = tx.Omit(omits...)
	}

	return db.AddError(tx.Create(values).Error)
}

// check association values has been saved
// if values kind is Struct, check it has been saved
// if values kind is Slice/Array, check all items have been saved
var visitMapStoreKey = "gorm:saved_association_map"

func checkAssociationsSaved(db *gorm.DB, values reflect.Value) bool {
	if visit, ok := db.Get(visitMapStoreKey); ok {

    /** Returns the value from the left map (possibly null). */
    @ParametricNullness
    V leftValue();

    /** Returns the value from the right map (possibly null). */
    @ParametricNullness
    V rightValue();

    /**
     * Two instances are considered equal if their {@link #leftValue()} values are equal and their
     * {@link #rightValue()} values are also equal.
     */
    @Override

        </publishing>
        <values>
            <value>
                <name>PartOf</name>
                <value>QuickFeedbackLinuxOnly</value>
            </value>
            <value>
                <name>PartOf</name>
                <value>QuickFeedback</value>
            </value>
            <value>
                <name>PartOf</name>
                <value>PullRequestFeedback</value>
            </value>