diff --git a/java/com/google/gerrit/plugins/codeowners/api/CodeOwnerConfigFileInfo.java b/java/com/google/gerrit/plugins/codeowners/api/CodeOwnerConfigFileInfo.java
index 41fa62b..4e9863b 100644
--- a/java/com/google/gerrit/plugins/codeowners/api/CodeOwnerConfigFileInfo.java
+++ b/java/com/google/gerrit/plugins/codeowners/api/CodeOwnerConfigFileInfo.java
@@ -14,6 +14,7 @@
 
 package com.google.gerrit.plugins.codeowners.api;
 
+import com.google.gerrit.extensions.common.WebLinkInfo;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfigImportMode;
 import java.util.List;
 
@@ -43,6 +44,9 @@
   /** The path of the code owner config file. */
   public String path;
 
+  /** Links to the code owner config file in external sites. */
+  public List<WebLinkInfo> webLinks;
+
   /** Imported code owner config files. */
   public List<CodeOwnerConfigFileInfo> imports;
 
diff --git a/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImport.java b/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImport.java
index a75c15b..fc1b521 100644
--- a/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImport.java
+++ b/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImport.java
@@ -22,22 +22,30 @@
 /**
  * Information about an import of a {@link CodeOwnerConfig}.
  *
- * <p>Contains the keys of the importing and the imported code owner config, as well as the
- * reference that the importing code owner config uses to reference the imported code owner config
- * (contains the import mode).
+ * <p>Contains the importing code owner config, the key of the imported code owner config, the
+ * imported code owner config if the import could be resolved, as well as the reference that the
+ * importing code owner config uses to reference the imported code owner config (contains the import
+ * mode).
  *
  * <p>It's possible that this class represents non-resolveable imports (e.g. an import of a
- * non-existing code owner config). In this case an error message is contained that explains why the
- * import couldn't be resolved.
+ * non-existing code owner config). In this case the imported code owner config is not available and
+ * an error message is contained that explains why the import couldn't be resolved.
  */
 @AutoValue
 public abstract class CodeOwnerConfigImport {
   /** Key of the importing code owner config. */
-  public abstract CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig();
+  public abstract CodeOwnerConfig importingCodeOwnerConfig();
 
   /** Key of the imported code owner config. */
   public abstract CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig();
 
+  /**
+   * Imported code owner config.
+   *
+   * <p>Not set for unresolved imports.
+   */
+  public abstract Optional<CodeOwnerConfig> importedCodeOwnerConfig();
+
   /** The code owner config reference that references the imported code owner config. */
   public abstract CodeOwnerConfigReference codeOwnerConfigReference();
 
@@ -50,8 +58,9 @@
   @Override
   public final String toString() {
     return MoreObjects.toStringHelper(this)
-        .add("keyOfImportingCodeOwnerConfig", keyOfImportingCodeOwnerConfig())
+        .add("importingCodeOwnerConfig", importingCodeOwnerConfig())
         .add("keyOfImportedCodeOwnerConfig", keyOfImportedCodeOwnerConfig())
+        .add("importedCodeOwnerConfig", importedCodeOwnerConfig())
         .add("codeOwnerConfigReference", codeOwnerConfigReference())
         .add("errorMessage", errorMessage())
         .toString();
@@ -60,13 +69,14 @@
   /** Creates a {@link CodeOwnerConfigImport} instance for an unresolved import. */
   @VisibleForTesting
   public static CodeOwnerConfigImport createUnresolvedImport(
-      CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig,
+      CodeOwnerConfig importingCodeOwnerConfig,
       CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig,
       CodeOwnerConfigReference codeOwnerConfigReference,
       String errorMessage) {
     return new AutoValue_CodeOwnerConfigImport(
-        keyOfImportingCodeOwnerConfig,
+        importingCodeOwnerConfig,
         keyOfImportedCodeOwnerConfig,
+        Optional.empty(),
         codeOwnerConfigReference,
         Optional.of(errorMessage));
   }
@@ -74,12 +84,13 @@
   /** Creates a {@link CodeOwnerConfigImport} instance for a resolved import. */
   @VisibleForTesting
   public static CodeOwnerConfigImport createResolvedImport(
-      CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig,
-      CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig,
+      CodeOwnerConfig importingCodeOwnerConfig,
+      CodeOwnerConfig importedCodeOwnerConfig,
       CodeOwnerConfigReference codeOwnerConfigReference) {
     return new AutoValue_CodeOwnerConfigImport(
-        keyOfImportingCodeOwnerConfig,
-        keyOfImportedCodeOwnerConfig,
+        importingCodeOwnerConfig,
+        importedCodeOwnerConfig.key(),
+        Optional.of(importedCodeOwnerConfig),
         codeOwnerConfigReference,
         Optional.empty());
   }
diff --git a/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java b/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java
index 5e7a11f..ac4f4eb 100644
--- a/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java
+++ b/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java
@@ -320,8 +320,7 @@
 
       // Resolve per-file imports.
       ImmutableSet<CodeOwnerImport> perFileImports =
-          getPerFileImports(
-              0, codeOwnerConfig.key(), resolvedCodeOwnerConfigBuilder.codeOwnerSets());
+          getPerFileImports(0, codeOwnerConfig, resolvedCodeOwnerConfigBuilder.codeOwnerSets());
       OptionalResultWithMessages<CodeOwnerConfigImports> perFileImportedCodeOwnerConfigs =
           resolveImports(codeOwnerConfig.key(), perFileImports, resolvedCodeOwnerConfigBuilder);
       messages.addAll(perFileImportedCodeOwnerConfigs.messages());
@@ -384,7 +383,7 @@
             codeOwnerConfigImport.referenceToImportedCodeOwnerConfig();
         CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
             createKeyForImportedCodeOwnerConfig(
-                codeOwnerConfigImport.importingCodeOwnerConfig(), codeOwnerConfigReference);
+                codeOwnerConfigImport.importingCodeOwnerConfig().key(), codeOwnerConfigReference);
 
         try (Timer0.Context ctx2 = codeOwnerMetrics.resolveCodeOwnerConfigImport.start()) {
           logger.atFine().log(
@@ -450,7 +449,7 @@
           resolvedImports.add(
               CodeOwnerConfigImport.createResolvedImport(
                   codeOwnerConfigImport.importingCodeOwnerConfig(),
-                  keyOfImportedCodeOwnerConfig,
+                  importedCodeOwnerConfig,
                   codeOwnerConfigReference));
 
           CodeOwnerConfigImportMode importMode = codeOwnerConfigReference.importMode();
@@ -495,7 +494,7 @@
             transitiveImports.addAll(
                 getPerFileImports(
                     codeOwnerConfigImport.importLevel() + 1,
-                    importedCodeOwnerConfig.key(),
+                    importedCodeOwnerConfig,
                     matchingPerFileCodeOwnerSets));
 
             if (importMode == CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY) {
@@ -539,15 +538,12 @@
     return codeOwnerConfig.imports().stream()
         .map(
             codeOwnerConfigReference ->
-                CodeOwnerImport.create(
-                    importLevel, codeOwnerConfig.key(), codeOwnerConfigReference))
+                CodeOwnerImport.create(importLevel, codeOwnerConfig, codeOwnerConfigReference))
         .collect(toImmutableSet());
   }
 
   private ImmutableSet<CodeOwnerImport> getPerFileImports(
-      int importLevel,
-      CodeOwnerConfig.Key importingCodeOwnerConfig,
-      Set<CodeOwnerSet> codeOwnerSets) {
+      int importLevel, CodeOwnerConfig importingCodeOwnerConfig, Set<CodeOwnerSet> codeOwnerSets) {
     ImmutableSet.Builder<CodeOwnerImport> codeOwnerConfigImports = ImmutableSet.builder();
     for (CodeOwnerSet codeOwnerSet : codeOwnerSets) {
       codeOwnerSet.imports().stream()
@@ -646,8 +642,8 @@
      */
     public abstract int importLevel();
 
-    /** The key of the code owner config that contains the import. */
-    public abstract CodeOwnerConfig.Key importingCodeOwnerConfig();
+    /** The code owner config that contains the import. */
+    public abstract CodeOwnerConfig importingCodeOwnerConfig();
 
     /** The reference to the imported code owner config */
     public abstract CodeOwnerConfigReference referenceToImportedCodeOwnerConfig();
@@ -699,7 +695,7 @@
 
     public static CodeOwnerImport create(
         int importLevel,
-        CodeOwnerConfig.Key importingCodeOwnerConfig,
+        CodeOwnerConfig importingCodeOwnerConfig,
         CodeOwnerConfigReference codeOwnerConfigReference) {
       return create(
           importLevel, importingCodeOwnerConfig, codeOwnerConfigReference, Optional.empty());
@@ -707,7 +703,7 @@
 
     public static CodeOwnerImport create(
         int importLevel,
-        CodeOwnerConfig.Key importingCodeOwnerConfig,
+        CodeOwnerConfig importingCodeOwnerConfig,
         CodeOwnerConfigReference codeOwnerConfigReference,
         CodeOwnerSet codeOwnerSet) {
       return create(
@@ -719,7 +715,7 @@
 
     public static CodeOwnerImport create(
         int importLevel,
-        CodeOwnerConfig.Key importingCodeOwnerConfig,
+        CodeOwnerConfig importingCodeOwnerConfig,
         CodeOwnerConfigReference codeOwnerConfigReference,
         Optional<CodeOwnerSet> codeOwnerSet) {
       return new AutoValue_PathCodeOwners_CodeOwnerImport(
diff --git a/java/com/google/gerrit/plugins/codeowners/backend/UnresolvedImportFormatter.java b/java/com/google/gerrit/plugins/codeowners/backend/UnresolvedImportFormatter.java
index 7946468..9f96afc 100644
--- a/java/com/google/gerrit/plugins/codeowners/backend/UnresolvedImportFormatter.java
+++ b/java/com/google/gerrit/plugins/codeowners/backend/UnresolvedImportFormatter.java
@@ -43,9 +43,9 @@
         unresolvedImport.keyOfImportedCodeOwnerConfig().project(),
         unresolvedImport.keyOfImportedCodeOwnerConfig().shortBranchName(),
         getFilePath(unresolvedImport.keyOfImportedCodeOwnerConfig()),
-        unresolvedImport.keyOfImportingCodeOwnerConfig().project(),
-        unresolvedImport.keyOfImportingCodeOwnerConfig().shortBranchName(),
-        getFilePath(unresolvedImport.keyOfImportingCodeOwnerConfig()),
+        unresolvedImport.importingCodeOwnerConfig().key().project(),
+        unresolvedImport.importingCodeOwnerConfig().key().shortBranchName(),
+        getFilePath(unresolvedImport.importingCodeOwnerConfig().key()),
         unresolvedImport
             .errorMessage()
             .orElseThrow(
diff --git a/java/com/google/gerrit/plugins/codeowners/restapi/AbstractGetCodeOwnersForPath.java b/java/com/google/gerrit/plugins/codeowners/restapi/AbstractGetCodeOwnersForPath.java
index 0fbb01d..1ddaa9b 100644
--- a/java/com/google/gerrit/plugins/codeowners/restapi/AbstractGetCodeOwnersForPath.java
+++ b/java/com/google/gerrit/plugins/codeowners/restapi/AbstractGetCodeOwnersForPath.java
@@ -229,7 +229,7 @@
 
           codeOwnerConfigFileInfosBuilder.add(
               codeOwnerConfigFileJson.format(
-                  codeOwnerConfig.key(),
+                  codeOwnerConfig,
                   pathCodeOwners.resolvedImports(),
                   pathCodeOwners.unresolvedImports()));
 
diff --git a/java/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJson.java b/java/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJson.java
index fe17a3f..ed59a8e 100644
--- a/java/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJson.java
+++ b/java/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJson.java
@@ -14,31 +14,35 @@
 
 package com.google.gerrit.plugins.codeowners.restapi;
 
+import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static java.util.Objects.requireNonNull;
 
 import com.google.common.collect.ImmutableList;
+import com.google.gerrit.extensions.common.WebLinkInfo;
 import com.google.gerrit.plugins.codeowners.api.CodeOwnerConfigFileInfo;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfig;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfigImport;
 import com.google.gerrit.plugins.codeowners.backend.UnresolvedImportFormatter;
+import com.google.gerrit.server.WebLinks;
 import com.google.inject.Inject;
 import java.util.List;
 
 /** Collection of routines to populate {@link CodeOwnerConfigFileInfo}. */
 public class CodeOwnerConfigFileJson {
+  private final WebLinks webLinks;
   private final UnresolvedImportFormatter unresolvedImportFormatter;
 
   @Inject
-  CodeOwnerConfigFileJson(UnresolvedImportFormatter unresolvedImportFormatter) {
+  CodeOwnerConfigFileJson(WebLinks webLinks, UnresolvedImportFormatter unresolvedImportFormatter) {
+    this.webLinks = webLinks;
     this.unresolvedImportFormatter = unresolvedImportFormatter;
   }
 
   /**
    * Formats the provided code owner config file information as a {@link CodeOwnerConfigFileInfo}.
    *
-   * @param codeOwnerConfigKey the key of the code owner config file as {@link
-   *     CodeOwnerConfigFileInfo}
+   * @param codeOwnerConfig the code owner config
    * @param resolvedImports code owner config files which have been successfully imported directly
    *     or indirectly
    * @param unresolvedImports code owner config files which are imported directly or indirectly but
@@ -47,6 +51,25 @@
    *     as {@link CodeOwnerConfigFileInfo}
    */
   public CodeOwnerConfigFileInfo format(
+      CodeOwnerConfig codeOwnerConfig,
+      List<CodeOwnerConfigImport> resolvedImports,
+      List<CodeOwnerConfigImport> unresolvedImports) {
+    requireNonNull(codeOwnerConfig, "codeOwnerConfig");
+    requireNonNull(resolvedImports, "resolvedImports");
+    requireNonNull(unresolvedImports, "unresolvedImports");
+
+    CodeOwnerConfigFileInfo info =
+        format(codeOwnerConfig.key(), resolvedImports, unresolvedImports);
+
+    ImmutableList<WebLinkInfo> fileLinks =
+        webLinks.getFileLinks(
+            info.project, info.branch, codeOwnerConfig.revision().getName(), info.path);
+    info.webLinks = !fileLinks.isEmpty() ? fileLinks : null;
+
+    return info;
+  }
+
+  private CodeOwnerConfigFileInfo format(
       CodeOwnerConfig.Key codeOwnerConfigKey,
       List<CodeOwnerConfigImport> resolvedImports,
       List<CodeOwnerConfigImport> unresolvedImports) {
@@ -64,7 +87,7 @@
         unresolvedImports.stream()
             .filter(
                 unresolvedImport ->
-                    unresolvedImport.keyOfImportingCodeOwnerConfig().equals(codeOwnerConfigKey))
+                    unresolvedImport.importingCodeOwnerConfig().key().equals(codeOwnerConfigKey))
             .map(
                 unresolvedImport -> {
                   CodeOwnerConfigFileInfo unresolvedCodeOwnerConfigFileInfo =
@@ -92,12 +115,15 @@
         resolvedImports.stream()
             .filter(
                 resolvedImport ->
-                    resolvedImport.keyOfImportingCodeOwnerConfig().equals(codeOwnerConfigKey))
+                    resolvedImport.importingCodeOwnerConfig().key().equals(codeOwnerConfigKey))
             .map(
                 resolvedImport -> {
+                  checkState(
+                      resolvedImport.importedCodeOwnerConfig().isPresent(),
+                      "no imported code owner config for resolved import");
                   CodeOwnerConfigFileInfo resolvedCodeOwnerConfigFileInfo =
                       format(
-                          resolvedImport.keyOfImportedCodeOwnerConfig(),
+                          resolvedImport.importedCodeOwnerConfig().get(),
                           removeImportEntriesFor(resolvedImports, codeOwnerConfigKey),
                           removeImportEntriesFor(unresolvedImports, codeOwnerConfigKey));
                   resolvedCodeOwnerConfigFileInfo.importMode =
@@ -113,7 +139,7 @@
   private ImmutableList<CodeOwnerConfigImport> removeImportEntriesFor(
       List<CodeOwnerConfigImport> imports, CodeOwnerConfig.Key codeOwnerConfigKey) {
     return imports.stream()
-        .filter(i -> !i.keyOfImportingCodeOwnerConfig().equals(codeOwnerConfigKey))
+        .filter(i -> !i.importingCodeOwnerConfig().key().equals(codeOwnerConfigKey))
         .collect(toImmutableList());
   }
 }
diff --git a/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImportTest.java b/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImportTest.java
index b6efbc6..85e7eb5 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImportTest.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImportTest.java
@@ -14,16 +14,24 @@
 
 package com.google.gerrit.plugins.codeowners.backend;
 
+import org.eclipse.jgit.lib.ObjectId;
 import org.junit.Test;
 
 /** Tests for {@link CodeOwnerConfigImport}. */
 public class CodeOwnerConfigImportTest extends AbstractAutoValueTest {
+  private static final ObjectId TEST_REVISION =
+      ObjectId.fromString("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef");
+
   @Test
   public void toStringIncludesAllData_resolvedImport() throws Exception {
     CodeOwnerConfigImport resolvedImport =
         CodeOwnerConfigImport.createResolvedImport(
-            CodeOwnerConfig.Key.create(project, "master", "/"),
-            CodeOwnerConfig.Key.create(project, "master", "/bar/"),
+            CodeOwnerConfig.builder(
+                    CodeOwnerConfig.Key.create(project, "master", "/"), TEST_REVISION)
+                .build(),
+            CodeOwnerConfig.builder(
+                    CodeOwnerConfig.Key.create(project, "master", "/bar/"), TEST_REVISION)
+                .build(),
             CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"));
     assertThatToStringIncludesAllData(resolvedImport, CodeOwnerConfigImport.class);
   }
@@ -32,7 +40,9 @@
   public void toStringIncludesAllData_unresolvedImport() throws Exception {
     CodeOwnerConfigImport unresolvedImport =
         CodeOwnerConfigImport.createUnresolvedImport(
-            CodeOwnerConfig.Key.create(project, "master", "/"),
+            CodeOwnerConfig.builder(
+                    CodeOwnerConfig.Key.create(project, "master", "/"), TEST_REVISION)
+                .build(),
             CodeOwnerConfig.Key.create(project, "master", "/bar/"),
             CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"),
             "test message");
diff --git a/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResultTest.java b/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResultTest.java
index deab817..febdf6b 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResultTest.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResultTest.java
@@ -17,10 +17,14 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMultimap;
 import com.google.common.collect.ImmutableSet;
+import org.eclipse.jgit.lib.ObjectId;
 import org.junit.Test;
 
 /** Tests for {@link CodeOwnerResolverResult}. */
 public class CodeOwnerResolverResultTest extends AbstractAutoValueTest {
+  private static final ObjectId TEST_REVISION =
+      ObjectId.fromString("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef");
+
   @Test
   public void toStringIncludesAllData() throws Exception {
     CodeOwnerResolverResult codeOwnerResolverResult =
@@ -31,12 +35,18 @@
             /* hasUnresolvedCodeOwners= */ false,
             ImmutableList.of(
                 CodeOwnerConfigImport.createResolvedImport(
-                    CodeOwnerConfig.Key.create(project, "master", "/"),
-                    CodeOwnerConfig.Key.create(project, "master", "/bar/"),
+                    CodeOwnerConfig.builder(
+                            CodeOwnerConfig.Key.create(project, "master", "/"), TEST_REVISION)
+                        .build(),
+                    CodeOwnerConfig.builder(
+                            CodeOwnerConfig.Key.create(project, "master", "/bar/"), TEST_REVISION)
+                        .build(),
                     CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"))),
             ImmutableList.of(
                 CodeOwnerConfigImport.createUnresolvedImport(
-                    CodeOwnerConfig.Key.create(project, "master", "/"),
+                    CodeOwnerConfig.builder(
+                            CodeOwnerConfig.Key.create(project, "master", "/"), TEST_REVISION)
+                        .build(),
                     CodeOwnerConfig.Key.create(project, "master", "/bar/"),
                     CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"),
                     "test message")),
diff --git a/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResultTest.java b/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResultTest.java
index a33835d..2970d71 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResultTest.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResultTest.java
@@ -27,6 +27,8 @@
   @Test
   public void toStringIncludesAllData() throws Exception {
     CodeOwnerConfig.Key codeOwnerConfigKey = CodeOwnerConfig.Key.create(project, "master", "/");
+    CodeOwnerConfig codeOwnerConfig =
+        CodeOwnerConfig.builder(codeOwnerConfigKey, TEST_REVISION).build();
     CodeOwnerConfigReference resolvableCodeOwnerConfigReference =
         CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS");
     CodeOwnerConfigReference unresolvableCodeOwnerConfigReference =
@@ -40,12 +42,14 @@
                 .build(),
             ImmutableList.of(
                 CodeOwnerConfigImport.createResolvedImport(
-                    codeOwnerConfigKey,
-                    CodeOwnerConfig.Key.create(project, "master", "/bar/"),
+                    codeOwnerConfig,
+                    CodeOwnerConfig.builder(
+                            CodeOwnerConfig.Key.create(project, "master", "/bar/"), TEST_REVISION)
+                        .build(),
                     resolvableCodeOwnerConfigReference)),
             ImmutableList.of(
                 CodeOwnerConfigImport.createUnresolvedImport(
-                    codeOwnerConfigKey,
+                    codeOwnerConfig,
                     CodeOwnerConfig.Key.create(project, "master", "/baz/"),
                     unresolvableCodeOwnerConfigReference,
                     "test message")));
diff --git a/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersTest.java b/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersTest.java
index 73d1e3d..8c67161 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersTest.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersTest.java
@@ -474,7 +474,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with non-resolveable import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -484,10 +484,13 @@
             .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(admin.email()).build())
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -502,7 +505,7 @@
     assertThat(pathCodeOwnersResult.unresolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createUnresolvedImport(
-                importingCodeOwnerConfigKey,
+                importingCodeOwnerConfig,
                 keyOfImportedCodeOwnerConfig,
                 codeOwnerConfigReference,
                 String.format(
@@ -530,7 +533,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create config with import of non code owner config file
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -540,10 +543,13 @@
             .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(admin.email()).build())
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -558,7 +564,7 @@
     assertThat(pathCodeOwnersResult.unresolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createUnresolvedImport(
-                importingCodeOwnerConfigKey,
+                importingCodeOwnerConfig,
                 keyOfImportedCodeOwnerConfig,
                 codeOwnerConfigReference,
                 String.format(
@@ -589,7 +595,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create the importing config
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -599,10 +605,13 @@
             .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(admin.email()).build())
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -618,7 +627,7 @@
     assertThat(pathCodeOwnersResult.unresolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createUnresolvedImport(
-                importingCodeOwnerConfigKey,
+                importingCodeOwnerConfig,
                 keyOfImportedCodeOwnerConfig,
                 codeOwnerConfigReference,
                 String.format(
@@ -650,7 +659,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create the importing config
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -660,10 +669,15 @@
             .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(admin.email()).build())
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -677,9 +691,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -708,7 +720,7 @@
         createCodeOwnerConfigReference(importMode, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -718,10 +730,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -735,9 +752,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -761,7 +776,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with matching per-file code owner and import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -775,10 +790,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -792,9 +812,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -818,7 +836,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with matching per-file code owner and import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -832,10 +850,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -850,9 +873,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -877,7 +898,7 @@
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
 
     // create importing config with matching per-file code owner and import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -891,10 +912,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -909,9 +935,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -939,7 +963,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -949,10 +973,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -970,9 +999,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1000,7 +1027,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1010,10 +1037,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1030,9 +1062,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1060,7 +1090,7 @@
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1070,10 +1100,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1090,9 +1125,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1112,7 +1145,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1122,10 +1155,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1137,9 +1175,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1161,7 +1197,7 @@
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
 
     // create importing config
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1171,10 +1207,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1186,9 +1227,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1236,7 +1275,7 @@
         createCodeOwnerConfigReference(importMode, keyOfImportedCodeOwnerConfig1);
 
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1246,10 +1285,17 @@
             .addImport(codeOwnerConfigReference1)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig1 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig1).get();
+    CodeOwnerConfig importedCodeOwnerConfig2 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig2).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1263,13 +1309,9 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig1,
-                codeOwnerConfigReference1),
+                importingCodeOwnerConfig, importedCodeOwnerConfig1, codeOwnerConfigReference1),
             CodeOwnerConfigImport.createResolvedImport(
-                keyOfImportedCodeOwnerConfig1,
-                keyOfImportedCodeOwnerConfig2,
-                codeOwnerConfigReference2));
+                importedCodeOwnerConfig1, importedCodeOwnerConfig2, codeOwnerConfigReference2));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1313,7 +1355,7 @@
 
     // create importing config with global code owner and import with import mode
     // GLOBAL_CODE_OWNER_SETS_ONLY
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1323,10 +1365,17 @@
             .addImport(codeOwnerConfigReference1)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig1 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig1).get();
+    CodeOwnerConfig importedCodeOwnerConfig2 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig2).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1341,12 +1390,10 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig1,
-                codeOwnerConfigReference1),
+                importingCodeOwnerConfig, importedCodeOwnerConfig1, codeOwnerConfigReference1),
             CodeOwnerConfigImport.createResolvedImport(
-                keyOfImportedCodeOwnerConfig1,
-                keyOfImportedCodeOwnerConfig2,
+                importedCodeOwnerConfig1,
+                importedCodeOwnerConfig2,
                 createCodeOwnerConfigReference(
                     CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY,
                     keyOfImportedCodeOwnerConfig2)));
@@ -1390,7 +1437,7 @@
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1400,10 +1447,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1417,9 +1469,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1443,7 +1493,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1454,10 +1504,15 @@
             .addImport(codeOwnerConfigReference1)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1470,13 +1525,9 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference1),
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference1),
             CodeOwnerConfigImport.createResolvedImport(
-                keyOfImportedCodeOwnerConfig,
-                importingCodeOwnerConfigKey,
-                codeOwnerConfigReference2));
+                importedCodeOwnerConfig, importingCodeOwnerConfig, codeOwnerConfigReference2));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1547,7 +1598,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import with relative path
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1557,10 +1608,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1573,9 +1629,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1587,7 +1641,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import from non-existing project
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1597,10 +1651,13 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1614,7 +1671,7 @@
     assertThat(pathCodeOwnersResult.unresolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createUnresolvedImport(
-                importingCodeOwnerConfigKey,
+                importingCodeOwnerConfig,
                 keyOfImportedCodeOwnerConfig,
                 codeOwnerConfigReference,
                 String.format("project %s not found", keyOfImportedCodeOwnerConfig.project())));
@@ -1640,7 +1697,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import from the hidden project
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1650,10 +1707,13 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1669,7 +1729,7 @@
     assertThat(pathCodeOwnersResult.unresolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createUnresolvedImport(
-                importingCodeOwnerConfigKey,
+                importingCodeOwnerConfig,
                 keyOfImportedCodeOwnerConfig,
                 codeOwnerConfigReference,
                 String.format(
@@ -1685,7 +1745,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import from non-existing branch
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1695,10 +1755,13 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1712,7 +1775,7 @@
     assertThat(pathCodeOwnersResult.unresolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createUnresolvedImport(
-                importingCodeOwnerConfigKey,
+                importingCodeOwnerConfig,
                 keyOfImportedCodeOwnerConfig,
                 codeOwnerConfigReference,
                 "code owner config does not exist (revision = current)"));
@@ -1736,7 +1799,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import with relative path
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1746,10 +1809,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1762,9 +1830,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1795,7 +1861,7 @@
             .build();
 
     // create importing config with global code owner and import with relative path
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1805,10 +1871,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead(branchName),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1821,9 +1892,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1847,7 +1916,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import with relative path
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1857,10 +1926,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1873,9 +1947,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1901,7 +1973,7 @@
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import with relative path
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1911,10 +1983,15 @@
             .addImport(codeOwnerConfigReference)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1927,9 +2004,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -1942,7 +2017,7 @@
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
 
     // create importing config with non-resolveable per file import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1956,10 +2031,13 @@
                     .build())
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1974,7 +2052,7 @@
     assertThat(pathCodeOwnersResult.unresolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createUnresolvedImport(
-                importingCodeOwnerConfigKey,
+                importingCodeOwnerConfig,
                 keyOfImportedCodeOwnerConfig,
                 codeOwnerConfigReference,
                 String.format(
@@ -2011,7 +2089,7 @@
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
 
     // create importing config with per code owner and per file import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -2025,10 +2103,15 @@
                     .build())
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -2047,9 +2130,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -2087,7 +2168,7 @@
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig1);
 
     // create importing config with per file code owner and per file import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -2101,10 +2182,17 @@
                     .build())
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig1 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig1).get();
+    CodeOwnerConfig importedCodeOwnerConfig2 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig2).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -2118,13 +2206,9 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig1,
-                codeOwnerConfigReference1),
+                importingCodeOwnerConfig, importedCodeOwnerConfig1, codeOwnerConfigReference1),
             CodeOwnerConfigImport.createResolvedImport(
-                keyOfImportedCodeOwnerConfig1,
-                keyOfImportedCodeOwnerConfig2,
-                codeOwnerConfigReference2));
+                importedCodeOwnerConfig1, importedCodeOwnerConfig2, codeOwnerConfigReference2));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -2165,7 +2249,7 @@
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig1);
 
     // create importing config with per file code owner and per file import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -2179,10 +2263,17 @@
                     .build())
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig1 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig1).get();
+    CodeOwnerConfig importedCodeOwnerConfig2 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig2).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -2197,12 +2288,10 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig1,
-                codeOwnerConfigReference1),
+                importingCodeOwnerConfig, importedCodeOwnerConfig1, codeOwnerConfigReference1),
             CodeOwnerConfigImport.createResolvedImport(
-                keyOfImportedCodeOwnerConfig1,
-                keyOfImportedCodeOwnerConfig2,
+                importedCodeOwnerConfig1,
+                importedCodeOwnerConfig2,
                 createCodeOwnerConfigReference(
                     CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY,
                     keyOfImportedCodeOwnerConfig2)));
