import org.gradle.api.provider.Property;

/**
 * Configuration for generating Dokka based Kotlin DSL docs.
 */
public abstract class KotlinDslReference {

    /**
     * The location of the final rendered Dokka content.
     */
    public abstract DirectoryProperty getRenderedDocumentation();

    /**
     * The Dokka version to use instead the default one Dokkatoo is configured with.

# See the License for the specific language governing permissions and
# limitations under the License.

WD=$(dirname "$0")
WD=$(cd "$WD"; pwd)

set -eux

# This script sets up the plain text rendered deployments for addons
# See samples/addons/README.md for more information

ADDONS="${WD}/../../samples/addons"
DASHBOARDS="${WD}/dashboards"
mkdir -p "${ADDONS}"
TMP=$(mktemp -d)

            task.getInputs().property("systemProperties", Collections.emptyMap());
            // TODO: This breaks the provider
            task.systemProperty("org.gradle.docs.releasenotes.rendered", extension.getReleaseNotes().getRenderedDocumentation().get().getAsFile());
        });
    }

or customize the ports to match the old defaults.
See the [security advisory](https://istio.io/latest/news/security/istio-security-2021-002/) for more information.

#### Other migrations

If you see errors like `rendered manifests contain a resource that already exists` during installation, you may need to forcibly take ownership.

The script below can handle this for you. Replace `RELEASE` and `NAMESPACE` with the name and namespace of the release:

You can set them as follows:

```Python hl_lines="3-16  19-32"
{!../../../docs_src/metadata/tutorial001.py!}
```

!!! tip
    You can write Markdown in the `description` field and it will be rendered in the output.

With this configuration, the automatic API docs would look like:

<img src="/img/tutorial/metadata/image01.png">

## License identifier

        TaskProvider<Sync> userguide = tasks.register("userguide", Sync.class, task -> {
            task.setGroup("documentation");
            task.setDescription("Stages rendered user manual documentation.");

            task.from(userguideSinglePageHtml);
            task.from(userguideSinglePagePdf);
            task.from(userguideMultiPage);

func getMatches(f *listener.FilterChainMatch) string {
	match := f
	if match == nil {
		match = &listener.FilterChainMatch{}
	}
	// filterChaince also has SuffixLen, SourceType, SourcePrefixRanges which are not rendered.

	descrs := []string{}
	if len(match.ServerNames) > 0 {
		descrs = append(descrs, fmt.Sprintf("SNI: %s", strings.Join(match.ServerNames, ",")))
	}
	if len(match.TransportProtocol) > 0 {

import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.SpecialNames
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.renderer.DescriptorRenderer
import org.jetbrains.kotlin.renderer.render
import org.jetbrains.kotlin.resolve.calls.inference.CapturedType
import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
import org.jetbrains.kotlin.types.*

    override val token: KtLifetimeToken
        get() = analysisContext.token
}

internal fun KotlinType.asStringForDebugging(analysisContext: Fe10AnalysisContext): String {
    val renderer = KtFe10DebugTypeRenderer()
    return prettyPrint { renderer.render(analysisContext, this@asStringForDebugging, this@prettyPrint) }

}

// generateValidatingWebhook renders a validating webhook configuration from the given tagWebhookConfig.
func generateValidatingWebhook(config *tagWebhookConfig, opts *GenerateOptions) (string, error) {
	r := helm.NewHelmRenderer(opts.ManifestsPath, defaultChart, "Pilot", config.IstioNamespace, nil)

	if err := r.Run(); err != nil {
		return "", fmt.Errorf("failed running Helm renderer: %v", err)
	}

	values := fmt.Sprintf(`