_ = resultBuilder.Add(r)
		}
	}

	return resultBuilder.Build()
}

func DefaultRemoteClusterExcludedSchemas() collection.Schemas {
	resultBuilder := collection.NewSchemasBuilder()
	// Pods are the most common resource type exists in the remote cluster.
	_ = resultBuilder.Add(collections.Deployment)
	// We don't need to analyze injection config in the multi-cluster scenario.
	_ = resultBuilder.Add(collections.ConfigMap)

		_ = resultBuilder.Add(myschema)
	}
	return resultBuilder.Build()
}

func (s Schemas) Intersect(otherSchemas Schemas) Schemas {
	resultBuilder := NewSchemasBuilder()

	schemaLookup := sets.String{}
	for _, myschema := range s.All() {
		schemaLookup.Insert(myschema.String())
	}

	// Only add schemas that are in both sets
	for _, myschema := range otherSchemas.All() {

        this.inputArtifact = inputArtifact;
        this.outputDir = outputDir;
        this.resultBuilder = TransformExecutionResult.builderFor(inputArtifact, outputDir);
    }

    @Override
    public TransformExecutionResult getRegisteredOutputs() {
        TransformExecutionResult result = resultBuilder.build();
        result.visitOutputs(new TransformExecutionResult.OutputVisitor() {
            @Override

        this.classpathWalker = classpathWalker;
        this.typeRegistry = typeRegistry;
        this.transform = transform;
    }

    @Override
    public final void transform(File destination) {
        resultBuilder().accept(destination, builder -> {
            try {
                visitEntries(builder);
            } catch (FileException e) {
                // Badly formed archive, so discard the contents and produce an empty JAR

                ${formatStreamArgument args, "errorOutput"}
            }
        """
    }

    private def formatArgument(@Nullable argument, Closure<String> resultBuilder) {
        argument?.with(resultBuilder) ?: ""
    }

    private def formatStreamArgument(Map<String, String> args, String streamName) {
        def streamValue = args[streamName]
        def result = ""