@@ -2265,7 +2354,7 @@
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig1);
 
     // create importing config with global import
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -2274,12 +2363,21 @@
             .addImport(codeOwnerConfigReference1)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig1 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig1).get();
+    CodeOwnerConfig importedCodeOwnerConfig2 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig2).get();
+    CodeOwnerConfig importedCodeOwnerConfig3 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig3).get();
+
     // Expectation for foo.xyz file: code owners is empty since foo.xyz neither matches *.md nor
     // *.txt
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.xyz"));
     assertThat(pathCodeOwners).isPresent();
@@ -2288,16 +2386,14 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig1,
-                codeOwnerConfigReference1));
+                importingCodeOwnerConfig, importedCodeOwnerConfig1, codeOwnerConfigReference1));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
 
     // Expectation for foo.md file: code owners contains only user since foo.md only matches *.md
     pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -2308,13 +2404,9 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig1,
-                codeOwnerConfigReference1),
+                importingCodeOwnerConfig, importedCodeOwnerConfig1, codeOwnerConfigReference1),
             CodeOwnerConfigImport.createResolvedImport(
-                keyOfImportedCodeOwnerConfig1,
-                keyOfImportedCodeOwnerConfig2,
-                codeOwnerConfigReference2));
+                importedCodeOwnerConfig1, importedCodeOwnerConfig2, codeOwnerConfigReference2));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
 
     // Expectation for foo.txt file: code owners contains only user2 since foo.txt only matches
