}

	type Harumph2 struct {
		ID      int       `gorm:"default:0"`
		Email   string    `gorm:"not null;index:,unique"`
		Name    string    `gorm:"notNull;default:foo"`
		Name2   string    `gorm:"size:233;not null;default:'foo'"`
		Name3   string    `gorm:"size:233;notNull;default:''"`
		Age     int       `gorm:"default:18"`
		Created time.Time `gorm:"default:2000-01-02"`

import org.codenarc.util.AstUtil


class IntegrationTestFixturesRule : AbstractAstVisitorRule() {
    override fun getName(): String = "IntegrationTestFixtures"

    override fun getPriority(): Int = 1

    override fun setPriority(priority: Int) {
        throw UnsupportedOperationException()
    }

    override fun setName(name: String?) {
        throw UnsupportedOperationException()
    }

def dep_a():
    return 40


def dep_b(a: Annotated[int, Depends(dep_a)]):
    return a + 2


class ItemIn(BaseModel):
    name: str
    value: int


class ItemOut(BaseModel):
    name: str
    value: int
    dep: int


class LargeIn(BaseModel):
    items: list[dict[str, Any]]
    metadata: dict[str, Any]

)

// SrvRecord - represents a DNS service record
type SrvRecord struct {
	Host     string      `json:"host,omitempty"`
	Port     json.Number `json:"port,omitempty"`
	Priority int         `json:"priority,omitempty"`
	Weight   int         `json:"weight,omitempty"`
	Text     string      `json:"text,omitempty"`
	Mail     bool        `json:"mail,omitempty"` // Be an MX record. Priority becomes Preference.

	ReplicationPriority         string        `json:"replication_priority"`
	ReplicationMaxWorkers       int           `json:"replication_max_workers"`
	ReplicationMaxLWorkers      int           `json:"replication_max_lrg_workers"`
	TransitionWorkers           int           `json:"transition_workers"`
	StaleUploadsCleanupInterval time.Duration `json:"stale_uploads_cleanup_interval"`

        private final LocalRepository localRepo;

        private final List<RemoteRepository> repositories;

        private final DependencyFilter filter;

        private final int hashCode;

        public CacheKey(
                Plugin plugin,
                DependencyFilter extensionFilter,
                List<RemoteRepository> repositories,
                RepositorySystemSession session) {

@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}


@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}
```

}

// JSONPathElement represents a keypath component
type JSONPathElement struct {
	Key            *ObjectKey `parser:"  @@"`               // ['name'] and .name forms
	Index          *int       `parser:"| \"[\" @Int \"]\""` // [3] form
	ObjectWildcard bool       `parser:"| @\".*\""`          // .* form
	ArrayWildcard  bool       `parser:"| @\"[*]\""`         // [*] form
}

// JSONPath represents a keypath.

				return
			}
		case "Resources":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Resources")
				return
			}
			if cap(z.Resources) >= int(zb0002) {
				z.Resources = (z.Resources)[:zb0002]
			} else {
				z.Resources = make([]string, zb0002)
			}
			for za0001 := range z.Resources {
				z.Resources[za0001], err = dc.ReadString()
				if err != nil {

        performanceTestCoverage: PerformanceTestCoverage,
        bucketIndex: Int,
    ): PerformanceTest

    fun getName(testCoverage: TestCoverage): String = throw UnsupportedOperationException()
}

data class TestProjectDuration(
    val testProject: String,
    val scenarioDurations: List<PerformanceTestDuration>,
) {
    val totalTime: Int = scenarioDurations.sumOf { it.durationInMs }