<xs:element type="trusted-artifactsType" name="trusted-artifacts"/>
            <xs:element type="ignored-keysType" name="ignored-keys"/>
            <xs:element type="trusted-keysType" name="trusted-keys"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="md5Type" mixed="true">
        <xs:sequence>

            <xs:element type="trusted-keysType" name="trusted-keys"/>
            <xs:element type="key-serversType" name="key-servers"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="md5Type" mixed="true">
        <xs:sequence>
            <xs:element type="also-trustType" name="also-trust" minOccurs="0"/>
        </xs:sequence>
        <xs:attribute type="xs:string" name="value" use="required"/>

* The passphrase used to protect your private key.

These items must be supplied as the values of the `signing.keyId`, `signing.secretKeyRingFile`, and `signing.password` properties, respectively.

Verify if the key is listed at the official site.
For example, Apache projects typically provide a KEYS.txt file that you can trust.
--

[[sec:ignoring-keys]]
=== Specifying key servers and ignoring keys

Gradle will automatically download the public keys required to verify a signature.

 * and for strong class references not to be held for the cache keys.
 * <p>
 * The use of {@link WeakClassSet} as the cache key, opposed to just {@link Class}, is because a type may be composed of types from different classloaders.
 * An example of this would be something like {@code ModelSet<SomeCustomUserType>}.
 * The class set abstraction effectively creates a key for all classes involved in a type.

            statement.setString(14, results.getHost());
            statement.setString(15, results.getTeamCityBuildId());
            statement.execute();
            ResultSet keys = statement.getGeneratedKeys();
            keys.next();
            return keys.getLong(1);
        }
    }

    private void insertExecutionExperiment(Connection connection, R results) throws SQLException {

    }

    @Override
    public boolean isFatal() {
        return false;
    }

    @Override
    public void explainTo(TreeFormatter formatter) {
        formatter.append("artifact was signed but all keys were ignored");
    }

            !offline
        );
        if (!verificationsBuilder.isUseKeyServers() && !offline) {
            LOGGER.lifecycle("Will use key servers to download missing keys. If you really want to ignore key servers when generating the verification file, you can use the --offline flag in addition");
        }
        try {
            validateChecksums();

public abstract class DefaultKeyServers {
    private final static List<URI> DEFAULT_KEYSERVERS = ImmutableList.of(
        uri("hkp://ha.pool.sks-keyservers.net"),
        uri("https://keyserver.ubuntu.com"),
        uri("https://keys.openpgp.org"),
        uri("https://pgp.mit.edu")
    );

    private static URI uri(String uri) {
        try {
            return new URI(uri);
        } catch (URISyntaxException e) {

        if (!declarationsBySchemaFunctions.isEmpty()) {
            collectorDeclarationsByClass[kClass] = declarationsBySchemaFunctions
        }

        return declarationsBySchemaFunctions.keys
    }

    override fun constructors(kClass: KClass<*>, preIndex: DataSchemaBuilder.PreIndex): Iterable<DataConstructor> = emptyList()