@@ -2322,7 +2414,7 @@
     pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.txt"));
     assertThat(pathCodeOwners).isPresent();
@@ -2333,13 +2425,9 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig1,
-                codeOwnerConfigReference1),
+                importingCodeOwnerConfig, importedCodeOwnerConfig1, codeOwnerConfigReference1),
             CodeOwnerConfigImport.createResolvedImport(
-                keyOfImportedCodeOwnerConfig1,
-                keyOfImportedCodeOwnerConfig3,
-                codeOwnerConfigReference3));
+                importedCodeOwnerConfig1, importedCodeOwnerConfig3, codeOwnerConfigReference3));
   }
 
   @Test
@@ -2481,7 +2569,7 @@
     // * has a global code owner
     // * has a per-file import for md files
     // * ignores global and parent code owners for md files
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -2496,10 +2584,15 @@
                     .build())
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -2514,9 +2607,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -2548,7 +2639,7 @@
 
     // create importing config that has a global import with mode ALL and a per-file rule for md
     // files that ignores global and parent code owners
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -2564,10 +2655,15 @@
                     .build())
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -2583,9 +2679,7 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig,
-                codeOwnerConfigReference));
+                importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -2625,7 +2719,7 @@
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig1);
 
     // create importing config
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -2635,10 +2729,17 @@
             .addImport(codeOwnerConfigReference1)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig1 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig1).get();
