interface KotlinJvmOptions

    private
    fun <T> extensionSchema(name: String, publicType: TypeOf<T>): ExtensionsSchema.ExtensionSchema = mock {
        on { getName() } doReturn name
        on { getPublicType() } doReturn publicType
    }

        generateDeploymentDescriptor = objectFactory.property(Boolean.class);
        generateDeploymentDescriptor.convention(true);
    }

    @Override
    public TypeOf<?> getPublicType() {
        return typeOf(org.gradle.plugins.ear.EarPluginConvention.class);
    }

    @Override
    public String getAppDirName() {
        logDeprecation();
        return appDirName;
    }

    }

    protected void renderVariants(T binary, TextReportBuilder builder) {
        ModelSchema<?> schema = schemaStore.getSchema(((BinarySpecInternal)binary).getPublicType());
        if (!(schema instanceof StructSchema)) {
            return;
        }
        Map<String, Object> variants = new TreeMap<>();

        return path;
    }

    @Override
    public File getFile() {
        return new File(path);
    }

    @Override
    public ChangeType getChangeType() {
        return change.getPublicType();
    }

    @Override
    public org.gradle.api.file.FileType getFileType() {
        FileType typeToConvert = change == ChangeTypeInternal.REMOVED ? previousFileType : currentFileType;

        return this;
    }

    @Override
    public String getDisplayName() {
        return getTypeDisplayName() + " container";
    }

    @Override
    public TypeOf<?> getPublicType() {
        return parameterizedTypeOf(new TypeOf<NamedDomainObjectContainer<?>>() {}, typeOf(getType()));
    }

    @Override

        return objects.newInstance(DefaultVersionCatalogBuilder.class, name, strings, versions, objects, dependencyResolutionServices);
    }

    @Override
    public TypeOf<?> getPublicType() {
        return typeOf(MutableVersionCatalogContainer.class);
    }

        this.project = project;
        this.extension = extension;
    }

    @SuppressWarnings("deprecation")
    @Override
    public TypeOf<?> getPublicType() {
        return typeOf(org.gradle.api.plugins.JavaPluginConvention.class);
    }

    @Override
    public Object sourceSets(@SuppressWarnings("rawtypes") Closure closure) {

    }

    interface PublicExtensionType {
    }

    static class ExtensionWithPublicType implements HasPublicType {
        @Override
        TypeOf<?> getPublicType() {
            typeOf(PublicExtensionType)
        }
    }

    static class FooExtension {
        String message = "Hello world!";
    }

    static class FooPluginExtension {

        return new DefaultLibraryBinaryIdentifier(component.getProjectPath(), component.getName(), getName());
    }

    @Override
    public Class<? extends BinarySpec> getPublicType() {
        return publicType;
    }

    @Override
    @Nullable
    public ComponentSpec getComponent() {
        return getComponentAs(ComponentSpec.class);
    }

    @Nullable

class ProjectSchemaNamedDomainObjectSchema(
    private val objectName: String,
    private val objectPublicType: TypeOf<*>
) : NamedDomainObjectSchema {

    override fun getName() = objectName

    override fun getPublicType() = objectPublicType
}


private
fun sourceSetsOf(project: Project) =
    project.extensions.findByName("sourceSets") as? SourceSetContainer


private