class Config:
            arbitrary_types_allowed = True
            json_encoders = {uuid.UUID: str}

        a_uuid: MyUuid

    @app.get("/get_custom_class")
    def return_some_user():
        # Test that the fix also works for custom pydantic classes
        return SomeCustomClass(a_uuid=MyUuid("b8799909-f914-42de-91bc-95c819218d01"))

    client = TestClient(app)

    with client:

	return os.Remove(store.directory)
}

// PutMultiple - puts an item to the store.
func (store *QueueStore[I]) PutMultiple(items []I) (Key, error) {
	// Generate a new UUID for the key.
	uid, err := uuid.NewRandom()
	if err != nil {
		return Key{}, err
	}

	store.Lock()
	defer store.Unlock()
	if uint64(len(store.entries)) >= store.entryLimit {
		return Key{}, errLimitExceeded
	}

}

data class FlameGraphGeneration(
    private val uuid: Int,
    private val name: String,
    private val scenarios: List<PerformanceScenario>
) : PerformanceTestProjectSpec {
    override val os: Os = Os.LINUX
    override
    fun asConfigurationId(model: CIBuildModel) =
        "${model.projectId}_PerformanceTest$uuid"

    override
    fun asName(): String =
        "Flamegraphs for $name"

    previousCrossVersionTests: List<BaseGradleBuildType>
) : Project({
    this.id("${model.projectId}_Stage_${stage.stageName.id}")
    this.uuid = "${DslContext.uuidPrefix}_${model.projectId}_Stage_${stage.stageName.uuid}"
    this.name = stage.stageName.stageName
    this.description = stage.stageName.description
}) {
    val specificBuildTypes: List<OsAwareBaseGradleBuildType>

		fi.VersionID = nullVersionID
	}

	var uv uuid.UUID
	var err error
	if fi.VersionID != "" && fi.VersionID != nullVersionID {
		uv, err = uuid.Parse(fi.VersionID)
		if err != nil {
			return err
		}
	}

	var dd uuid.UUID
	if fi.DataDir != "" {
		dd, err = uuid.Parse(fi.DataDir)
		if err != nil {
			return err
		}
	}

        <constraint name="Base" regexp="ServiceRegistrationProvider" withinHierarchy="true" within="" contains="" />
      </searchConfiguration>

				healBucket(u.Bucket, scan)
			} else {
				if len(u.Versions) > 0 {
					vers := len(u.Versions) / 16
					if vers > 0 {
						for i := 0; i < vers; i++ {
							healObject(u.Bucket, u.Object, uuid.UUID(u.Versions[16*i:]).String(), scan)
						}
					}
				} else {
					healObject(u.Bucket, u.Object, u.VersionID, scan)
				}
			}

			wait()
		}
	}

) {

    constructor(
        uuid: Int,
        testType: TestType,
        os: Os,
        testJvm: JvmCategory,
        expectedBucketNumber: Int = DEFAULT_FUNCTIONAL_TEST_BUCKET_SIZE,
        buildJvm: Jvm = BuildToolBuildJvm,
        withoutDependencies: Boolean = false,
        arch: Arch = Arch.AMD64,
        failStage: Boolean = true,

    stage: Stage,
    prevStage: Stage?,
    os: Os?,
    dependencies: List<BaseGradleBuildType>,
    generateTriggers: Boolean = true,
) : BaseGradleBuildType(init = {
    id(stageTriggerId(model, stage, os))
    uuid = stageTriggerUuid(model, stage, os)
    name = stage.stageName.stageName + " (Trigger)" + (os?.asName()?.toCapitalized()?.let { "($it)" } ?: "")
    type = Type.COMPOSITE

    applyDefaultSettings()

    features {

	"context"
	"slices"
	"time"

	"github.com/minio/madmin-go/v3"
)

func commonETags(etags []string) (etag string, maxima int) {
	etagOccurrenceMap := make(map[string]int, len(etags))

	// Ignore the uuid sentinel and count the rest.
	for _, etag := range etags {
		if etag == "" {
			continue
		}
		etagOccurrenceMap[etag]++
	}

	maxima = 0 // Counter for remembering max occurrence of elements.
	latest := ""