<?xml version="1.0" encoding="UTF-8"?>
<!--
    Copyright (c) 2005, 2019 IBM Corporation and others.
    This program and the accompanying materials
    are made available under the terms of the Eclipse Public License 2.0
    which accompanies this distribution, and is available at
    https://www.eclipse.org/legal/epl-2.0/

    SPDX-License-Identifier: EPL-2.0

    Contributors:
        IBM Corporation - initial API and implementation
 -->

<html>
<head>
	<!--  Escape to the root of your source folder  -->
	<meta
		name="root"
		content="../../../../../../" />
	<title>WTP API overview</title>
</head>

<body>

<abstract>SPI support for the server tools framework.</abstract>

<p>The classes in this package would typically be extended or used by
SPI clients of the server tools framework who are providing a new server
type, runtime type, or other extension. These delegates are never visible
to regular API clients unless explicitly exposed by the provider.</p>

<p>The majority of these classes are delegates to implement one of the
extension points. View the extension point documentation for further
details.</p>

</body>
</html>