@OutputFile
    abstract RegularFileProperty getDestFile();

    @Input
    abstract Property<String> getJavadocUrl();
    @Input
    abstract Property<String> getDsldocUrl();
    @Input
    abstract Property<String> getWebsiteUrl();
    @Input
    abstract Property<String> getVersion();

    @TaskAction
    def transform() {
        XIncludeAwareXmlProvider provider = new XIncludeAwareXmlProvider()

)

// Dialector GORM database dialector
type Dialector interface {
	Name() string
	Initialize(*DB) error
	Migrator(db *DB) Migrator
	DataTypeOf(*schema.Field) string
	DefaultValueOf(*schema.Field) clause.Expression
	BindVarTo(writer clause.Writer, stmt *Statement, v interface{})
	QuoteTo(clause.Writer, string)
	Explain(sql string, vars ...interface{}) string
}

// Plugin GORM plugin interface
type Plugin interface {

    public static final String MAKE_BOTH_MODE = "make-both";

    private List<String> blackList = new ArrayList<>();

    private Map<String, BuildFailure> buildFailuresByProject = new HashMap<>();

    private Map<String, Map<String, Map>> pluginContextsByProjectAndPluginKey = new HashMap<>();

    private String failureBehavior = FAIL_FAST;

    private final ProjectSorter sorter;

    }

    public Iterator<?> getIteratorForXPathExpression(String expression) {
        return context.iterate(expression);
    }

    public boolean containsXPathExpression(String expression) {
        return context.getValue(expression) != null;
    }

    public Object getValue(String expression) {
        try {
            return context.getValue(expression);

	type args struct {
		yamlStr string
	}
	type PrefixTemp struct {
		Prefix BatchJobPrefix `yaml:"prefix"`
	}
	tests := []struct {
		name    string
		b       PrefixTemp
		args    args
		want    []string
		wantErr bool
	}{
		{
			name: "test1",
			b:    PrefixTemp{},
			args: args{
				yamlStr: `
prefix: "foo"
`,
			},
			want:    []string{"foo"},
			wantErr: false,
		},
		{

                            "items": {
                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                        },
                        "msg": {"title": "Message", "type": "string"},
                        "type": {"title": "Error Type", "type": "string"},
                    },
                },
                "HTTPValidationError": {

    private final Map<String, ClassDoc> extensionClasses = [:]
    private final String pluginId
    final ClassDoc targetClass
    final List<PropertyDoc> extraProperties = []
    final List<BlockDoc> extraBlocks = []

    ClassExtensionDoc(String pluginId, ClassDoc targetClass) {
        this.pluginId = pluginId
        this.targetClass = targetClass
    }

    String getPluginId() {
        return pluginId

 */
@Deprecated(since = "4.0.0")
public interface WorkspaceModelResolver {

    Model resolveRawModel(String groupId, String artifactId, String versionConstraint)
            throws UnresolvableModelException;

    Model resolveEffectiveModel(String groupId, String artifactId, String versionConstraint)
            throws UnresolvableModelException;

        @Nullable
        private final String modelId;

        ResolvedPathSource(Path path, String location, String modelId) {
            super(path, location);
            this.modelId = modelId;
        }

        @Override
        public Path getPath() {
            return null;
        }

        @Override
        @Nullable
        public String getModelId() {
            return modelId;

    public void debug(Throwable error) {
        logger.debug("", error);
    }

    @Override
    public void debug(Supplier<String> content) {
        if (isDebugEnabled()) {
            logger.debug(content.get());
        }
    }

    @Override
    public void debug(Supplier<String> content, Throwable error) {
        if (isDebugEnabled()) {
            logger.debug(content.get(), error);
        }
    }