* @param <T> the type of the object associated to this key
     */
    final class Key<T> {

        private final Class<T> type;
        private final Object id;

        private Key(Class<T> type, Object id) {
            this.type = type;
            this.id = id;
        }

        public Class<T> type() {
            return type;
        }

        @Override

client = TestClient(app)


def test_query():
    response = client.get("/query")
    assert response.status_code == 422
    assert response.json() == {
        "detail": [
            {
                "type": "missing",
                "loc": ["query", "query"],
                "msg": "Field required",
                "input": None,
            }
        ]
    }


def test_query_query_baz():

	has       RelationshipType = "has"
)

type Relationships struct {
	HasOne    []*Relationship
	BelongsTo []*Relationship
	HasMany   []*Relationship
	Many2Many []*Relationship
	Relations map[string]*Relationship

	EmbeddedRelations map[string]*Relationships

	Mux sync.RWMutex
}

type Relationship struct {
	Name                     string
	Type                     RelationshipType

        }

        if (empty(artifactId)) {
            throw new InvalidArtifactRTException(
                    groupId, artifactId, getVersion(), type, "The artifactId cannot be empty.");
        }

        if (empty(type)) {
            throw new InvalidArtifactRTException(groupId, artifactId, getVersion(), type, "The type cannot be empty.");
        }

        primitiveNameToClassMap.put(Integer.TYPE.getName(), Integer.TYPE);
        primitiveNameToClassMap.put(Long.TYPE.getName(), Long.TYPE);
        primitiveNameToClassMap.put(Float.TYPE.getName(), Float.TYPE);
        primitiveNameToClassMap.put(Double.TYPE.getName(), Double.TYPE);
    }

    /**

      },
      "stopword_en_filter": {
        "type": "stop",
        "stopwords": "_english_"
      },
      "content_length_filter": {
        "type": "length",
        "max": 30
      },
      "limit_token_count_filter": {
        "type": "limit",
        "max_token_count": 2147483647
      },
      "stemmer_en_filter": {
        "type": "stemmer",
        "name": "english"
      },

      },
      "favorite_count": {
        "type": "long"
      },
      "filename": {
        "type": "keyword"
      },
      "filetype": {
        "type": "keyword"
      },
      "host": {
        "type": "keyword"
      },
      "lang": {
        "type": "keyword"
      },
      "last_modified": {
        "type": "date",
        "format": "date_optional_time"
      },

                        "type": "object",
                        "properties": {
                            "name": {"title": "Name", "type": "string"},
                            "price": {"title": "Price", "type": "number"},
                            "tags": {
                                "title": "Tags",
                                "type": "array",

)
def test_required_str_schema(path: str):
    assert app.openapi()["paths"][path]["get"]["parameters"] == [
        {
            "required": True,
            "schema": {"title": "P", "type": "string"},
            "name": "p",
            "in": "header",
        }
    ]


@pytest.mark.parametrize(
    "path",
    ["/required-str", "/model-required-str"],
)

     *
     * @param netName the network name of the share
     * @param type the type of the share
     * @param remark the optional comment or description for the share
     */
    public SmbShareInfo(final String netName, final int type, final String remark) {
        this.netName = netName;
        this.type = type;
        this.remark = remark;
    }

    @Override
    public String getName() {