+    CodeOwnerConfig importedCodeOwnerConfig2 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig2).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -2652,13 +2753,9 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig1,
-                codeOwnerConfigReference1),
+                importingCodeOwnerConfig, importedCodeOwnerConfig1, codeOwnerConfigReference1),
             CodeOwnerConfigImport.createResolvedImport(
-                keyOfImportedCodeOwnerConfig1,
-                keyOfImportedCodeOwnerConfig2,
-                codeOwnerConfigReference2));
+                importedCodeOwnerConfig1, importedCodeOwnerConfig2, codeOwnerConfigReference2));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
@@ -2698,7 +2795,7 @@
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig1);
 
     // create importing config
-    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -2708,10 +2805,17 @@
             .addImport(codeOwnerConfigReference1)
             .create();
 
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
+    CodeOwnerConfig importedCodeOwnerConfig1 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig1).get();
+    CodeOwnerConfig importedCodeOwnerConfig2 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig2).get();
+
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            importingCodeOwnerConfigKey,
+            keyOfImportingCodeOwnerConfig,
             projectOperations.project(project).getHead("master"),
             Path.of("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -2725,13 +2829,9 @@
     assertThat(pathCodeOwnersResult.resolvedImports())
         .containsExactly(
             CodeOwnerConfigImport.createResolvedImport(
-                importingCodeOwnerConfigKey,
-                keyOfImportedCodeOwnerConfig1,
-                codeOwnerConfigReference1),
+                importingCodeOwnerConfig, importedCodeOwnerConfig1, codeOwnerConfigReference1),
             CodeOwnerConfigImport.createResolvedImport(
-                keyOfImportedCodeOwnerConfig1,
-                keyOfImportedCodeOwnerConfig2,
-                codeOwnerConfigReference2));
+                importedCodeOwnerConfig1, importedCodeOwnerConfig2, codeOwnerConfigReference2));
     assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
