from fastapi import Body
    from pydantic import Discriminator, Tag

    class Cat(BaseModel):
        pet_type: str = "cat"
        meows: int

    class Dog(BaseModel):
        pet_type: str = "dog"
        barks: float

    def get_pet_type(v):
        assert isinstance(v, dict)
        return v.get("pet_type", "")

    Pet = Annotated[
        Union[Annotated[Cat, Tag("cat")], Annotated[Dog, Tag("dog")]],

     * Plugins can choose to report a warning to users when unresolved paths exist.
     */
    PathType UNRESOLVED = new PathType() {
        @Override
        public String name() {
            return "UNRESOLVED";
        }

        @Override
        public String id() {
            return "UNRESOLVED";
        }

        @Override

        return classifier;
    }

    public void setClassifier(String classifier) {
        this.classifier = classifier;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Object getDatum() {
        return datum;
    }

    public void setDatum(Object datum) {

        DefaultToolchain toolchain = newDefaultToolchain(model, "TYPE");
        assertEquals("TYPE", toolchain.getType());

        model.setType("MODEL_TYPE");
        toolchain = newDefaultToolchain(model);
        assertEquals("MODEL_TYPE", toolchain.getType());
    }

    @Test
    void testGetLogger() {
        ToolchainModel model = new ToolchainModel();

        this.setDescription(p.getDescription());
        this.setExpression(p.getExpression());
        this.setDeprecated(p.getDeprecated());
        this.setDefaultValue(p.getDefaultValue());
        this.setType(p.getType());
        this.setSince(p.getSince());
    }

    // ----------------------------------------------------------------------
    //
    // ----------------------------------------------------------------------

        return name;
    }

    @Override
    public String toString() {
        return String.format("%s.%s", ownerClass, name);
    }

    public TypeMetaData getType() {
        return type;
    }

    public void setType(TypeMetaData type) {
        this.type = type;
    }

    public boolean isWriteable() {
        return setter != null;
    }

    public boolean isReadable() {

    protected DefaultToolchain(ToolchainModel model, String type, Logger logger) {
        this(model, logger);
        this.type = type;
    }

    @Override
    public final String getType() {
        return type != null ? type : model.getType();
    }

    @Override
    public final ToolchainModel getModel() {
        return model;
    }

    public final void addProvideToken(String type, RequirementMatcher matcher) {

            propertyMetaData.setType(new TypeMetaData(type.getName()));

            Element para = doc.createElement("para");
            para.appendChild(doc.createTextNode("The "));
            para.appendChild(linkRenderer.link(propertyMetaData.getType(), listener));

    public ParameterMetaData(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public TypeMetaData getType() {
        return type;
    }

    public void setType(TypeMetaData type) {
        this.type = type;
    }

    public String getSignature() {
        StringBuilder builder = new StringBuilder();

    }

    public void setVersion(String version) {
        this.version = version;
    }

    public String getType() {
        return type;
    }

    public String getCheckedType() {
        return type == null ? "jar" : type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public ArtifactScopeEnum getArtifactScope() {