* </p>
     *
     * @param elements The elements to add
     */
    @Incubating
    @SuppressWarnings("unchecked")
    // TODO Use @SafeVarargs and make method final
    void appendAll(T... elements);

    /**
     * Adds zero or more elements to the property value.
     *
     * <p>The given iterable will be queried when the value of this property is queried.
     *
     * <p>

        property.explicit
    }

    def "can add to explicit value with append"() {
        given:
        property.set([])
        property.appendAll(Providers.of(["1", "2"]))
        property.appendAll(Providers.of(["3", "4"]))

        expect:
        assertValueIs toImmutable(["1", "2", "3", "4"])
        property.explicit
    }

    @SuppressWarnings("varargs")
    @SafeVarargs
    public final void appendAll(T... elements) {
        withActualValue(it -> it.addAll(elements));
    }

    @Override
    public void appendAll(Iterable<? extends T> elements) {
        withActualValue(it -> it.addAll(elements));
    }

    @Override
    public void appendAll(Provider<? extends Iterable<? extends T>> provider) {

        objectFactory().listProperty(T::class.java).apply {
            if (values.isNotEmpty()) {
                uncheckedNonnullCast<CollectionPropertyInternal<T, Collection<T>>>(this).appendAll(*values)
            }
        }

    private
    inline fun <reified T : Any> propertyOf(value: T) =
        objectFactory().property(T::class.java).apply {
            set(value)
        }

	// string "u"
	o = append(o, 0x82, 0xa1, 0x75)
	if z.Update == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Update.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Update")
			return
		}
	}
	// string "f"
	o = append(o, 0xa1, 0x66)
	if z.Final == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Final.MarshalMsg(o)
		if err != nil {

	// string "Disable"
	o = append(o, 0x86, 0xa7, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65)
	if z.Disable == nil {
		o = msgp.AppendNil(o)
	} else {
		o = msgp.AppendBool(o, *z.Disable)
	}
	// string "Batch"
	o = append(o, 0xa5, 0x42, 0x61, 0x74, 0x63, 0x68)
	if z.Batch == nil {
		o = msgp.AppendNil(o)
	} else {
		o = msgp.AppendInt(o, *z.Batch)
	}
	// string "InMemory"

	return bts, nil
}

// MarshalMsg appends the bytes representation of b to the provided byte slice.
func (m *MSS) MarshalMsg(bytes []byte) (o []byte, err error) {
	if m == nil || *m == nil {
		return msgp.AppendNil(bytes), nil
	}
	o = msgp.AppendMapHeader(bytes, uint32(len(*m)))
	for za0001, za0002 := range *m {
		o = msgp.AppendString(o, za0001)
		o = msgp.AppendString(o, za0002)
	}
	return o, nil
}

	if z.Replicate == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Replicate.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Replicate")
			return
		}
	}
	// string "KeyRotate"
	o = append(o, 0xa9, 0x4b, 0x65, 0x79, 0x52, 0x6f, 0x74, 0x61, 0x74, 0x65)
	if z.KeyRotate == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.KeyRotate.MarshalMsg(o)

		if z.ObjectV1 == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.ObjectV1.MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "ObjectV1")
				return
			}
		}
	}
	if (zb0001Mask & 0x4) == 0 { // if not omitted
		// string "V2Obj"
		o = append(o, 0xa5, 0x56, 0x32, 0x4f, 0x62, 0x6a)
		if z.ObjectV2 == nil {
			o = msgp.AppendNil(o)
		} else {

	})
}

// Println calls l.Output to print to the logger.
// Arguments are handled in the manner of [fmt.Println].
func (l *Logger) Println(v ...any) {
	l.output(0, 2, func(b []byte) []byte {
		return fmt.Appendln(b, v...)
	})
}

// Fatal is equivalent to l.Print() followed by a call to [os.Exit](1).
func (l *Logger) Fatal(v ...any) {
	l.Output(2, fmt.Sprint(v...))
	os.Exit(1)
}