diff --git a/javatests/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJsonIT.java b/javatests/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJsonIT.java
index ed0b301..fa1d9c8 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJsonIT.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJsonIT.java
@@ -19,18 +19,25 @@
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
-import com.google.gerrit.entities.Project;
+import com.google.gerrit.acceptance.ExtensionRegistry;
+import com.google.gerrit.acceptance.ExtensionRegistry.Registration;
+import com.google.gerrit.entities.BranchNameKey;
+import com.google.gerrit.extensions.common.WebLinkInfo;
+import com.google.gerrit.extensions.webui.FileWebLink;
 import com.google.gerrit.plugins.codeowners.acceptance.AbstractCodeOwnersIT;
 import com.google.gerrit.plugins.codeowners.api.CodeOwnerConfigFileInfo;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfig;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfigImport;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfigImportMode;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfigReference;
+import com.google.inject.Inject;
 import org.junit.Before;
 import org.junit.Test;
 
 /** Tests for {@link CodeOwnerConfigFileJson}. */
 public class CodeOwnerConfigFileJsonIT extends AbstractCodeOwnersIT {
+  @Inject private ExtensionRegistry extensionRegistry;
+
   private CodeOwnerConfigFileJson CodeOwnerConfigFileJson;
 
   @Before
@@ -39,28 +46,35 @@
   }
 
   @Test
