name = objectFactory.property(String.class);
        url = objectFactory.property(String.class);
    }

    @Override
    public Property<String> getName() {
        return name;
    }

    @Override
    public Property<String> getUrl() {
        return url;
    }

            "inputProperty::Property[first-property]",
            "nested.inputProperty::Property[second-property]",
            "nestedList.\$0.inputProperty::Property[second-property]",
            "nestedList.\$1.inputProperty::Property[second-property]",
            "nestedListOfLists.\$0.\$0.inputProperty::Property[second-property]",
            "nestedMap.key1.inputProperty::Property[second-property]",

                property.setSchema(propertySchema);
            }
        };
    }

    private static String propertyDescription(ModelSchemaExtractionContext<?> parentContext, ModelProperty<?> property) {
        if (property.getDeclaredBy().size() == 1 && property.getDeclaredBy().contains(parentContext.getType())) {
            return String.format("property '%s'", property.getName());
        } else {

        public static AttachedProperty of(PropertyMetadata property, boolean applyRole) {
            return new AttachedProperty(property, applyRole);
        }

        public final PropertyMetadata property;
        public final boolean applyRole;

        private AttachedProperty(PropertyMetadata property, boolean applyRole) {
            this.property = property;
            this.applyRole = applyRole;
        }
    }

		instance="prototype">
		<!--
		<property name="maxDocumentCacheSize">5</property>
		<property name="unprocessedDocumentSize">100</property>
		<property name="threadDump">false</property>
		<postConstruct name="addBoostDocumentRule">
			<arg>
				<component class="org.codelibs.fess.indexer.BoostDocumentRule">
					<property name="matchExpression">"url.matches(\".*fess.*\")"</property>
					<property name="boostExpression">"1000.0"</property>

            <la:form action="/admin/relatedcontent/">
                <la:hidden property="crudMode"/>
                <c:if test="${crudMode==2}">
                    <la:hidden property="id"/>
                    <la:hidden property="versionNo"/>
                </c:if>
                <la:hidden property="createdBy"/>
                <la:hidden property="createdTime"/>
                <div class="row">

        .filter { property ->
            (includeMemberFilter.shouldIncludeMember(property) ||
                kClass.primaryConstructor?.parameters.orEmpty().any { it.name == property.name && it.type == property.returnType }) &&
                property.visibility == KVisibility.PUBLIC &&
                isGradlePropertyType(property.returnType)
        }.map { property ->

    ) {
        checkPropertyAccessOnCurrentReceiver(reference.property, reference.receiver, reference.originElement)
    }

    private
    fun AnalysisContext.checkPropertyAccessOnCurrentReceiver(property: DataProperty, receiver: ObjectOrigin, access: LanguageTreeElement) {
        if (property.isDirectAccessOnly) {
            checkAccessOnCurrentReceiver(receiver, access)
        }
    }

    }

    @Override
    public Property<T> convention(Provider<? extends T> provider) {
        Preconditions.checkArgument(provider != null, "Cannot set the convention of a property using a null provider.");
        setConvention(Providers.internal(provider).asSupplier(getValidationDisplayName(), type, sanitizer));
        return this;
    }

    @Override
    public Property<T> unset() {
        super.unset();

/**
 * Provides efficient access to a property.
 */
interface PropertyDelegate {
    operator fun <T> getValue(receiver: Any?, property: KProperty<*>): T
}


/**
 * Provides efficient access to a mutable dynamic property.
 */
interface MutablePropertyDelegate : PropertyDelegate {
    operator fun <T> setValue(receiver: Any?, property: KProperty<*>, value: T)
}


internal