// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Started field is set to the value of the last call.
func (b *ContainerStatusApplyConfiguration) WithStarted(value bool) *ContainerStatusApplyConfiguration {
	b.Started = &value
	return b
}

// WithAllocatedResources sets the AllocatedResources field in the declarative configuration to the given value

// and returns a slice of up to n names of files in the directory,
// in directory order. Subsequent calls on the same file will yield
// further names.
//
// If n > 0, Readdirnames returns at most n names. In this case, if
// Readdirnames returns an empty slice, it will return a non-nil error
// explaining why. At the end of a directory, the error is [io.EOF].
//
// If n <= 0, Readdirnames returns all the names from the directory in

     * Returns the time when this test completed execution.
     *
     * @return The end t ime, in milliseconds since the epoch.
     */
    long getEndTime();

    /**
     * Returns the total number of atomic tests executed for this test. This will return 1 if this test is itself an
     * atomic test.
     *
     * @return The number of tests, possibly 0
     */
    long getTestCount();

    /**

	return targetIDs
}

// Clone - returns copy of this rules.
func (rules Rules) Clone() Rules {
	rulesCopy := make(Rules)

	for pattern, targetIDSet := range rules {
		rulesCopy[pattern] = targetIDSet.Clone()
	}

	return rulesCopy
}

// Union - returns union with given rules as new rules.
func (rules Rules) Union(rules2 Rules) Rules {
	nrules := rules.Clone()

	for pattern, targetIDSet := range rules2 {

func Float32frombits(b uint32) float32 { return *(*float32)(unsafe.Pointer(&b)) }

// Float64bits returns the IEEE 754 binary representation of f,
// with the sign bit of f and the result in the same bit position,
// and Float64bits(Float64frombits(x)) == x.
func Float64bits(f float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }

// Float64frombits returns the floating-point number corresponding

     * Returns the test class name for this test, if any.
     *
     * @return The class name. May return null.
     */
    @Nullable
    @UsedByScanPlugin("test-retry")
    String getClassName();

    /**
     * Is this test a composite test?
     *
     * @return true if this test is a composite test.
     */
    boolean isComposite();

    /**
     * Returns the parent of this test, if any.
     *

	}
	return nil
}

// Enabled - returns true if versioning is enabled
func (v Versioning) Enabled() bool {
	return v.Status == Enabled
}

// Versioned returns if 'prefix' has versioning enabled or suspended.
func (v Versioning) Versioned(prefix string) bool {
	return v.PrefixEnabled(prefix) || v.PrefixSuspended(prefix)
}

// PrefixEnabled - returns true if versioning is enabled at the bucket and given
// prefix, false otherwise.

	return func(yield func(K) bool) {
		for k := range m {
			if !yield(k) {
				return
			}
		}
	}
}

// Values returns an iterator over values in m.
// The iteration order is not specified and is not guaranteed
// to be the same from one call to the next.
func Values[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[V] {
	return func(yield func(V) bool) {
		for _, v := range m {

	return slices.Contains(s, v)
}

// FindFunc finds the first element matching the function, or nil if none do
func FindFunc[E any](s []E, f func(E) bool) *E {
	idx := slices.IndexFunc(s, f)
	if idx == -1 {
		return nil
	}
	return &s[idx]
}

// First returns the first item in the slice, if there is one
func First[E any](s []E) *E {
	if len(s) == 0 {
		return nil
	}
	return &s[0]
}

import org.jetbrains.kotlin.analysis.api.symbols.KaClassLikeSymbol

/**
 * Returns a [KaClassLikeSymbol] for this [KaType] if the type represents a uniquely resolvable class/object/type alias.
 */
public val KaType.symbol: KaClassLikeSymbol?
    get() = (this as? KaNonErrorClassType)?.symbol

/**
 * Returns a [KtClassLikeSymbol] for this [KtType] if the type represents a uniquely resolvable class/object/type alias.
 */