-  public void cannotFormatWithNullCodeOwnerConfigKey() throws Exception {
+  public void cannotFormatWithNullCodeOwnerConfig() throws Exception {
     NullPointerException npe =
         assertThrows(
             NullPointerException.class,
             () ->
                 CodeOwnerConfigFileJson.format(
-                    /* codeOwnerConfigKey= */ null,
+                    /* codeOwnerConfig= */ null,
                     /* resolvedImports= */ ImmutableList.of(),
                     /* unresolvedImports= */ ImmutableList.of()));
-    assertThat(npe).hasMessageThat().isEqualTo("codeOwnerConfigKey");
+    assertThat(npe).hasMessageThat().isEqualTo("codeOwnerConfig");
   }
 
   @Test
   public void cannotFormatWithNullResolvedImports() throws Exception {
     CodeOwnerConfig.Key codeOwnerConfigKey =
-        CodeOwnerConfig.Key.create(Project.nameKey("project"), "master", "/");
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+    CodeOwnerConfig codeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).get();
     NullPointerException npe =
         assertThrows(
             NullPointerException.class,
             () ->
                 CodeOwnerConfigFileJson.format(
-                    codeOwnerConfigKey,
+                    codeOwnerConfig,
                     /* resolvedImports= */ null,
                     /* unresolvedImports= */ ImmutableList.of()));
     assertThat(npe).hasMessageThat().isEqualTo("resolvedImports");
@@ -69,13 +83,20 @@
   @Test
   public void cannotFormatWithNullUnresolvedImports() throws Exception {
     CodeOwnerConfig.Key codeOwnerConfigKey =
-        CodeOwnerConfig.Key.create(Project.nameKey("project"), "master", "/");
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+    CodeOwnerConfig codeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).get();
     NullPointerException npe =
         assertThrows(
             NullPointerException.class,
             () ->
                 CodeOwnerConfigFileJson.format(
-                    codeOwnerConfigKey,
+                    codeOwnerConfig,
                     /* resolvedImports= */ ImmutableList.of(),
                     /* unresolvedImports= */ null));
     assertThat(npe).hasMessageThat().isEqualTo("unresolvedImports");
@@ -83,6 +104,18 @@
 
   @Test
   public void formatWithoutImports() throws Exception {
+    testFormatWithoutImports(/* expectWebLinks= */ false);
+  }
+
+  @Test
+  public void formatWithoutImports_WithWebLinks() throws Exception {
+    try (Registration registration =
+        extensionRegistry.newRegistration().add(new CodeOwnersConfigFileWebLink())) {
+      testFormatWithoutImports(/* expectWebLinks= */ true);
+    }
+  }
+
+  private void testFormatWithoutImports(boolean expectWebLinks) throws Exception {
     CodeOwnerConfig.Key codeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
@@ -91,10 +124,12 @@
             .folderPath("/foo/baz/")
             .addCodeOwnerEmail(admin.email())
             .create();
+    CodeOwnerConfig codeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).get();
 
     CodeOwnerConfigFileInfo codeOwnerConfigFileInfo =
         CodeOwnerConfigFileJson.format(
-            codeOwnerConfigKey,
+            codeOwnerConfig,
             /* resolvedImports= */ ImmutableList.of(),
             /* unresolvedImports= */ ImmutableList.of());
     assertThat(codeOwnerConfigFileInfo.project).isEqualTo(codeOwnerConfigKey.project().get());
@@ -106,11 +141,29 @@
     assertThat(codeOwnerConfigFileInfo.imports).isNull();
     assertThat(codeOwnerConfigFileInfo.unresolvedImports).isNull();
     assertThat(codeOwnerConfigFileInfo.unresolvedErrorMessage).isNull();
+
+    if (expectWebLinks) {
+      assertThat(codeOwnerConfigFileInfo.webLinks).containsExactly(createWebLink(codeOwnerConfig));
+    } else {
+      assertThat(codeOwnerConfigFileInfo.webLinks).isNull();
+    }
   }
 
   @Test
   public void formatWithUnresolvedImports() throws Exception {
-    CodeOwnerConfig.Key codeOwnerConfigKey =
+    testFormatWithUnresolvedImports(/* expectWebLinks= */ false);
+  }
+
+  @Test
+  public void formatWithUnresolvedImports_WithWebLinks() throws Exception {
+    try (Registration registration =
+        extensionRegistry.newRegistration().add(new CodeOwnersConfigFileWebLink())) {
+      testFormatWithUnresolvedImports(/* expectWebLinks= */ true);
+    }
+  }
+
+  private void testFormatWithUnresolvedImports(boolean expectWebLinks) throws Exception {
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -118,6 +171,8 @@
             .folderPath("/foo/bar/")
             .addCodeOwnerEmail(admin.email())
             .create();
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
 
     CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
         CodeOwnerConfig.Key.create(project, "stable", "/foo/baz/");
@@ -127,19 +182,21 @@
 
     CodeOwnerConfigFileInfo codeOwnerConfigFileInfo =
         CodeOwnerConfigFileJson.format(
-            codeOwnerConfigKey,
+            importingCodeOwnerConfig,
             /* resolvedImports= */ ImmutableList.of(),
             /* unresolvedImports= */ ImmutableList.of(
                 CodeOwnerConfigImport.createUnresolvedImport(
-                    codeOwnerConfigKey,
+                    importingCodeOwnerConfig,
                     keyOfImportedCodeOwnerConfig,
                     codeOwnerConfigReference,
                     "error message")));
-    assertThat(codeOwnerConfigFileInfo.project).isEqualTo(codeOwnerConfigKey.project().get());
+    assertThat(codeOwnerConfigFileInfo.project)
+        .isEqualTo(keyOfImportingCodeOwnerConfig.project().get());
     assertThat(codeOwnerConfigFileInfo.branch)
-        .isEqualTo(codeOwnerConfigKey.branchNameKey().branch());
+        .isEqualTo(keyOfImportingCodeOwnerConfig.branchNameKey().branch());
     assertThat(codeOwnerConfigFileInfo.path)
-        .isEqualTo(codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).getFilePath());
+        .isEqualTo(
+            codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).getFilePath());
     assertThat(codeOwnerConfigFileInfo.importMode).isNull();
     assertThat(codeOwnerConfigFileInfo.imports).isNull();
     assertThat(codeOwnerConfigFileInfo.unresolvedErrorMessage).isNull();
@@ -158,11 +215,32 @@
     assertThat(unresolvedImportInfo.imports).isNull();
     assertThat(unresolvedImportInfo.unresolvedImports).isNull();
     assertThat(unresolvedImportInfo.unresolvedErrorMessage).isEqualTo("error message");
