sourceSets.main {
    output.dir(mapOf("builtBy" to writeFuturePluginVersions), futurePluginVersionsDestDir)
}
configurations.runtimeElements {
    outgoing {
        variants.named("resources") {
            artifact(futurePluginVersionsDestDir) {
                builtBy(writeFuturePluginVersions)
            }
        }
    }
}

publishing {

            testRoot.convention(restRootDir)
        }

        // TODO: This effectively makes testRoot not customizable, which we don't do anyway atm
        project.sourceSets.test.output.dir(restRootDir, builtBy: buildRestTests)
    }

            copy.from(pluginProject.getTasks().named("pluginProperties"));
            copy.from(pluginProject.file("src/main/plugin-metadata"));
        });

        Map<String, Object> map = Map.of("builtBy", taskName);
        SourceSetContainer sourceSetContainer = project.getExtensions().getByType(SourceSetContainer.class);
        sourceSetContainer.getByName("test").getOutput().dir(map, outputDir);
    }

        }
        isCanBeResolved = false
        isCanBeConsumed = true
        outgoing.artifact(localRepository) {
            builtBy(localPublish)
        }
    }

    if (signArtifacts) {
        // Otherwise we get

                into('build/install/elastic-distro')
            }
            artifacts {
                it.add("expanded-${testArchiveProjectName}", file('build/install')) {
                    builtBy expandedTask
                    type = 'directory'
                }
            }
        """
    }

    private void localDistroSetup() {
        settingsFile << """

}

// Version returns the version of the builtin KMS.
func (secretKey) Version(ctx context.Context) (string, error) { return "v1", nil }

// APIs returns an error since the builtin KMS does not provide a list of APIs.
func (secretKey) APIs(ctx context.Context) ([]madmin.KMSAPI, error) {
	return nil, ErrNotSupported
}

// Status returns a set of endpoints and their KMS status. Since, the builtin KMS is not

    paths:
      - third_party$
      - builtin$
      - examples$
issues:
  max-issues-per-linter: 100
  max-same-issues: 100
formatters:
  enable:
    - gofumpt
    - goimports
  exclusions:
    generated: lax
    paths:
      - third_party$
      - builtin$

     * been resolved and it is not a domain SID or builtin account,
     * the full DOMAIN\name form of the account will be
     * returned (e.g. MYDOM\alice or MYDOM\Domain Users).
     * If the SID has been resolved but it is is a domain SID,
     * only the domain name will be returned (e.g. MYDOM).
     * If the SID has been resolved but it is a builtin account,
     * only the name component will be returned (e.g. SYSTEM).

	MinKES                  // MinIO MinKES
	Builtin                 // Builtin single key KMS implementation
)

// Type identifies the KMS type.
type Type uint

// String returns the Type's string representation
func (t Type) String() string {
	switch t {
	case MinKMS:
		return "MinIO KMS"
	case MinKES:
		return "MinIO KES"
	case Builtin:
		return "MinIO builtin"
	default:

     */
    @Nonnull
    String getProjectId();

    /**
     * Gets the POM file from which the project was built.
     *
     * @return the optional POM file
     */
    @Nonnull
    Optional<Path> getPomFile();

    /**
     * Gets the project that was built.
     *
     * @return The project that was built or {@code null} if an error occurred and this result accompanies a
     *         {@link ProjectBuilderException}.