companion object Factory {
        fun visibility(visibility: Visibility): AttributePredicate = object: AttributePredicate {
            override fun match(kmClass: KmClass) = kmClass.visibility == visibility
            override fun match(kmConstructor: KmConstructor) = kmConstructor.visibility == visibility
            override fun match(kmProperty: KmProperty) = kmProperty.visibility == visibility

    ),
    values = {"cpu": "riscv64"},
    visibility = ["//visibility:public"],
)

config_setting(
    name = "debug",
    values = {
        "compilation_mode": "dbg",
    },
    visibility = ["//visibility:public"],
)

config_setting(
    name = "optimized",
    values = {
        "compilation_mode": "opt",
    },
    visibility = ["//visibility:public"],
)

config_setting(

        "tfe_tensorhandle_internal.h",
    ],
    visibility = [
        "//tensorflow/core/function/runtime_client:__pkg__",
        "//tensorflow/python:__subpackages__",
    ],
)

cc_library(
    name = "c_api_internal",
    hdrs = [
        "c_api_experimental.h",
        "c_api_internal.h",
    ],
    visibility = ["//tensorflow:internal"],
    deps = [
        ":c_api",

        if (Modifier.isPrivate(ctClass.modifiers)) false
        else hasAttribute(ctClass, AttributePredicate.visibility(Visibility.INTERNAL))

    fun isKotlinInternal(ctMember: CtMember): Boolean =
        if (Modifier.isPrivate(ctMember.modifiers)) false
        else hasAttribute(ctMember, AttributePredicate.visibility(Visibility.INTERNAL))

    fun isKotlinOperatorFunction(ctMethod: CtMethod): Boolean =

)

filegroup(
    name = "safe_ptr_hdr",
    srcs = ["safe_ptr.h"],
    visibility = [
        "//tensorflow:internal",
    ],
)

cc_library(
    name = "safe_ptr",
    srcs = [
        "safe_ptr.cc",
        "//tensorflow/c/eager:headers",
    ],
    hdrs = ["safe_ptr.h"],
    visibility = [
        "//tensorflow:internal",
    ],
    deps = [
        ":c_api_internal",
    ],
)

    tester.testStaticMethods(PatternFilenameFilter.class, Visibility.PACKAGE); // currently none

    // The reason that we skip this method is discussed in a comment on the method.
    tester.ignore(PatternFilenameFilter.class.getMethod("accept", File.class, String.class));
    tester.testInstanceMethods(new PatternFilenameFilter(".*"), Visibility.PACKAGE);
  }

        ":lib_headers",
    ],
    visibility = ["//tensorflow/python:__pkg__"],
)

filegroup(
    name = "sources",
    srcs = [
        ":device_sources",
        ":lib_sources",
    ],
    visibility = ["//tensorflow/python:__pkg__"],
)

cc_library(
    name = "parallel_device",
    srcs = [":device_sources"],
    hdrs = [":device_headers"],
    visibility = ["//visibility:private"],
    deps = [

  public void testAllPublicConstructors(Class<?> c) {
    testConstructors(c, Visibility.PUBLIC);
  }

  /**
   * Runs {@link #testMethod} on every static method of class {@code c} that has at least {@code
   * minimalVisibility}, including those "inherited" from superclasses of the same package.
   */
  public void testStaticMethods(Class<?> c, Visibility minimalVisibility) {
    for (Method method : minimalVisibility.getStaticMethods(c)) {

#else
#define TF_CAPI_EXPORT __declspec(dllimport)
#endif  // TF_COMPILE_LIBRARY
#else
#ifdef TF_CAPI_WEAK
#define TF_CAPI_EXPORT \
  __attribute__((visibility("default"))) __attribute((weak))
#else
#define TF_CAPI_EXPORT __attribute__((visibility("default")))
#endif  // TF_CAPI_WEAK
#endif  // _WIN32
#endif  // SWIG

// TF_Bool is the C API typedef for unsigned char, while TF_BOOL is

  private Visibility visibility = Visibility.PACKAGE;
  private Predicate<Class<?>> classFilter =
      (Class<?> cls) -> visibility.isVisible(cls.getModifiers());

  /**
   * Restricts the sanity tests for public API only. By default, package-private API are also
   * covered.
   */
  protected final void publicApiOnly() {
    visibility = Visibility.PUBLIC;
  }

  /**