+
+    if (expectWebLinks) {
+      assertThat(codeOwnerConfigFileInfo.webLinks)
+          .containsExactly(createWebLink(importingCodeOwnerConfig));
+      assertThat(unresolvedImportInfo.webLinks).isNull();
+    } else {
+      assertThat(codeOwnerConfigFileInfo.webLinks).isNull();
+      assertThat(unresolvedImportInfo.webLinks).isNull();
+    }
   }
 
   @Test
   public void formatWithImports() throws Exception {
-    CodeOwnerConfig.Key codeOwnerConfigKey =
+    testFormatWithImports(/* expectWebLinks= */ false);
+  }
+
+  @Test
+  public void formatWithImports_WithWebLinks() throws Exception {
+    try (Registration registration =
+        extensionRegistry.newRegistration().add(new CodeOwnersConfigFileWebLink())) {
+      testFormatWithImports(/* expectWebLinks= */ true);
+    }
+  }
+
+  private void testFormatWithImports(boolean expectWebLinks) throws Exception {
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -170,25 +248,38 @@
             .folderPath("/foo/bar/")
             .addCodeOwnerEmail(admin.email())
             .create();
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
 
+    createBranch(BranchNameKey.create(project, "stable"));
     CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
-        CodeOwnerConfig.Key.create(project, "stable", "/foo/baz/");
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("stable")
+            .folderPath("/foo/baz/")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
     CodeOwnerConfigReference codeOwnerConfigReference =
         createCodeOwnerConfigReference(
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
 
     CodeOwnerConfigFileInfo codeOwnerConfigFileInfo =
         CodeOwnerConfigFileJson.format(
-            codeOwnerConfigKey,
+            importingCodeOwnerConfig,
             /* resolvedImports= */ ImmutableList.of(
                 CodeOwnerConfigImport.createResolvedImport(
-                    codeOwnerConfigKey, keyOfImportedCodeOwnerConfig, codeOwnerConfigReference)),
+                    importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference)),
             /* unresolvedImports= */ ImmutableList.of());
-    assertThat(codeOwnerConfigFileInfo.project).isEqualTo(codeOwnerConfigKey.project().get());
+    assertThat(codeOwnerConfigFileInfo.project)
+        .isEqualTo(keyOfImportingCodeOwnerConfig.project().get());
     assertThat(codeOwnerConfigFileInfo.branch)
-        .isEqualTo(codeOwnerConfigKey.branchNameKey().branch());
+        .isEqualTo(keyOfImportingCodeOwnerConfig.branchNameKey().branch());
     assertThat(codeOwnerConfigFileInfo.path)
-        .isEqualTo(codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).getFilePath());
+        .isEqualTo(
+            codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).getFilePath());
     assertThat(codeOwnerConfigFileInfo.importMode).isNull();
     assertThat(codeOwnerConfigFileInfo.unresolvedImports).isNull();
     assertThat(codeOwnerConfigFileInfo.unresolvedErrorMessage).isNull();
@@ -206,11 +297,33 @@
     assertThat(resolvedImportInfo.imports).isNull();
     assertThat(resolvedImportInfo.unresolvedImports).isNull();
     assertThat(resolvedImportInfo.unresolvedErrorMessage).isNull();
+
+    if (expectWebLinks) {
+      assertThat(codeOwnerConfigFileInfo.webLinks)
+          .containsExactly(createWebLink(importingCodeOwnerConfig));
+      assertThat(resolvedImportInfo.webLinks)
+          .containsExactly(createWebLink(importedCodeOwnerConfig));
+    } else {
+      assertThat(codeOwnerConfigFileInfo.webLinks).isNull();
+      assertThat(resolvedImportInfo.webLinks).isNull();
+    }
   }
 
   @Test
   public void formatWithNestedImports() throws Exception {
-    CodeOwnerConfig.Key codeOwnerConfigKey =
+    testFormatWithNestedImports(/* expectWebLinks= */ false);
+  }
+
+  @Test
+  public void formatWithNestedImports_WithWebLinks() throws Exception {
+    try (Registration registration =
+        extensionRegistry.newRegistration().add(new CodeOwnersConfigFileWebLink())) {
+      testFormatWithNestedImports(/* expectWebLinks= */ true);
+    }
+  }
+
+  private void testFormatWithNestedImports(boolean expectWebLinks) throws Exception {
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -218,6 +331,8 @@
             .folderPath("/foo/bar/")
             .addCodeOwnerEmail(admin.email())
             .create();
+    CodeOwnerConfig importingCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).get();
 
     CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
         codeOwnerConfigOperations
@@ -227,12 +342,23 @@
             .folderPath("/foo/bar/baz")
             .addCodeOwnerEmail(admin.email())
             .create();
+    CodeOwnerConfig importedCodeOwnerConfig =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).get();
     CodeOwnerConfigReference codeOwnerConfigReference =
         createCodeOwnerConfigReference(
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
 
+    createBranch(BranchNameKey.create(project, "stable"));
     CodeOwnerConfig.Key keyOfNestedImportedCodeOwnerConfig1 =
-        CodeOwnerConfig.Key.create(project, "stable", "/foo/baz1/");
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("stable")
+            .folderPath("/foo/baz1/")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+    CodeOwnerConfig nestedImportedCodeOwnerConfig1 =
+        codeOwnerConfigOperations.codeOwnerConfig(keyOfNestedImportedCodeOwnerConfig1).get();
     CodeOwnerConfigReference nestedCodeOwnerConfigReference1 =
         createCodeOwnerConfigReference(
             CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY,
@@ -246,25 +372,27 @@
 
     CodeOwnerConfigFileInfo codeOwnerConfigFileInfo =
         CodeOwnerConfigFileJson.format(
-            codeOwnerConfigKey,
+            importingCodeOwnerConfig,
             /* resolvedImports= */ ImmutableList.of(
                 CodeOwnerConfigImport.createResolvedImport(
-                    codeOwnerConfigKey, keyOfImportedCodeOwnerConfig, codeOwnerConfigReference),
+                    importingCodeOwnerConfig, importedCodeOwnerConfig, codeOwnerConfigReference),
                 CodeOwnerConfigImport.createResolvedImport(
-                    keyOfImportedCodeOwnerConfig,
-                    keyOfNestedImportedCodeOwnerConfig1,
+                    importedCodeOwnerConfig,
+                    nestedImportedCodeOwnerConfig1,
                     nestedCodeOwnerConfigReference1)),
             /* unresolvedImports= */ ImmutableList.of(
                 CodeOwnerConfigImport.createUnresolvedImport(
-                    keyOfImportedCodeOwnerConfig,
+                    importedCodeOwnerConfig,
                     keyOfNestedImportedCodeOwnerConfig2,
                     nestedCodeOwnerConfigReference2,
                     "error message")));
-    assertThat(codeOwnerConfigFileInfo.project).isEqualTo(codeOwnerConfigKey.project().get());
+    assertThat(codeOwnerConfigFileInfo.project)
+        .isEqualTo(keyOfImportingCodeOwnerConfig.project().get());
     assertThat(codeOwnerConfigFileInfo.branch)
-        .isEqualTo(codeOwnerConfigKey.branchNameKey().branch());
+        .isEqualTo(keyOfImportingCodeOwnerConfig.branchNameKey().branch());
     assertThat(codeOwnerConfigFileInfo.path)
-        .isEqualTo(codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).getFilePath());
+        .isEqualTo(
+            codeOwnerConfigOperations.codeOwnerConfig(keyOfImportingCodeOwnerConfig).getFilePath());
     assertThat(codeOwnerConfigFileInfo.importMode).isNull();
     assertThat(codeOwnerConfigFileInfo.unresolvedImports).isNull();
     assertThat(codeOwnerConfigFileInfo.unresolvedErrorMessage).isNull();
@@ -316,10 +444,37 @@
     assertThat(nestedUnresolvedImportInfo1.imports).isNull();
     assertThat(nestedUnresolvedImportInfo1.unresolvedImports).isNull();
     assertThat(nestedUnresolvedImportInfo1.unresolvedErrorMessage).isEqualTo("error message");
