class AnonymousValueImpl implements AnonymousValue {

    private final List<Value<?>> args;
    private final List<Import> imports;
    private final List<Type> typeParams;
    private final List<Field> fields;
    private final List<Method> methods;
    private final List<Initializer> initializers;
    private final List<ClassOrInterface<?>> innerClasses;
    private Type value;

    public AnonymousValueImpl() {
        this.args         = new ArrayList<>();
        this.imports      = new ArrayList<>();
        this.typeParams   = new ArrayList<>();
        this.fields       = new ArrayList<>();
        this.methods      = new ArrayList<>();
        this.initializers = new ArrayList<>();
        this.innerClasses = new ArrayList<>();
    }

    private AnonymousValueImpl(AnonymousValue prototype) {
        this.args             = Copier.copy(prototype.getValues(), HasCopy::copy);
        this.imports          = Copier.copy(prototype.getImports());
        this.typeParams       = new ArrayList<>(prototype.getTypeParameters());
        this.fields           = Copier.copy(prototype.getFields());
        this.methods          = Copier.copy(prototype.getMethods());
        this.initializers     = Copier.copy(prototype.getInitializers());
        this.innerClasses     = Copier.copy(prototype.getClasses(), ClassOrInterface::copy);
        this.value            = prototype.getValue();
    }

    @Override
    public Type getValue() {
        return value;
    }

    @Override
    public List<Value<?>> getValues() {
        return args;
    }

    @Override
    public List<Import> getImports() {
        return imports;
    }

    @Override
    public List<Type> getTypeParameters() {
        return typeParams;
    }

    @Override
    public List<Field> getFields() {
        return fields;
    }

    @Override
    public List<Method> getMethods() {
        return methods;
    }

    @Override
    public List<Initializer> getInitializers() {
        return initializers;
    }

    @Override
    public List<ClassOrInterface<?>> getClasses() {
        return innerClasses;
    }

    @Override
    public AnonymousValue setValue(Type value) {
        this.value = value;
        return this;
    }

    @Override
    public AnonymousValue copy() {
        return new AnonymousValueImpl(this);
    }

    @Override
    public boolean equals(Object o) {<FILL_FUNCTION_BODY>}

    @Override
    public int hashCode() {
        return Objects.hash(args, imports, typeParams, fields, methods, initializers, innerClasses, value);
    }
}

        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        final AnonymousValueImpl that = (AnonymousValueImpl) o;
        return Objects.equals(args, that.args) &&
                Objects.equals(imports, that.imports) &&
                Objects.equals(typeParams, that.typeParams) &&
                Objects.equals(fields, that.fields) &&
                Objects.equals(methods, that.methods) &&
                Objects.equals(initializers, that.initializers) &&
                Objects.equals(innerClasses, that.innerClasses) &&
                Objects.equals(value, that.value);
    
<no_super_class>