}

    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

            """
                {
                    "acceptedApiChanges": [
                        {
                            "type": "org.gradle.api.file.SourceDirectorySet",
                            "member": "Method org.gradle.api.file.SourceDirectorySet.getOutputDir()",
                            "acceptation": "Deprecated method removed",
                            "changes": [

    response = client.post("/", json={"numbers": [1, 2, 3]})
    assert response.json() == IsDict(
        {
            "detail": {
                "errors": [
                    {
                        "type": "list_type",
                        "loc": ["body"],
                        "msg": "Input should be a valid list",
                        "input": {"numbers": [1, 2, 3]},
                    }
                ],

#         ; localTableName  = MEMBER             ; foreignTableName  = MEMBER_STATUS
#         ; localColumnName = MEMBER_STATUS_CODE ; foreignColumnName = MEMBER_STATUS_CODE
#     }
#     ; FK_PURCHASE_MEMBER_ID = map:{
#         ; localTableName  = PURCHASE  ; foreignTableName  = MEMBER
#     }
#     ; FK_MEMBER_MEMBER_ADDRESS_VALID = map:{
#         ; localTableName  = MEMBER    ; foreignTableName  = MEMBER_ADDRESS

    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)

    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 custom_route_handler


app = FastAPI()
app.router.route_class = GzipRoute


@app.post("/sum")
async def sum_numbers(numbers: List[int] = Body()):

                        "member": "Implemented interface org.gradle.api.initialization.IncludedBuild",
                        "changes": ["Interface has been removed"],
                        "acceptation": "@Incubating interface has been removed"
                    },
                    {
                        "type": "other.Type",
                        "member": "Method other.Type.someMethod",

        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)}.
   *

            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