+
+    if (expectWebLinks) {
+      assertThat(codeOwnerConfigFileInfo.webLinks)
+          .containsExactly(createWebLink(importingCodeOwnerConfig));
+      assertThat(resolvedImportInfo.webLinks)
+          .containsExactly(createWebLink(importedCodeOwnerConfig));
+      assertThat(nestedResolvedImportInfo.webLinks)
+          .containsExactly(createWebLink(nestedImportedCodeOwnerConfig1));
+      assertThat(nestedUnresolvedImportInfo1.webLinks).isNull();
+    } else {
+      assertThat(codeOwnerConfigFileInfo.webLinks).isNull();
+      assertThat(resolvedImportInfo.webLinks).isNull();
+      assertThat(nestedResolvedImportInfo.webLinks).isNull();
+      assertThat(nestedUnresolvedImportInfo1.webLinks).isNull();
+    }
   }
 
   @Test
   public void formatWithCyclicImports() throws Exception {
+    testFormatWithCyclicImports(/* expectWebLinks= */ false);
+  }
+
+  @Test
+  public void formatWithCyclicImports_WithWebLinks() throws Exception {
+    try (Registration registration =
+        extensionRegistry.newRegistration().add(new CodeOwnersConfigFileWebLink())) {
+      testFormatWithCyclicImports(/* expectWebLinks= */ true);
+    }
+  }
+
+  private void testFormatWithCyclicImports(boolean expectWebLinks) throws Exception {
     CodeOwnerConfig.Key codeOwnerConfigKey1 =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
@@ -328,6 +483,8 @@
             .folderPath("/foo/bar/")
             .addCodeOwnerEmail(admin.email())
             .create();
+    CodeOwnerConfig codeOwnerConfig1 =
+        codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey1).get();
     CodeOwnerConfigReference codeOwnerConfigReference1 =
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, codeOwnerConfigKey1);
 
@@ -339,17 +496,19 @@
             .folderPath("/foo/bar/baz")
             .addCodeOwnerEmail(admin.email())
             .create();
+    CodeOwnerConfig codeOwnerConfig2 =
+        codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey2).get();
     CodeOwnerConfigReference codeOwnerConfigReference2 =
         createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, codeOwnerConfigKey2);
 
     CodeOwnerConfigFileInfo codeOwnerConfigFileInfo =
         CodeOwnerConfigFileJson.format(
-            codeOwnerConfigKey1,
+            codeOwnerConfig1,
             /* resolvedImports= */ ImmutableList.of(
                 CodeOwnerConfigImport.createResolvedImport(
-                    codeOwnerConfigKey1, codeOwnerConfigKey2, codeOwnerConfigReference1),
+                    codeOwnerConfig1, codeOwnerConfig2, codeOwnerConfigReference1),
                 CodeOwnerConfigImport.createResolvedImport(
-                    codeOwnerConfigKey2, codeOwnerConfigKey1, codeOwnerConfigReference2)),
+                    codeOwnerConfig2, codeOwnerConfig1, codeOwnerConfigReference2)),
             /* unresolvedImports= */ ImmutableList.of());
 
     assertThat(codeOwnerConfigFileInfo.project).isEqualTo(codeOwnerConfigKey1.project().get());
@@ -384,5 +543,40 @@
     assertThat(nestedResolvedImportInfo.imports).isNull();
     assertThat(nestedResolvedImportInfo.unresolvedImports).isNull();
     assertThat(nestedResolvedImportInfo.unresolvedErrorMessage).isNull();
+
+    if (expectWebLinks) {
+      assertThat(codeOwnerConfigFileInfo.webLinks).containsExactly(createWebLink(codeOwnerConfig1));
+      assertThat(resolvedImportInfo.webLinks).containsExactly(createWebLink(codeOwnerConfig2));
+      assertThat(nestedResolvedImportInfo.webLinks)
+          .containsExactly(createWebLink(codeOwnerConfig1));
+    } else {
+      assertThat(codeOwnerConfigFileInfo.webLinks).isNull();
+      assertThat(resolvedImportInfo.webLinks).isNull();
+      assertThat(nestedResolvedImportInfo.webLinks).isNull();
+    }
+  }
+
+  private WebLinkInfo createWebLink(CodeOwnerConfig codeOwnerConfig) {
+    return createWebLink(
+        codeOwnerConfig.key().project().get(),
+        codeOwnerConfig.key().branchNameKey().branch(),
+        codeOwnerConfig.revision().getName(),
+        codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfig.key()).getFilePath());
+  }
+
+  private WebLinkInfo createWebLink(
+      String projectName, String revision, String hash, String fileName) {
+    return new WebLinkInfo(
+        "name",
+        "imageURL",
+        "http://view/" + projectName + "/" + revision + "/" + hash + "/" + fileName);
+  }
+
+  private class CodeOwnersConfigFileWebLink implements FileWebLink {
+    @Override
+    public WebLinkInfo getFileWebLink(
+        String projectName, String revision, String hash, String fileName) {
+      return createWebLink(projectName, revision, hash, fileName);
+    }
   }
 }
diff --git a/resources/Documentation/rest-api.md b/resources/Documentation/rest-api.md
index ace28a0..d694667 100644
--- a/resources/Documentation/rest-api.md
+++ b/resources/Documentation/rest-api.md
@@ -959,14 +959,15 @@
 The `CodeOwnerConfigFileInfo` entity contains information about a code owner
 config file and its imports.
 
-| Field Name |          | Description |
-| ---------- | -------- | ----------- |
-| `project`  || The name of the project from which the code owner config was loaded, or for unresolved imports, from which the code owner config was supposed to be loaded.
-| `branch`   || The name of the branch from which the code owner config was loaded, or for unresolved imports, from which the code owner config was supposed to be loaded.
-| `path`     || The absolute path of the code owner config file.
-| `imports`  | optional | Imported code owner config files as [CodeOwnerConfigFileInfo](#code-owner-config-file-info) entities.
+| Field Name  |          | Description |
+| ----------- | -------- | ----------- |
+| `project`   || The name of the project from which the code owner config was loaded, or for unresolved imports, from which the code owner config was supposed to be loaded.
+| `branch`    || The name of the branch from which the code owner config was loaded, or for unresolved imports, from which the code owner config was supposed to be loaded.
+| `path`      || The absolute path of the code owner config file.
+| `web_links` | optional | Links to the code owner config file in external sites as a list of [WebLinkInfo](../../../Documentation/rest-api-changes.html#web-link-info) entities. Not set if the `CodeOwnerConfigFileInfo` represents an imported code owner config file that couldn't be resolved or if [web links](../../../Documentation/dev-plugins.html#links-to-external-tools) are not configured.
+| `imports`   | optional | Imported code owner config files as [CodeOwnerConfigFileInfo](#code-owner-config-file-info) entities.
 | `unresolved_imports` | optional | Imported code owner config files that couldn't be resolved as [CodeOwnerConfigFileInfo](#code-owner-config-file-info) entities.
-| `unresolved_error_message` | optional | Message explaining why this code owner config couldn't be resolved. Only set if the `CodeOwnerConfigFileInfo` represents an import code owner config file that couldn't be resolved.
+| `unresolved_error_message` | optional | Message explaining why this code owner config couldn't be resolved. Only set if the `CodeOwnerConfigFileInfo` represents an imported code owner config file that couldn't be resolved.
 | `import_mode` | optional | The import mode (`ALL` or `GLOBAL_CODE_OWNER_SETS_ONLY`). Only set if the `CodeOwnerConfigFileInfo` represents an imported code owner config file.
 
 ---