Lombok has introduced experimental features with version: 1.18.2 for inheritance issues faced with Builder annotation, and can be resolved with @SuperBuilder annotation as below.

@SuperBuilder
public class ParentClass {
    private final String a;
    private final String b;
}

@SuperBuilder
public class ChildClass extends ParentClass{
    private final String c;
}

Now, one can use Builder class as below (that was not possible with @Builder annotation)

ChildClass.builder().a("testA").b("testB").c("testC").build();

Since you can't use @SuperBuilder annotation, beacause you don't have access to ApplicationEvent class, as far as I can see, the only solution is to do something like following:

Assume that you have TrackedEvent class wich looks something like this:

public class TrackedEvent extends ApplicationEvent {
    protected String correlationId;
    protected String description;

    public TrackedEvent(Object source, String correlationId, String description) {
        super(source);
        this.correlationId = correlationId;
        this.description = description;
    }

    public TrackedEvent(Object source) {
        super(source);
    }


}

And you have OperationalEvent class wich extends above class. Than, you can implement builder pattern in OptionalEvent class like this:

public class OperationalEvent extends TrackedEvent {

    private String type;
    private String status;

    public OperationalEvent(Object source) {
        super(source);
    }


    @Builder(builderMethodName = "optionalEvent")
    public OperationalEvent(Object source, String correlationId, String description, String type, String status) {
        super(source, correlationId, description);
        this.type = type;
        this.status = status;
    }

    @Override
    public String toString() {
        return "OperationalEvent{" +
                "type='" + type + '\'' +
                ", status='" + status + '\'' +
                "correlationId:" + correlationId +
                '}';
    }
}

And than the following code should work as expected:

public static void main(String[] args) {
    ApplicationEvent applicationEvent = new ApplicationEvent(new Object()) {
        @Override
        public Object getSource() {
            return super.getSource();
        }
    };
    OperationalEvent opsEvent = OperationalEvent.optionalEvent()
            .description("something happened")
            .source(applicationEvent)
            .status("status")
            .correlationId("1")
            .build();

}

Since release 1.18.2 lombok includes the new experimental @SuperBuilder. It supports fields from superclasses (also abstract ones). With it, the solution is as simple as this:

@SuperBuilder
public class Child extends Parent {
   private String a;
   private int b;
   private boolean c;
}

@SuperBuilder
public class Parent {
    private double d;
    private float e;
}

Child instance = Child.builder().b(7).e(6.3).build();

Update 2019-10-09: If you use IntelliJ, you need at least version 0.27 of the IntelliJ Lombok plugin to use @SuperBuilder.

PS: @AllArgsConstructor(onConstructor=@__(@Builder)) does not work because @Builder is an annotation-processing annotation that lombok translates to code during compilation. Generating and then translating new lombok annotation would require several iterations of annotation processing, and lombok does not support that. @Autowired, in contrast, is a regular Java annotation available at runtime.

Here we just need to call super of the builder.

@Data
public class B extends A {
    Integer b1;

    @Builder
    public B(Integer b1, Integer a1) {
        super(a1);
        this.b1 = b1;
    }

    public static class BBuilder extends ABuilder{
            BBuilder() {
                super();
            }
    }
}

@Builder should be added to the class not the constructor like so:

import lombok.Builder;
@Builder
public class C extends B {
    private String fieldC;

    public C(String fieldC, String fieldB, String fieldA) {
        super(fieldB, String fieldA);
        this.fieldC = fieldC;
    }
}

The @Builder annotation causes lombok to generate the inner Builder-class. Adding stuff like @Builder.Default to fields or methods will just modify the builder methods. See the following example from lombok's @Builder description page:

import lombok.Builder;
import lombok.Singular;
import java.util.Set;

@Builder
public class BuilderExample {
    @Builder.Default private long created = System.currentTimeMillis();
    private String name;
    private int age;
    @Singular private Set<String> occupations;
}

A class annotated with @Builder will automatically have an inner class named like the outer class but postfixed with 'Builder'. You can then instantiate such a builder by calling:

MyClass myObject = MyClass.builder().withSomething("abc").build();