val member: String?,
        val acceptation: String?,
        val changes: List<String>?
    ) {
        override fun toString(): String = "Type: '$type', Member: '$member'"
    }

    @VisibleForTesting
    data class AcceptedApiChanges(
        val acceptedApiChanges: List<AcceptedApiChange>?
    )

  // context and TF server for multi-client execution.
  virtual absl::Status EnableCollectiveOps(const ServerDef& server_def) = 0;

  // Set a distributed manager that helps set up, update, and check liveness
  // of member tasks in the cluster.
  virtual void SetDistributedManager(
      std::unique_ptr<ImmediateExecutionDistributedManager> distributed) = 0;

  virtual ImmediateExecutionDistributedManager* GetDistributedManager() = 0;

        return true;
      }
    }
    return false;
  }

  private boolean isIgnored(Member member) {
    return member.isSynthetic() || ignoredMembers.contains(member) || isEquals(member);
  }

  /**
   * Returns true if the given member is a method that overrides {@link Object#equals(Object)}.
   *

 */
@ElementTypesAreNonnullByDefault
public abstract class Invokable<T, R> implements AnnotatedElement, Member {
  private final AccessibleObject accessibleObject;
  private final Member member;

  <M extends AccessibleObject & Member> Invokable(M member) {
    checkNotNull(member);
    this.accessibleObject = member;
    this.member = member;
  }

  /** Returns {@link Invokable} of {@code method}. */

        }

    fun isSince(version: String, member: JApiCompatibility): Boolean =
        apiSourceFileFor(member).let { apiSourceFile ->
            when (apiSourceFile) {
                is ApiSourceFile.Java -> sources.executeQuery(apiSourceFile, JavaSourceQueries.isSince(version, member))
                is ApiSourceFile.Kotlin -> sources.executeQuery(apiSourceFile, KotlinSourceQueries.isSince(version, member))
            }
        }

    private

            for (ClassDoc subClass : classDoc.getSubClasses()) {
                Element member = document.createElement("member");
                Element apilink = document.createElement("apilink");
                apilink.setAttribute("class", subClass.getName());
                member.appendChild(apilink);
                simplelist.appendChild(member);
            }
            seg.appendChild(simplelist);
        }
    }

    fun isSince(version: String, member: JApiCompatibility): JavaSourceQuery<Boolean> =
        member.jApiClass.simpleName.let { declaringClassSimpleName ->
            JavaSourceQuery(
                false,
                when (member) {
                    is JApiClass -> isSinceJavaClassVisitorFor(declaringClassSimpleName, version)
                    is JApiField -> isSinceJavaFieldVisitorFor(member, version)

            else -> throw IllegalArgumentException("Unsupported javassist member type '${this::class}'")
        }
}


internal
enum class MemberType {
    TYPE, CONSTRUCTOR, FIELD, METHOD
}


private
fun memberTypeFor(member: CtMember): MemberType =
    when (member) {
        is CtConstructor -> MemberType.CONSTRUCTOR
        is CtField -> MemberType.FIELD

    BinaryBreakingSuperclassChangeRule(Map<String, Object> params) {
        super(params)
    }

    @Override
    protected boolean changed(JApiCompatibility member) {
        return member instanceof JApiClass && !member.superclass.binaryCompatible && !member.superclass.compatibilityChanges.empty
    }

    @Override
    protected Violation checkSuperClassChanges(JApiClass apiClass, CtClass oldClass, CtClass newClass) {

        return true;
      }
    }
    return false;
  }

  private boolean isIgnored(Member member) {
    return member.isSynthetic() || ignoredMembers.contains(member) || isEquals(member);
  }

  /**
   * Returns true if the given member is a method that overrides {@link Object#equals(Object)}.
   *