diff --git a/java/com/google/gerrit/plugins/codeowners/acceptance/AbstractCodeOwnersTest.java b/java/com/google/gerrit/plugins/codeowners/acceptance/AbstractCodeOwnersTest.java
index 0e872a9..9830533 100644
--- a/java/com/google/gerrit/plugins/codeowners/acceptance/AbstractCodeOwnersTest.java
+++ b/java/com/google/gerrit/plugins/codeowners/acceptance/AbstractCodeOwnersTest.java
@@ -38,6 +38,9 @@
 import com.google.gerrit.plugins.codeowners.acceptance.testsuite.CodeOwnerConfigOperations;
 import com.google.gerrit.plugins.codeowners.acceptance.testsuite.TestCodeOwnerConfigCreation.Builder;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerBackend;
+import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfig;
+import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfigImportMode;
+import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfigReference;
 import com.google.gerrit.plugins.codeowners.backend.config.BackendConfig;
 import com.google.gerrit.plugins.codeowners.backend.config.CodeOwnersPluginConfiguration;
 import com.google.gerrit.plugins.codeowners.backend.config.StatusConfig;
@@ -341,4 +344,13 @@
     }
     throw new IllegalStateException("unknown code owner backend: " + backend.getClass().getName());
   }
+
+  protected CodeOwnerConfigReference createCodeOwnerConfigReference(
+      CodeOwnerConfigImportMode importMode, CodeOwnerConfig.Key codeOwnerConfigKey) {
+    return CodeOwnerConfigReference.builder(
+            importMode, codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).getFilePath())
+        .setProject(codeOwnerConfigKey.project())
+        .setBranch(codeOwnerConfigKey.branchNameKey().branch())
+        .build();
+  }
 }
diff --git a/java/com/google/gerrit/plugins/codeowners/api/CodeOwnerConfigFileInfo.java b/java/com/google/gerrit/plugins/codeowners/api/CodeOwnerConfigFileInfo.java
new file mode 100644
index 0000000..41fa62b
--- /dev/null
+++ b/java/com/google/gerrit/plugins/codeowners/api/CodeOwnerConfigFileInfo.java
@@ -0,0 +1,65 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.plugins.codeowners.api;
+
+import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfigImportMode;
+import java.util.List;
+
+/**
+ * Representation of a code owner config file in the REST API.
+ *
+ * <p>This class determines the JSON format of code owner config files in the REST API.
+ *
+ * <p>The JSON only contains the location of the code owner config file (project, branch, path) and
+ * information about the imported code owner config files. It's not a representation of the code
+ * owner config file content (the content of a code owner config file is represented by {@link
+ * CodeOwnerConfigInfo}).
+ */
+public class CodeOwnerConfigFileInfo {
+  /**
+   * 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.
+   */
+  public String project;
+
+  /**
+   * 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.
+   */
+  public String branch;
+
+  /** The path of the code owner config file. */
+  public String path;
+
+  /** Imported code owner config files. */
+  public List<CodeOwnerConfigFileInfo> imports;
+
+  /** Imported code owner config files that couldn't be resolved. */
+  public List<CodeOwnerConfigFileInfo> unresolvedImports;
+
+  /**
+   * Message explaining why this code owner config couldn't be resolved.
+   *
+   * <p>Only set for unresolved imports.
+   */
+  public String unresolvedErrorMessage;
+
+  /**
+   * The import mode.
+   *
+   * <p>Only set for imports.
+   */
+  public CodeOwnerConfigImportMode importMode;
+}
diff --git a/java/com/google/gerrit/plugins/codeowners/api/CodeOwnersInfo.java b/java/com/google/gerrit/plugins/codeowners/api/CodeOwnersInfo.java
index d699029..763dff2 100644
--- a/java/com/google/gerrit/plugins/codeowners/api/CodeOwnersInfo.java
+++ b/java/com/google/gerrit/plugins/codeowners/api/CodeOwnersInfo.java
@@ -34,6 +34,9 @@
    */
   public Boolean ownedByAllUsers;
 
+  /** The code owner config files that have been inspected to gather the code owners. */
+  public List<CodeOwnerConfigFileInfo> codeOwnerConfigs;
+
   /**
    * Debug logs that may help to understand why a user is or isn't suggested as a code owner.
    *
diff --git a/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImport.java b/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImport.java
new file mode 100644
index 0000000..a75c15b
--- /dev/null
+++ b/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImport.java
@@ -0,0 +1,86 @@
+// Copyright (C) 2020 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.plugins.codeowners.backend;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import java.util.Optional;
+
+/**
+ * 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>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.
+ */
+@AutoValue
+public abstract class CodeOwnerConfigImport {
+  /** Key of the importing code owner config. */
+  public abstract CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig();
+
+  /** Key of the imported code owner config. */
+  public abstract CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig();
+
+  /** The code owner config reference that references the imported code owner config. */
+  public abstract CodeOwnerConfigReference codeOwnerConfigReference();
+
+  /**
+   * If the import couldn't be resolved, a message explaining why the code owner config reference
+   * couldn't be resolved.
+   */
+  public abstract Optional<String> errorMessage();
+
+  @Override
+  public final String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("keyOfImportingCodeOwnerConfig", keyOfImportingCodeOwnerConfig())
+        .add("keyOfImportedCodeOwnerConfig", keyOfImportedCodeOwnerConfig())
+        .add("codeOwnerConfigReference", codeOwnerConfigReference())
+        .add("errorMessage", errorMessage())
+        .toString();
+  }
+
+  /** Creates a {@link CodeOwnerConfigImport} instance for an unresolved import. */
+  @VisibleForTesting
+  public static CodeOwnerConfigImport createUnresolvedImport(
+      CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig,
+      CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig,
+      CodeOwnerConfigReference codeOwnerConfigReference,
+      String errorMessage) {
+    return new AutoValue_CodeOwnerConfigImport(
+        keyOfImportingCodeOwnerConfig,
+        keyOfImportedCodeOwnerConfig,
+        codeOwnerConfigReference,
+        Optional.of(errorMessage));
+  }
+
+  /** Creates a {@link CodeOwnerConfigImport} instance for a resolved import. */
+  @VisibleForTesting
+  public static CodeOwnerConfigImport createResolvedImport(
+      CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig,
+      CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig,
+      CodeOwnerConfigReference codeOwnerConfigReference) {
+    return new AutoValue_CodeOwnerConfigImport(
+        keyOfImportingCodeOwnerConfig,
+        keyOfImportedCodeOwnerConfig,
+        codeOwnerConfigReference,
+        Optional.empty());
+  }
+}
diff --git a/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolver.java b/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolver.java
index 07894ce..7db6b68 100644
--- a/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolver.java
+++ b/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolver.java
@@ -50,7 +50,6 @@
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
@@ -234,6 +233,7 @@
       return resolve(
           pathCodeOwnersResult.get().getPathCodeOwners(),
           pathCodeOwnersResult.get().getAnnotations(),
+          pathCodeOwnersResult.get().resolvedImports(),
           pathCodeOwnersResult.get().unresolvedImports(),
           pathCodeOwnersResult.messages());
     }
@@ -260,6 +260,7 @@
     return resolve(
         codeOwnerReferences,
         /* annotationsByCodeOwnerReference= */ ImmutableMultimap.of(),
+        /* resolvedImports= */ ImmutableList.of(),
         /* unresolvedImports= */ ImmutableList.of(),
         /* pathCodeOwnersMessages= */ ImmutableList.of());
   }
@@ -279,9 +280,11 @@
   private CodeOwnerResolverResult resolve(
       Set<CodeOwnerReference> codeOwnerReferences,
       ImmutableMultimap<CodeOwnerReference, CodeOwnerAnnotation> annotationsByCodeOwnerReference,
-      List<UnresolvedImport> unresolvedImports,
+      ImmutableList<CodeOwnerConfigImport> resolvedImports,
+      ImmutableList<CodeOwnerConfigImport> unresolvedImports,
       ImmutableList<String> pathCodeOwnersMessages) {
     requireNonNull(codeOwnerReferences, "codeOwnerReferences");
+    requireNonNull(resolvedImports, "resolvedImports");
     requireNonNull(unresolvedImports, "unresolvedImports");
     requireNonNull(pathCodeOwnersMessages, "pathCodeOwnersMessages");
 
@@ -313,7 +316,8 @@
               annotationsByCodeOwner.build(),
               ownedByAllUsers.get(),
               hasUnresolvedCodeOwners.get(),
-              !unresolvedImports.isEmpty(),
+              resolvedImports,
+              unresolvedImports,
               messageBuilder.build());
       logger.atFine().log("resolve result = %s", codeOwnerResolverResult);
       return codeOwnerResolverResult;
diff --git a/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResult.java b/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResult.java
index 7dd9e96..4db3a4c 100644
--- a/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResult.java
+++ b/java/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResult.java
@@ -52,8 +52,16 @@
   /** Whether there are code owner references which couldn't be resolved. */
   public abstract boolean hasUnresolvedCodeOwners();
 
+  /** Imports which were successfully resolved. */
+  public abstract ImmutableList<CodeOwnerConfigImport> resolvedImports();
+
+  /** Imports which couldn't be resolved. */
+  public abstract ImmutableList<CodeOwnerConfigImport> unresolvedImports();
+
   /** Whether there are imports which couldn't be resolved. */
-  public abstract boolean hasUnresolvedImports();
+  public boolean hasUnresolvedImports() {
+    return !unresolvedImports().isEmpty();
+  }
 
   /** Gets messages that were collected while resolving the code owners. */
   public abstract ImmutableList<String> messages();
@@ -76,7 +84,8 @@
         .add("annotations", annotations())
         .add("ownedByAllUsers", ownedByAllUsers())
         .add("hasUnresolvedCodeOwners", hasUnresolvedCodeOwners())
-        .add("hasUnresolvedImports", hasUnresolvedImports())
+        .add("resolvedImports", resolvedImports())
+        .add("unresolvedImports", unresolvedImports())
         .add("messages", messages())
         .toString();
   }
@@ -87,25 +96,16 @@
       ImmutableMultimap<CodeOwner, CodeOwnerAnnotation> annotations,
       boolean ownedByAllUsers,
       boolean hasUnresolvedCodeOwners,
-      boolean hasUnresolvedImports,
+      ImmutableList<CodeOwnerConfigImport> resolvedImports,
+      ImmutableList<CodeOwnerConfigImport> unresolvedImports,
       List<String> messages) {
     return new AutoValue_CodeOwnerResolverResult(
         codeOwners,
         annotations,
         ownedByAllUsers,
         hasUnresolvedCodeOwners,
-        hasUnresolvedImports,
+        resolvedImports,
+        unresolvedImports,
         ImmutableList.copyOf(messages));
   }
-
-  /** Creates a empty {@link CodeOwnerResolverResult} instance. */
-  public static CodeOwnerResolverResult createEmpty() {
-    return new AutoValue_CodeOwnerResolverResult(
-        /* codeOwners= */ ImmutableSet.of(),
-        /* annotations= */ ImmutableMultimap.of(),
-        /* ownedByAllUsers= */ false,
-        /* hasUnresolvedCodeOwners= */ false,
-        /* hasUnresolvedImports= */ false,
-        /* messages= */ ImmutableList.of());
-  }
 }
diff --git a/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java b/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java
index a61c913..5e7a11f 100644
--- a/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java
+++ b/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwners.java
@@ -252,17 +252,18 @@
       }
 
       // Resolve global imports.
-      ImmutableList.Builder<UnresolvedImport> unresolvedImports = ImmutableList.builder();
-      ImmutableSet<CodeOwnerConfigImport> globalImports = getGlobalImports(0, codeOwnerConfig);
-      OptionalResultWithMessages<List<UnresolvedImport>> unresolvedGlobalImports;
+      ImmutableList.Builder<CodeOwnerConfigImport> resolvedImports = ImmutableList.builder();
+      ImmutableList.Builder<CodeOwnerConfigImport> unresolvedImports = ImmutableList.builder();
+      ImmutableSet<CodeOwnerImport> globalImports = getGlobalImports(0, codeOwnerConfig);
+      OptionalResultWithMessages<CodeOwnerConfigImports> globalImportedCodeOwnerConfigs;
       if (!globalCodeOwnersIgnored) {
-        unresolvedGlobalImports =
+        globalImportedCodeOwnerConfigs =
             resolveImports(codeOwnerConfig.key(), globalImports, resolvedCodeOwnerConfigBuilder);
       } else {
         // skip global import with mode GLOBAL_CODE_OWNER_SETS_ONLY,
         // since we already know that global code owners will be ignored, we do not need to resolve
         // these imports
-        unresolvedGlobalImports =
+        globalImportedCodeOwnerConfigs =
             resolveImports(
                 codeOwnerConfig.key(),
                 globalImports.stream()
@@ -273,8 +274,9 @@
                     .collect(toImmutableSet()),
                 resolvedCodeOwnerConfigBuilder);
       }
-      messages.addAll(unresolvedGlobalImports.messages());
-      unresolvedImports.addAll(unresolvedGlobalImports.get());
+      messages.addAll(globalImportedCodeOwnerConfigs.messages());
+      resolvedImports.addAll(globalImportedCodeOwnerConfigs.get().resolved());
+      unresolvedImports.addAll(globalImportedCodeOwnerConfigs.get().unresolved());
 
       // Remove all global code owner sets if any per-file code owner set has the
       // ignoreGlobalAndParentCodeOwners flag set to true (as in this case they are ignored and
@@ -317,18 +319,22 @@
       }
 
       // Resolve per-file imports.
-      ImmutableSet<CodeOwnerConfigImport> perFileImports =
+      ImmutableSet<CodeOwnerImport> perFileImports =
           getPerFileImports(
               0, codeOwnerConfig.key(), resolvedCodeOwnerConfigBuilder.codeOwnerSets());
-      OptionalResultWithMessages<List<UnresolvedImport>> unresolvedPerFileImports =
+      OptionalResultWithMessages<CodeOwnerConfigImports> perFileImportedCodeOwnerConfigs =
           resolveImports(codeOwnerConfig.key(), perFileImports, resolvedCodeOwnerConfigBuilder);
-      messages.addAll(unresolvedPerFileImports.messages());
-      unresolvedImports.addAll(unresolvedPerFileImports.get());
+      messages.addAll(perFileImportedCodeOwnerConfigs.messages());
+      resolvedImports.addAll(perFileImportedCodeOwnerConfigs.get().resolved());
+      unresolvedImports.addAll(perFileImportedCodeOwnerConfigs.get().unresolved());
 
       this.pathCodeOwnersResult =
           OptionalResultWithMessages.create(
               PathCodeOwnersResult.create(
-                  path, resolvedCodeOwnerConfigBuilder.build(), unresolvedImports.build()),
+                  path,
+                  resolvedCodeOwnerConfigBuilder.build(),
+                  resolvedImports.build(),
+                  unresolvedImports.build()),
               messages);
       logger.atFine().log("path code owners result = %s", pathCodeOwnersResult);
       return this.pathCodeOwnersResult;
@@ -343,11 +349,12 @@
    * @param resolvedCodeOwnerConfigBuilder the builder for the resolved code owner config
    * @return list of unresolved imports, empty list if all imports were successfully resolved
    */
-  private OptionalResultWithMessages<List<UnresolvedImport>> resolveImports(
+  private OptionalResultWithMessages<CodeOwnerConfigImports> resolveImports(
       CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig,
-      Set<CodeOwnerConfigImport> codeOwnerConfigImports,
+      Set<CodeOwnerImport> codeOwnerConfigImports,
       CodeOwnerConfig.Builder resolvedCodeOwnerConfigBuilder) {
-    ImmutableList.Builder<UnresolvedImport> unresolvedImports = ImmutableList.builder();
+    ImmutableList.Builder<CodeOwnerConfigImport> resolvedImports = ImmutableList.builder();
+    ImmutableList.Builder<CodeOwnerConfigImport> unresolvedImports = ImmutableList.builder();
     StringBuilder messageBuilder = new StringBuilder();
     try (Timer0.Context ctx = codeOwnerMetrics.resolveCodeOwnerConfigImports.start()) {
       logger.atFine().log("resolve imports of codeOwnerConfig %s", keyOfImportingCodeOwnerConfig);
@@ -361,7 +368,7 @@
       Map<BranchNameKey, ObjectId> revisionMap = new HashMap<>();
       revisionMap.put(codeOwnerConfig.key().branchNameKey(), codeOwnerConfig.revision());
 
-      Queue<CodeOwnerConfigImport> codeOwnerConfigsToImport = new ArrayDeque<>();
+      Queue<CodeOwnerImport> codeOwnerConfigsToImport = new ArrayDeque<>();
       codeOwnerConfigsToImport.addAll(codeOwnerConfigImports);
       if (!codeOwnerConfigsToImport.isEmpty()) {
         messageBuilder.append(
@@ -370,7 +377,7 @@
                 keyOfImportingCodeOwnerConfig.format(codeOwners)));
       }
       while (!codeOwnerConfigsToImport.isEmpty()) {
-        CodeOwnerConfigImport codeOwnerConfigImport = codeOwnerConfigsToImport.poll();
+        CodeOwnerImport codeOwnerConfigImport = codeOwnerConfigsToImport.poll();
         messageBuilder.append(codeOwnerConfigImport.format());
 
         CodeOwnerConfigReference codeOwnerConfigReference =
@@ -387,7 +394,7 @@
               projectCache.get(keyOfImportedCodeOwnerConfig.project());
           if (!projectState.isPresent()) {
             unresolvedImports.add(
-                UnresolvedImport.create(
+                CodeOwnerConfigImport.createUnresolvedImport(
                     codeOwnerConfigImport.importingCodeOwnerConfig(),
                     keyOfImportedCodeOwnerConfig,
                     codeOwnerConfigReference,
@@ -399,7 +406,7 @@
           }
           if (!projectState.get().statePermitsRead()) {
             unresolvedImports.add(
-                UnresolvedImport.create(
+                CodeOwnerConfigImport.createUnresolvedImport(
                     codeOwnerConfigImport.importingCodeOwnerConfig(),
                     keyOfImportedCodeOwnerConfig,
                     codeOwnerConfigReference,
@@ -425,7 +432,7 @@
 
           if (!mayBeImportedCodeOwnerConfig.isPresent()) {
             unresolvedImports.add(
-                UnresolvedImport.create(
+                CodeOwnerConfigImport.createUnresolvedImport(
                     codeOwnerConfigImport.importingCodeOwnerConfig(),
                     keyOfImportedCodeOwnerConfig,
                     codeOwnerConfigReference,
@@ -439,6 +446,13 @@
           }
 
           CodeOwnerConfig importedCodeOwnerConfig = mayBeImportedCodeOwnerConfig.get();
+
+          resolvedImports.add(
+              CodeOwnerConfigImport.createResolvedImport(
+                  codeOwnerConfigImport.importingCodeOwnerConfig(),
+                  keyOfImportedCodeOwnerConfig,
+                  codeOwnerConfigReference));
+
           CodeOwnerConfigImportMode importMode = codeOwnerConfigReference.importMode();
           logger.atFine().log("import mode = %s", importMode.name());
 
@@ -475,7 +489,7 @@
           if (importMode.resolveImportsOfImport()
               && seenCodeOwnerConfigs.add(keyOfImportedCodeOwnerConfig)) {
             logger.atFine().log("resolve imports of imported code owner config");
-            Set<CodeOwnerConfigImport> transitiveImports = new HashSet<>();
+            Set<CodeOwnerImport> transitiveImports = new HashSet<>();
             transitiveImports.addAll(
                 getGlobalImports(codeOwnerConfigImport.importLevel() + 1, importedCodeOwnerConfig));
             transitiveImports.addAll(
@@ -495,7 +509,7 @@
                   transitiveImports.stream()
                       .map(
                           codeOwnerCfgImport ->
-                              CodeOwnerConfigImport.create(
+                              CodeOwnerImport.create(
                                   codeOwnerCfgImport.importLevel(),
                                   codeOwnerCfgImport.importingCodeOwnerConfig(),
                                   CodeOwnerConfigReference.copyWithNewImportMode(
@@ -516,31 +530,31 @@
       message = message.substring(0, message.length() - 1);
     }
     return OptionalResultWithMessages.create(
-        unresolvedImports.build(),
+        CodeOwnerConfigImports.create(resolvedImports.build(), unresolvedImports.build()),
         !message.isEmpty() ? ImmutableList.of(message) : ImmutableList.of());
   }
 
-  private ImmutableSet<CodeOwnerConfigImport> getGlobalImports(
+  private ImmutableSet<CodeOwnerImport> getGlobalImports(
       int importLevel, CodeOwnerConfig codeOwnerConfig) {
     return codeOwnerConfig.imports().stream()
         .map(
             codeOwnerConfigReference ->
-                CodeOwnerConfigImport.create(
+                CodeOwnerImport.create(
                     importLevel, codeOwnerConfig.key(), codeOwnerConfigReference))
         .collect(toImmutableSet());
   }
 
-  private ImmutableSet<CodeOwnerConfigImport> getPerFileImports(
+  private ImmutableSet<CodeOwnerImport> getPerFileImports(
       int importLevel,
       CodeOwnerConfig.Key importingCodeOwnerConfig,
       Set<CodeOwnerSet> codeOwnerSets) {
-    ImmutableSet.Builder<CodeOwnerConfigImport> codeOwnerConfigImports = ImmutableSet.builder();
+    ImmutableSet.Builder<CodeOwnerImport> codeOwnerConfigImports = ImmutableSet.builder();
     for (CodeOwnerSet codeOwnerSet : codeOwnerSets) {
       codeOwnerSet.imports().stream()
           .forEach(
               codeOwnerConfigReference ->
                   codeOwnerConfigImports.add(
-                      CodeOwnerConfigImport.create(
+                      CodeOwnerImport.create(
                           importLevel,
                           importingCodeOwnerConfig,
                           codeOwnerConfigReference,
@@ -623,7 +637,7 @@
   }
 
   @AutoValue
-  abstract static class CodeOwnerConfigImport {
+  abstract static class CodeOwnerImport {
     /**
      * The import level.
      *
@@ -683,7 +697,7 @@
       return levels > 0 ? String.format("%" + (levels * 2) + "s", "") : "";
     }
 
-    public static CodeOwnerConfigImport create(
+    public static CodeOwnerImport create(
         int importLevel,
         CodeOwnerConfig.Key importingCodeOwnerConfig,
         CodeOwnerConfigReference codeOwnerConfigReference) {
@@ -691,7 +705,7 @@
           importLevel, importingCodeOwnerConfig, codeOwnerConfigReference, Optional.empty());
     }
 
-    public static CodeOwnerConfigImport create(
+    public static CodeOwnerImport create(
         int importLevel,
         CodeOwnerConfig.Key importingCodeOwnerConfig,
         CodeOwnerConfigReference codeOwnerConfigReference,
@@ -703,13 +717,28 @@
           Optional.of(codeOwnerSet));
     }
 
-    public static CodeOwnerConfigImport create(
+    public static CodeOwnerImport create(
         int importLevel,
         CodeOwnerConfig.Key importingCodeOwnerConfig,
         CodeOwnerConfigReference codeOwnerConfigReference,
         Optional<CodeOwnerSet> codeOwnerSet) {
-      return new AutoValue_PathCodeOwners_CodeOwnerConfigImport(
+      return new AutoValue_PathCodeOwners_CodeOwnerImport(
           importLevel, importingCodeOwnerConfig, codeOwnerConfigReference, codeOwnerSet);
     }
   }
+
+  @AutoValue
+  abstract static class CodeOwnerConfigImports {
+    /** Imported code owner configs the could be resolved. */
+    abstract ImmutableList<CodeOwnerConfigImport> resolved();
+
+    /** Imported code owner configs the could not be resolved. */
+    abstract ImmutableList<CodeOwnerConfigImport> unresolved();
+
+    static CodeOwnerConfigImports create(
+        ImmutableList<CodeOwnerConfigImport> resolved,
+        ImmutableList<CodeOwnerConfigImport> unresolved) {
+      return new AutoValue_PathCodeOwners_CodeOwnerConfigImports(resolved, unresolved);
+    }
+  }
 }
diff --git a/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResult.java b/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResult.java
index 93a36be..5b262bf 100644
--- a/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResult.java
+++ b/java/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResult.java
@@ -36,8 +36,11 @@
   /** Gets the resolved code owner config. */
   abstract CodeOwnerConfig codeOwnerConfig();
 
+  /** Gets a list of resolved imports. */
+  public abstract ImmutableList<CodeOwnerConfigImport> resolvedImports();
+
   /** Gets a list of unresolved imports. */
-  public abstract ImmutableList<UnresolvedImport> unresolvedImports();
+  public abstract ImmutableList<CodeOwnerConfigImport> unresolvedImports();
 
   /** Whether there are unresolved imports. */
   public boolean hasUnresolvedImports() {
@@ -104,14 +107,21 @@
     return MoreObjects.toStringHelper(this)
         .add("path", path())
         .add("codeOwnerConfig", codeOwnerConfig())
+        .add("resolvedImports", resolvedImports())
         .add("unresolvedImports", unresolvedImports())
         .toString();
   }
 
   /** Creates a {@link PathCodeOwnersResult} instance. */
   public static PathCodeOwnersResult create(
-      Path path, CodeOwnerConfig codeOwnerConfig, List<UnresolvedImport> unresolvedImports) {
+      Path path,
+      CodeOwnerConfig codeOwnerConfig,
+      List<CodeOwnerConfigImport> resolvedImports,
+      List<CodeOwnerConfigImport> unresolvedImports) {
     return new AutoValue_PathCodeOwnersResult(
-        path, codeOwnerConfig, ImmutableList.copyOf(unresolvedImports));
+        path,
+        codeOwnerConfig,
+        ImmutableList.copyOf(resolvedImports),
+        ImmutableList.copyOf(unresolvedImports));
   }
 }
diff --git a/java/com/google/gerrit/plugins/codeowners/backend/UnresolvedImport.java b/java/com/google/gerrit/plugins/codeowners/backend/UnresolvedImport.java
deleted file mode 100644
index bea1e08..0000000
--- a/java/com/google/gerrit/plugins/codeowners/backend/UnresolvedImport.java
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (C) 2020 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package com.google.gerrit.plugins.codeowners.backend;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.base.MoreObjects;
-
-/** Information about an unresolved import. */
-@AutoValue
-public abstract class UnresolvedImport {
-  /** Key of the importing code owner config. */
-  public abstract CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig();
-
-  /** Key of the imported code owner config. */
-  public abstract CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig();
-
-  /** The code owner config reference that was attempted to be resolved. */
-  public abstract CodeOwnerConfigReference codeOwnerConfigReference();
-
-  /** Message explaining why the code owner config reference couldn't be resolved. */
-  public abstract String message();
-
-  @Override
-  public final String toString() {
-    return MoreObjects.toStringHelper(this)
-        .add("keyOfImportingCodeOwnerConfig", keyOfImportingCodeOwnerConfig())
-        .add("keyOfImportedCodeOwnerConfig", keyOfImportedCodeOwnerConfig())
-        .add("codeOwnerConfigReference", codeOwnerConfigReference())
-        .add("message", message())
-        .toString();
-  }
-
-  /** Creates a {@link UnresolvedImport} instance. */
-  static UnresolvedImport create(
-      CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig,
-      CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig,
-      CodeOwnerConfigReference codeOwnerConfigReference,
-      String message) {
-    return new AutoValue_UnresolvedImport(
-        keyOfImportingCodeOwnerConfig,
-        keyOfImportedCodeOwnerConfig,
-        codeOwnerConfigReference,
-        message);
-  }
-}
diff --git a/java/com/google/gerrit/plugins/codeowners/backend/UnresolvedImportFormatter.java b/java/com/google/gerrit/plugins/codeowners/backend/UnresolvedImportFormatter.java
index 52958d9..7946468 100644
--- a/java/com/google/gerrit/plugins/codeowners/backend/UnresolvedImportFormatter.java
+++ b/java/com/google/gerrit/plugins/codeowners/backend/UnresolvedImportFormatter.java
@@ -20,7 +20,7 @@
 import com.google.inject.Inject;
 import java.nio.file.Path;
 
-/** Class to format an {@link UnresolvedImport} as a user-readable string. */
+/** Class to format an {@link CodeOwnerConfigImport} as a user-readable string. */
 public class UnresolvedImportFormatter {
   private final CodeOwnersPluginConfiguration codeOwnersPluginConfiguration;
   private final ProjectCache projectCache;
@@ -37,7 +37,7 @@
   }
 
   /** Returns a user-readable string representation of the given unresolved import. */
-  public String format(UnresolvedImport unresolvedImport) {
+  public String format(CodeOwnerConfigImport unresolvedImport) {
     return String.format(
         "The import of %s:%s:%s in %s:%s:%s cannot be resolved: %s",
         unresolvedImport.keyOfImportedCodeOwnerConfig().project(),
@@ -46,10 +46,16 @@
         unresolvedImport.keyOfImportingCodeOwnerConfig().project(),
         unresolvedImport.keyOfImportingCodeOwnerConfig().shortBranchName(),
         getFilePath(unresolvedImport.keyOfImportingCodeOwnerConfig()),
-        unresolvedImport.message());
+        unresolvedImport
+            .errorMessage()
+            .orElseThrow(
+                () ->
+                    new IllegalStateException(
+                        String.format(
+                            "unresolved import %s must have an error message", unresolvedImport))));
   }
 
-  private Path getFilePath(CodeOwnerConfig.Key codeOwnerConfigKey) {
+  public Path getFilePath(CodeOwnerConfig.Key codeOwnerConfigKey) {
     return getBackend(codeOwnerConfigKey).getFilePath(codeOwnerConfigKey);
   }
 
@@ -60,6 +66,10 @@
    * returned.
    */
   private CodeOwnerBackend getBackend(CodeOwnerConfig.Key codeOwnerConfigKey) {
+    // For unresolved imports the project may not exist. Trying to get the project config for
+    // non-existing projects fails, hence check whether the project exists before trying to access
+    // the project config and fall back to the default code owner backend if the project doesn't
+    // exist.
     if (projectCache.get(codeOwnerConfigKey.project()).isPresent()) {
       return codeOwnersPluginConfiguration
           .getProjectConfig(codeOwnerConfigKey.project())
diff --git a/java/com/google/gerrit/plugins/codeowners/restapi/AbstractGetCodeOwnersForPath.java b/java/com/google/gerrit/plugins/codeowners/restapi/AbstractGetCodeOwnersForPath.java
index 677e67c..b918d5d 100644
--- a/java/com/google/gerrit/plugins/codeowners/restapi/AbstractGetCodeOwnersForPath.java
+++ b/java/com/google/gerrit/plugins/codeowners/restapi/AbstractGetCodeOwnersForPath.java
@@ -38,6 +38,7 @@
 import com.google.gerrit.extensions.restapi.BadRequestException;
 import com.google.gerrit.extensions.restapi.Response;
 import com.google.gerrit.extensions.restapi.RestReadView;
+import com.google.gerrit.plugins.codeowners.api.CodeOwnerConfigFileInfo;
 import com.google.gerrit.plugins.codeowners.api.CodeOwnersInfo;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwner;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerAnnotation;
@@ -92,6 +93,7 @@
   private final CodeOwnerConfigHierarchy codeOwnerConfigHierarchy;
   private final Provider<CodeOwnerResolver> codeOwnerResolver;
   private final CodeOwnerJson.Factory codeOwnerJsonFactory;
+  private final CodeOwnerConfigFileJson codeOwnerConfigFileJson;
   private final EnumSet<ListAccountsOption> options;
   private final Set<String> hexOptions;
 
@@ -167,7 +169,8 @@
       CodeOwnersPluginConfiguration codeOwnersPluginConfiguration,
       CodeOwnerConfigHierarchy codeOwnerConfigHierarchy,
       Provider<CodeOwnerResolver> codeOwnerResolver,
-      CodeOwnerJson.Factory codeOwnerJsonFactory) {
+      CodeOwnerJson.Factory codeOwnerJsonFactory,
+      CodeOwnerConfigFileJson codeOwnerConfigFileJson) {
     this.accountVisibility = accountVisibility;
     this.accounts = accounts;
     this.accountControlFactory = accountControlFactory;
@@ -178,6 +181,7 @@
     this.codeOwnerConfigHierarchy = codeOwnerConfigHierarchy;
     this.codeOwnerResolver = codeOwnerResolver;
     this.codeOwnerJsonFactory = codeOwnerJsonFactory;
+    this.codeOwnerConfigFileJson = codeOwnerConfigFileJson;
     this.options = EnumSet.noneOf(ListAccountsOption.class);
     this.hexOptions = new HashSet<>();
   }
@@ -213,6 +217,8 @@
     ListMultimap<CodeOwner, CodeOwnerAnnotation> annotations = LinkedListMultimap.create();
     AtomicBoolean ownedByAllUsers = new AtomicBoolean(false);
     ImmutableList.Builder<String> debugLogsBuilder = ImmutableList.builder();
+    ImmutableList.Builder<CodeOwnerConfigFileInfo> codeOwnerConfigFileInfosBuilder =
+        ImmutableList.builder();
     codeOwnerConfigHierarchy.visit(
         rsrc.getBranch(),
         rsrc.getRevision(),
@@ -221,6 +227,12 @@
           CodeOwnerResolverResult pathCodeOwners =
               codeOwnerResolver.get().resolvePathCodeOwners(codeOwnerConfig, rsrc.getPath());
 
+          codeOwnerConfigFileInfosBuilder.add(
+              codeOwnerConfigFileJson.format(
+                  codeOwnerConfig.key(),
+                  pathCodeOwners.resolvedImports(),
+                  pathCodeOwners.unresolvedImports()));
+
           debugLogsBuilder.addAll(pathCodeOwners.messages());
           codeOwners.addAll(pathCodeOwners.codeOwners());
           annotations.putAll(pathCodeOwners.annotations());
@@ -325,7 +337,7 @@
     codeOwnersInfo.codeOwners =
         codeOwnerJsonFactory.create(getFillOptions()).format(sortedAndLimitedCodeOwners);
     codeOwnersInfo.ownedByAllUsers = ownedByAllUsers.get() ? true : null;
-
+    codeOwnersInfo.codeOwnerConfigs = codeOwnerConfigFileInfosBuilder.build();
     ImmutableList<String> debugLogs = debugLogsBuilder.build();
     codeOwnersInfo.debugLogs = debug ? debugLogs : null;
     logger.atFine().log("debug logs: %s", debugLogs);
diff --git a/java/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJson.java b/java/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJson.java
new file mode 100644
index 0000000..fe17a3f
--- /dev/null
+++ b/java/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJson.java
@@ -0,0 +1,119 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.plugins.codeowners.restapi;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.collect.ImmutableList;
+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.inject.Inject;
+import java.util.List;
+
+/** Collection of routines to populate {@link CodeOwnerConfigFileInfo}. */
+public class CodeOwnerConfigFileJson {
+  private final UnresolvedImportFormatter unresolvedImportFormatter;
+
+  @Inject
+  CodeOwnerConfigFileJson(UnresolvedImportFormatter unresolvedImportFormatter) {
+    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 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
+   *     couldn't be resolved
+   * @return the provided {@link com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfig.Key}
+   *     as {@link CodeOwnerConfigFileInfo}
+   */
+  public CodeOwnerConfigFileInfo format(
+      CodeOwnerConfig.Key codeOwnerConfigKey,
+      List<CodeOwnerConfigImport> resolvedImports,
+      List<CodeOwnerConfigImport> unresolvedImports) {
+    requireNonNull(codeOwnerConfigKey, "codeOwnerConfigKey");
+    requireNonNull(resolvedImports, "resolvedImports");
+    requireNonNull(unresolvedImports, "unresolvedImports");
+
+    CodeOwnerConfigFileInfo info = new CodeOwnerConfigFileInfo();
+
+    info.project = codeOwnerConfigKey.project().get();
+    info.branch = codeOwnerConfigKey.branchNameKey().branch();
+    info.path = unresolvedImportFormatter.getFilePath(codeOwnerConfigKey).toString();
+
+    ImmutableList<CodeOwnerConfigFileInfo> unresolvedImportInfos =
+        unresolvedImports.stream()
+            .filter(
+                unresolvedImport ->
+                    unresolvedImport.keyOfImportingCodeOwnerConfig().equals(codeOwnerConfigKey))
+            .map(
+                unresolvedImport -> {
+                  CodeOwnerConfigFileInfo unresolvedCodeOwnerConfigFileInfo =
+                      format(
+                          unresolvedImport.keyOfImportedCodeOwnerConfig(),
+                          /* resolvedImports= */ ImmutableList.of(),
+                          /* unresolvedImports= */ ImmutableList.of());
+                  unresolvedCodeOwnerConfigFileInfo.importMode =
+                      unresolvedImport.codeOwnerConfigReference().importMode();
+                  unresolvedCodeOwnerConfigFileInfo.unresolvedErrorMessage =
+                      unresolvedImport
+                          .errorMessage()
+                          .orElseThrow(
+                              () ->
+                                  new IllegalStateException(
+                                      String.format(
+                                          "unresolved import %s must have an error message",
+                                          unresolvedImport)));
+                  return unresolvedCodeOwnerConfigFileInfo;
+                })
+            .collect(toImmutableList());
+    info.unresolvedImports = !unresolvedImportInfos.isEmpty() ? unresolvedImportInfos : null;
+
+    ImmutableList<CodeOwnerConfigFileInfo> importInfos =
+        resolvedImports.stream()
+            .filter(
+                resolvedImport ->
+                    resolvedImport.keyOfImportingCodeOwnerConfig().equals(codeOwnerConfigKey))
+            .map(
+                resolvedImport -> {
+                  CodeOwnerConfigFileInfo resolvedCodeOwnerConfigFileInfo =
+                      format(
+                          resolvedImport.keyOfImportedCodeOwnerConfig(),
+                          removeImportEntriesFor(resolvedImports, codeOwnerConfigKey),
+                          removeImportEntriesFor(unresolvedImports, codeOwnerConfigKey));
+                  resolvedCodeOwnerConfigFileInfo.importMode =
+                      resolvedImport.codeOwnerConfigReference().importMode();
+                  return resolvedCodeOwnerConfigFileInfo;
+                })
+            .collect(toImmutableList());
+    info.imports = !importInfos.isEmpty() ? importInfos : null;
+
+    return info;
+  }
+
+  private ImmutableList<CodeOwnerConfigImport> removeImportEntriesFor(
+      List<CodeOwnerConfigImport> imports, CodeOwnerConfig.Key codeOwnerConfigKey) {
+    return imports.stream()
+        .filter(i -> !i.keyOfImportingCodeOwnerConfig().equals(codeOwnerConfigKey))
+        .collect(toImmutableList());
+  }
+}
diff --git a/java/com/google/gerrit/plugins/codeowners/restapi/GetCodeOwnersForPathInBranch.java b/java/com/google/gerrit/plugins/codeowners/restapi/GetCodeOwnersForPathInBranch.java
index e0a9145..85410e9 100644
--- a/java/com/google/gerrit/plugins/codeowners/restapi/GetCodeOwnersForPathInBranch.java
+++ b/java/com/google/gerrit/plugins/codeowners/restapi/GetCodeOwnersForPathInBranch.java
@@ -82,6 +82,7 @@
       CodeOwnerConfigHierarchy codeOwnerConfigHierarchy,
       Provider<CodeOwnerResolver> codeOwnerResolver,
       CodeOwnerJson.Factory codeOwnerJsonFactory,
+      CodeOwnerConfigFileJson codeOwnerConfigFileJson,
       GitRepositoryManager repoManager) {
     super(
         accountVisibility,
@@ -93,7 +94,8 @@
         codeOwnersPluginConfiguration,
         codeOwnerConfigHierarchy,
         codeOwnerResolver,
-        codeOwnerJsonFactory);
+        codeOwnerJsonFactory,
+        codeOwnerConfigFileJson);
     this.repoManager = repoManager;
   }
 
diff --git a/java/com/google/gerrit/plugins/codeowners/restapi/GetCodeOwnersForPathInChange.java b/java/com/google/gerrit/plugins/codeowners/restapi/GetCodeOwnersForPathInChange.java
index 3ed9a51..b7149c5 100644
--- a/java/com/google/gerrit/plugins/codeowners/restapi/GetCodeOwnersForPathInChange.java
+++ b/java/com/google/gerrit/plugins/codeowners/restapi/GetCodeOwnersForPathInChange.java
@@ -73,7 +73,8 @@
       CodeOwnerConfigHierarchy codeOwnerConfigHierarchy,
       Provider<CodeOwnerResolver> codeOwnerResolver,
       ServiceUserClassifier serviceUserClassifier,
-      CodeOwnerJson.Factory codeOwnerJsonFactory) {
+      CodeOwnerJson.Factory codeOwnerJsonFactory,
+      CodeOwnerConfigFileJson codeOwnerConfigFileJson) {
     super(
         accountVisibility,
         accounts,
@@ -84,7 +85,8 @@
         codeOwnersPluginConfiguration,
         codeOwnerConfigHierarchy,
         codeOwnerResolver,
-        codeOwnerJsonFactory);
+        codeOwnerJsonFactory,
+        codeOwnerConfigFileJson);
     this.serviceUserClassifier = serviceUserClassifier;
   }
 
diff --git a/java/com/google/gerrit/plugins/codeowners/testing/CodeOwnerConfigFileInfoSubject.java b/java/com/google/gerrit/plugins/codeowners/testing/CodeOwnerConfigFileInfoSubject.java
new file mode 100644
index 0000000..410ad9a
--- /dev/null
+++ b/java/com/google/gerrit/plugins/codeowners/testing/CodeOwnerConfigFileInfoSubject.java
@@ -0,0 +1,177 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.plugins.codeowners.testing;
+
+import static com.google.common.truth.Truth.assertAbout;
+import static com.google.gerrit.truth.ListSubject.elements;
+
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.StringSubject;
+import com.google.common.truth.Subject;
+import com.google.gerrit.plugins.codeowners.api.CodeOwnerConfigFileInfo;
+import com.google.gerrit.plugins.codeowners.backend.CodeOwnerBackend;
+import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfig;
+import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfigImportMode;
+import com.google.gerrit.truth.ListSubject;
+
+/** {@link Subject} for doing assertions on {@link CodeOwnerConfigFileInfo}s. */
+public class CodeOwnerConfigFileInfoSubject extends Subject {
+  /**
+   * Starts fluent chain to do assertions on a {@link CodeOwnerConfigFileInfo}.
+   *
+   * @param codeOwnerConfigFileInfo the code owner config file info on which assertions should be
+   *     done
+   * @return the created {@link CodeOwnerConfigFileInfoSubject}
+   */
+  public static CodeOwnerConfigFileInfoSubject assertThat(
+      CodeOwnerConfigFileInfo codeOwnerConfigFileInfo) {
+    return assertAbout(codeOwnerConfigFileInfos()).that(codeOwnerConfigFileInfo);
+  }
+
+  public static Factory<CodeOwnerConfigFileInfoSubject, CodeOwnerConfigFileInfo>
+      codeOwnerConfigFileInfos() {
+    return CodeOwnerConfigFileInfoSubject::new;
+  }
+
+  private final CodeOwnerConfigFileInfo codeOwnerConfigFileInfo;
+
+  private CodeOwnerConfigFileInfoSubject(
+      FailureMetadata metadata, CodeOwnerConfigFileInfo codeOwnerConfigFileInfo) {
+    super(metadata, codeOwnerConfigFileInfo);
+    this.codeOwnerConfigFileInfo = codeOwnerConfigFileInfo;
+  }
+
+  /** Returns a subject for the project of the code owner config file info. */
+  public StringSubject hasProjectThat() {
+    return check("project()").that(codeOwnerConfigFileInfo().project);
+  }
+
+  /** Returns a subject for the branch of the code owner config file info. */
+  public StringSubject hasBranchThat() {
+    return check("branch()").that(codeOwnerConfigFileInfo().branch);
+  }
+
+  /** Returns a subject for the path of the code owner config file info. */
+  public StringSubject hasPathThat() {
+    return check("path()").that(codeOwnerConfigFileInfo().path);
+  }
+
+  /**
+   * Returns a {@link ListSubject} for the (resolved) imports of the code owner config file info.
+   */
+  public ListSubject<CodeOwnerConfigFileInfoSubject, CodeOwnerConfigFileInfo> hasImportsThat() {
+    return check("imports()")
+        .about(elements())
+        .thatCustom(codeOwnerConfigFileInfo().imports, codeOwnerConfigFileInfos());
+  }
+
+  /**
+   * Returns a {@link ListSubject} for the unresolved imports of the code owner config file info.
+   */
+  public ListSubject<CodeOwnerConfigFileInfoSubject, CodeOwnerConfigFileInfo>
+      hasUnresolvedImportsThat() {
+    return check("unresolvedimports()")
+        .about(elements())
+        .thatCustom(codeOwnerConfigFileInfo().unresolvedImports, codeOwnerConfigFileInfos());
+  }
+
+  /** Returns a subject for the import mode of the code owner config file info. */
+  public Subject hasImportModeThat() {
+    return check("importMode()").that(codeOwnerConfigFileInfo().importMode);
+  }
+
+  /** Returns a subject for the unresolved error message of the code owner config file info. */
+  public Subject hasUnresolvedErrorMessageThat() {
+    return check("unresolvedErrorMessage()").that(codeOwnerConfigFileInfo().unresolvedErrorMessage);
+  }
+
+  public CodeOwnerConfigFileInfoSubject assertKey(
+      CodeOwnerBackend codeOwnerBackend, CodeOwnerConfig.Key codeOwnerConfigKey) {
+    hasProjectThat().isEqualTo(codeOwnerConfigKey.project().get());
+    hasBranchThat().isEqualTo(codeOwnerConfigKey.branchNameKey().branch());
+    hasPathThat().isEqualTo(codeOwnerBackend.getFilePath(codeOwnerConfigKey).toString());
+    return this;
+  }
+
+  public CodeOwnerConfigFileInfoSubject assertNoResolvedImports() {
+    hasImportsThat().isNull();
+    return this;
+  }
+
+  public CodeOwnerConfigFileInfoSubject assertResolvedImport(
+      CodeOwnerBackend codeOwnerBackend,
+      CodeOwnerConfig.Key codeOwnerConfigKey,
+      CodeOwnerConfigImportMode importMode) {
+    hasImportsThat().hasSize(1);
+    CodeOwnerConfigFileInfoSubject subjectForResolvedImport = hasImportsThat().element(0);
+    subjectForResolvedImport
+        .assertKey(codeOwnerBackend, codeOwnerConfigKey)
+        .assertImportMode(importMode)
+        .assertNoUnresolvedErrorMessage();
+    return this;
+  }
+
+  public CodeOwnerConfigFileInfoSubject assertNoUnresolvedImports() {
+    hasUnresolvedImportsThat().isNull();
+    return this;
+  }
+
+  public CodeOwnerConfigFileInfoSubject assertUnresolvedImport(
+      CodeOwnerBackend codeOwnerBackend,
+      CodeOwnerConfig.Key codeOwnerConfigKey,
+      CodeOwnerConfigImportMode importMode,
+      String unresolvedErrorMessage) {
+    hasUnresolvedImportsThat().hasSize(1);
+    CodeOwnerConfigFileInfoSubject subjectForUnresolvedImport =
+        hasUnresolvedImportsThat().element(0);
+    subjectForUnresolvedImport
+        .assertKey(codeOwnerBackend, codeOwnerConfigKey)
+        .assertImportMode(importMode)
+        .assertUnresolvedErrorMessage(unresolvedErrorMessage);
+    return this;
+  }
+
+  public CodeOwnerConfigFileInfoSubject assertNoImports() {
+    assertNoResolvedImports();
+    assertNoUnresolvedImports();
+    return this;
+  }
+
+  public CodeOwnerConfigFileInfoSubject assertImportMode(CodeOwnerConfigImportMode importMode) {
+    hasImportModeThat().isEqualTo(importMode);
+    return this;
+  }
+
+  public CodeOwnerConfigFileInfoSubject assertNoImportMode() {
+    hasImportModeThat().isNull();
+    return this;
+  }
+
+  public CodeOwnerConfigFileInfoSubject assertUnresolvedErrorMessage(
+      String unresolvedErrorMessage) {
+    hasUnresolvedErrorMessageThat().isEqualTo(unresolvedErrorMessage);
+    return this;
+  }
+
+  public CodeOwnerConfigFileInfoSubject assertNoUnresolvedErrorMessage() {
+    hasUnresolvedErrorMessageThat().isNull();
+    return this;
+  }
+
+  private CodeOwnerConfigFileInfo codeOwnerConfigFileInfo() {
+    isNotNull();
+    return codeOwnerConfigFileInfo;
+  }
+}
diff --git a/java/com/google/gerrit/plugins/codeowners/testing/CodeOwnersInfoSubject.java b/java/com/google/gerrit/plugins/codeowners/testing/CodeOwnersInfoSubject.java
index 11433e2..9e5fb44 100644
--- a/java/com/google/gerrit/plugins/codeowners/testing/CodeOwnersInfoSubject.java
+++ b/java/com/google/gerrit/plugins/codeowners/testing/CodeOwnersInfoSubject.java
@@ -15,6 +15,7 @@
 package com.google.gerrit.plugins.codeowners.testing;
 
 import static com.google.common.truth.Truth.assertAbout;
+import static com.google.gerrit.plugins.codeowners.testing.CodeOwnerConfigFileInfoSubject.codeOwnerConfigFileInfos;
 import static com.google.gerrit.plugins.codeowners.testing.CodeOwnerInfoSubject.codeOwnerInfos;
 import static com.google.gerrit.truth.ListSubject.elements;
 
@@ -22,6 +23,7 @@
 import com.google.common.truth.FailureMetadata;
 import com.google.common.truth.IterableSubject;
 import com.google.common.truth.Subject;
+import com.google.gerrit.plugins.codeowners.api.CodeOwnerConfigFileInfo;
 import com.google.gerrit.plugins.codeowners.api.CodeOwnerInfo;
 import com.google.gerrit.plugins.codeowners.api.CodeOwnersInfo;
 import com.google.gerrit.truth.ListSubject;
@@ -65,6 +67,13 @@
     }
   }
 
+  public ListSubject<CodeOwnerConfigFileInfoSubject, CodeOwnerConfigFileInfo>
+      hasCodeOwnerConfigsThat() {
+    return check("codeOwnerConfigs()")
+        .about(elements())
+        .thatCustom(codeOwnersInfo().codeOwnerConfigs, codeOwnerConfigFileInfos());
+  }
+
   public IterableSubject hasDebugLogsThat() {
     return check("debugLogs").that(codeOwnersInfo().debugLogs);
   }
diff --git a/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/AbstractGetCodeOwnersForPathIT.java b/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/AbstractGetCodeOwnersForPathIT.java
index 74c9eb2..cd6f9a2 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/AbstractGetCodeOwnersForPathIT.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/acceptance/api/AbstractGetCodeOwnersForPathIT.java
@@ -17,6 +17,7 @@
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.gerrit.acceptance.testsuite.project.TestProjectUpdate.allowCapability;
 import static com.google.gerrit.acceptance.testsuite.project.TestProjectUpdate.block;
+import static com.google.gerrit.plugins.codeowners.testing.CodeOwnerConfigFileInfoSubject.assertThat;
 import static com.google.gerrit.plugins.codeowners.testing.CodeOwnerInfoSubject.hasAccountId;
 import static com.google.gerrit.plugins.codeowners.testing.CodeOwnerInfoSubject.hasAccountName;
 import static com.google.gerrit.plugins.codeowners.testing.CodeOwnersInfoSubject.assertThat;
@@ -25,6 +26,7 @@
 import static java.util.stream.Collectors.toList;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
 import com.google.gerrit.acceptance.TestAccount;
 import com.google.gerrit.acceptance.config.GerritConfig;
 import com.google.gerrit.acceptance.testsuite.account.AccountOperations;
@@ -44,13 +46,16 @@
 import com.google.gerrit.plugins.codeowners.acceptance.AbstractCodeOwnersIT;
 import com.google.gerrit.plugins.codeowners.acceptance.testsuite.TestCodeOwnerConfigCreation;
 import com.google.gerrit.plugins.codeowners.acceptance.testsuite.TestPathExpressions;
+import com.google.gerrit.plugins.codeowners.api.CodeOwnerConfigFileInfo;
 import com.google.gerrit.plugins.codeowners.api.CodeOwners;
 import com.google.gerrit.plugins.codeowners.api.CodeOwnersInfo;
+import com.google.gerrit.plugins.codeowners.backend.CodeOwnerBackend;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfig;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfigImportMode;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerConfigReference;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerResolver;
 import com.google.gerrit.plugins.codeowners.backend.CodeOwnerSet;
+import com.google.gerrit.plugins.codeowners.backend.config.BackendConfig;
 import com.google.gerrit.plugins.codeowners.restapi.CheckCodeOwnerCapability;
 import com.google.gerrit.plugins.codeowners.restapi.GetCodeOwnersForPathInBranch;
 import com.google.inject.Inject;
@@ -77,11 +82,14 @@
   @Inject private GroupOperations groupOperations;
   @Inject private ProjectOperations projectOperations;
 
+  private CodeOwnerBackend backend;
+
   protected TestPathExpressions testPathExpressions;
 
   @Before
   public void setup() throws Exception {
     testPathExpressions = plugin.getSysInjector().getInstance(TestPathExpressions.class);
+    backend = plugin.getSysInjector().getInstance(BackendConfig.class).getDefaultBackend();
   }
 
   /** Must return the {@link CodeOwners} API against which the tests should be run. */
@@ -98,7 +106,10 @@
 
   @Test
   public void getCodeOwnersWhenNoCodeOwnerConfigsExist() throws Exception {
-    assertThat(queryCodeOwners("/foo/bar/baz.md")).hasCodeOwnersThat().isEmpty();
+    CodeOwnersInfo codeOwnersInfo = queryCodeOwners("/foo/bar/baz.md");
+    assertThat(codeOwnersInfo).hasCodeOwnersThat().isEmpty();
+    assertThat(codeOwnersInfo).hasOwnedByAllUsersThat().isNull();
+    assertThat(codeOwnersInfo).hasCodeOwnerConfigsThat().isEmpty();
   }
 
   @Test
@@ -115,6 +126,7 @@
     CodeOwnersInfo codeOwnersInfo = queryCodeOwners("/foo/bar/baz.md");
     assertThat(codeOwnersInfo).hasCodeOwnersThat().isEmpty();
     assertThat(codeOwnersInfo).hasOwnedByAllUsersThat().isNull();
+    assertThat(codeOwnersInfo).hasCodeOwnerConfigsThat().isEmpty();
   }
 
   @Test
@@ -136,29 +148,32 @@
   private void testGetCodeOwners(boolean useAbsolutePath) throws Exception {
     TestAccount user2 = accountCreator.user2();
 
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/")
-        .addCodeOwnerEmail(admin.email())
-        .create();
+    CodeOwnerConfig.Key codeOwnerConfigKey1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/")
+            .addCodeOwnerEmail(admin.email())
+            .create();
 
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/foo/")
-        .addCodeOwnerEmail(user.email())
-        .create();
+    CodeOwnerConfig.Key codeOwnerConfigKey2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/")
+            .addCodeOwnerEmail(user.email())
+            .create();
 
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/foo/bar/")
-        .addCodeOwnerEmail(user2.email())
-        .create();
+    CodeOwnerConfig.Key codeOwnerConfigKey3 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/")
+            .addCodeOwnerEmail(user2.email())
+            .create();
 
     CodeOwnersInfo codeOwnersInfo =
         queryCodeOwners(useAbsolutePath ? "/foo/bar/baz.md" : "foo/bar/baz.md");
@@ -172,6 +187,27 @@
         .comparingElementsUsing(hasAccountName())
         .containsExactly(null, null, null);
     assertThat(codeOwnersInfo).hasOwnedByAllUsersThat().isNull();
+
+    assertThat(codeOwnersInfo.codeOwnerConfigs).hasSize(3);
+    CodeOwnerConfigFileInfo codeOwnerConfigFileInfo3 = codeOwnersInfo.codeOwnerConfigs.get(0);
+    CodeOwnerConfigFileInfo codeOwnerConfigFileInfo2 = codeOwnersInfo.codeOwnerConfigs.get(1);
+    CodeOwnerConfigFileInfo codeOwnerConfigFileInfo1 = codeOwnersInfo.codeOwnerConfigs.get(2);
+    assertThat(codeOwnerConfigFileInfo3)
+        .assertKey(backend, codeOwnerConfigKey3)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
+    assertThat(codeOwnerConfigFileInfo2)
+        .assertKey(backend, codeOwnerConfigKey2)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
+    assertThat(codeOwnerConfigFileInfo1)
+        .assertKey(backend, codeOwnerConfigKey1)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
+
     assertThat(codeOwnersInfo).hasDebugLogsThat().isNull();
   }
 
@@ -184,24 +220,26 @@
 
     // 1. code owner config that makes "user2" a code owner, inheriting code owners from parent code
     // owner configs is enabled by default
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/foo/bar/")
-        .addCodeOwnerEmail(user2.email())
-        .create();
+    CodeOwnerConfig.Key codeOwnerConfigKey1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/")
+            .addCodeOwnerEmail(user2.email())
+            .create();
 
     // 2. code owner config that makes "user" a code owner, code owners from parent code owner
     // configs are ignored
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/foo/")
-        .ignoreParentCodeOwners()
-        .addCodeOwnerEmail(user.email())
-        .create();
+    CodeOwnerConfig.Key codeOwnerConfigKey2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/")
+            .ignoreParentCodeOwners()
+            .addCodeOwnerEmail(user.email())
+            .create();
 
     // 3. code owner config that makes "admin" a code owner and assigns code ownership to all users,
     // but for this test this code owner config is ignored, since the 2. code owner config ignores
@@ -227,36 +265,71 @@
         .containsExactly(user2.id(), user.id())
         .inOrder();
     assertThat(codeOwnersInfo).hasOwnedByAllUsersThat().isNull();
+
+    assertThat(codeOwnersInfo.codeOwnerConfigs).hasSize(2);
+    CodeOwnerConfigFileInfo codeOwnerConfigFileInfo1 = codeOwnersInfo.codeOwnerConfigs.get(0);
+    CodeOwnerConfigFileInfo codeOwnerConfigFileInfo2 = codeOwnersInfo.codeOwnerConfigs.get(1);
+    assertThat(codeOwnerConfigFileInfo1)
+        .assertKey(backend, codeOwnerConfigKey1)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
+    assertThat(codeOwnerConfigFileInfo2)
+        .assertKey(backend, codeOwnerConfigKey2)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
   }
 
   @Test
   public void getPerFileCodeOwners() throws Exception {
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/foo/bar/")
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .addPathExpression(testPathExpressions.matchFileType("txt"))
-                .addCodeOwnerEmail(admin.email())
-                .build())
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .addPathExpression(testPathExpressions.matchFileType("md"))
-                .addCodeOwnerEmail(user.email())
-                .build())
-        .create();
+    CodeOwnerConfig.Key codeOwnerConfigKey =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/")
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .addPathExpression(testPathExpressions.matchFileType("txt"))
+                    .addCodeOwnerEmail(admin.email())
+                    .build())
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .addPathExpression(testPathExpressions.matchFileType("md"))
+                    .addCodeOwnerEmail(user.email())
+                    .build())
+            .create();
 
-    assertThat(queryCodeOwners("/foo/bar/config.txt"))
+    CodeOwnersInfo codeOwnersInfo = queryCodeOwners("/foo/bar/config.txt");
+    assertThat(codeOwnersInfo)
         .hasCodeOwnersThat()
         .comparingElementsUsing(hasAccountId())
         .containsExactly(admin.id());
-    assertThat(queryCodeOwners("/foo/bar/baz.md"))
+    assertThat(Iterables.getOnlyElement(codeOwnersInfo.codeOwnerConfigs))
+        .assertKey(backend, codeOwnerConfigKey)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
+
+    codeOwnersInfo = queryCodeOwners("/foo/bar/baz.md");
+    assertThat(codeOwnersInfo)
         .hasCodeOwnersThat()
         .comparingElementsUsing(hasAccountId())
         .containsExactly(user.id());
-    assertThat(queryCodeOwners("/foo/bar/main.config")).hasCodeOwnersThat().isEmpty();
+    assertThat(Iterables.getOnlyElement(codeOwnersInfo.codeOwnerConfigs))
+        .assertKey(backend, codeOwnerConfigKey)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
+
+    codeOwnersInfo = queryCodeOwners("/foo/bar/main.config");
+    assertThat(codeOwnersInfo).hasCodeOwnersThat().isEmpty();
+    assertThat(Iterables.getOnlyElement(codeOwnersInfo.codeOwnerConfigs))
+        .assertKey(backend, codeOwnerConfigKey)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
   }
 
   @Test
@@ -548,22 +621,24 @@
     TestAccount user2 = accountCreator.user2();
 
     // create some code owner configs
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/")
-        .addCodeOwnerEmail(admin.email())
-        .create();
+    CodeOwnerConfig.Key codeOwnerConfigKey1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/")
+            .addCodeOwnerEmail(admin.email())
+            .create();
 
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/foo/bar/")
-        .addCodeOwnerEmail(user.email())
-        .addCodeOwnerEmail(user2.email())
-        .create();
+    CodeOwnerConfig.Key codeOwnerConfigKey2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/")
+            .addCodeOwnerEmail(user.email())
+            .addCodeOwnerEmail(user2.email())
+            .create();
 
     // get code owners with different limits
     CodeOwnersInfo codeOwnersInfo =
@@ -576,18 +651,51 @@
         .element(0)
         .hasAccountIdThat()
         .isAnyOf(user.id(), user2.id());
+    assertThat(codeOwnersInfo.codeOwnerConfigs).hasSize(2);
+    assertThat(codeOwnersInfo.codeOwnerConfigs.get(0))
+        .assertKey(backend, codeOwnerConfigKey2)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
+    assertThat(codeOwnersInfo.codeOwnerConfigs.get(1))
+        .assertKey(backend, codeOwnerConfigKey1)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
 
     codeOwnersInfo = queryCodeOwners(getCodeOwnersApi().query().withLimit(2), "/foo/bar/baz.md");
     assertThat(codeOwnersInfo)
         .hasCodeOwnersThat()
         .comparingElementsUsing(hasAccountId())
         .containsExactly(user.id(), user2.id());
+    assertThat(codeOwnersInfo.codeOwnerConfigs).hasSize(2);
+    assertThat(codeOwnersInfo.codeOwnerConfigs.get(0))
+        .assertKey(backend, codeOwnerConfigKey2)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
+    assertThat(codeOwnersInfo.codeOwnerConfigs.get(1))
+        .assertKey(backend, codeOwnerConfigKey1)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
 
     codeOwnersInfo = getCodeOwnersApi().query().withLimit(3).get("/foo/bar/baz.md");
     assertThat(codeOwnersInfo)
         .hasCodeOwnersThat()
         .comparingElementsUsing(hasAccountId())
         .containsExactly(admin.id(), user.id(), user2.id());
+    assertThat(codeOwnersInfo.codeOwnerConfigs).hasSize(2);
+    assertThat(codeOwnersInfo.codeOwnerConfigs.get(0))
+        .assertKey(backend, codeOwnerConfigKey2)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
+    assertThat(codeOwnersInfo.codeOwnerConfigs.get(1))
+        .assertKey(backend, codeOwnerConfigKey1)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
   }
 
   @Test
@@ -632,10 +740,12 @@
   public void getGlobalCodeOwners() throws Exception {
     TestAccount globalOwner =
         accountCreator.create("global_owner", "global.owner@example.com", "Global Owner", null);
-    assertThat(queryCodeOwners("/foo/bar/baz.md"))
+    CodeOwnersInfo codeOwnersInfo = queryCodeOwners("/foo/bar/baz.md");
+    assertThat(codeOwnersInfo)
         .hasCodeOwnersThat()
         .comparingElementsUsing(hasAccountId())
         .containsExactly(globalOwner.id());
+    assertThat(codeOwnersInfo).hasCodeOwnerConfigsThat().isEmpty();
   }
 
   @Test
@@ -767,18 +877,25 @@
   @Test
   public void getDefaultCodeOwners() throws Exception {
     // Create default code owner config file in refs/meta/config.
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch(RefNames.REFS_CONFIG)
-        .folderPath("/")
-        .addCodeOwnerEmail(user.email())
-        .create();
+    CodeOwnerConfig.Key codeOwnerConfigKey =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch(RefNames.REFS_CONFIG)
+            .folderPath("/")
+            .addCodeOwnerEmail(user.email())
+            .create();
 
-    assertThat(queryCodeOwners("/foo/bar/baz.md"))
+    CodeOwnersInfo codeOwnersInfo = queryCodeOwners("/foo/bar/baz.md");
+    assertThat(codeOwnersInfo)
         .hasCodeOwnersThat()
         .comparingElementsUsing(hasAccountId())
         .containsExactly(user.id());
+    assertThat(Iterables.getOnlyElement(codeOwnersInfo.codeOwnerConfigs))
+        .assertKey(backend, codeOwnerConfigKey)
+        .assertNoImports()
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage();
   }
 
   @Test
@@ -1643,4 +1760,168 @@
     }
     assertThat(foundDifferentOrder).isTrue();
   }
+
+  @Test
+  public void getCodeOwnersWithUnresolvedImport() throws Exception {
+    skipTestIfImportsNotSupportedByCodeOwnersBackend();
+
+    Project.NameKey nonExistingProject = Project.nameKey("non-existing");
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        CodeOwnerConfig.Key.create(nonExistingProject, "master", "/", "OWNERS");
+    CodeOwnerConfigReference nonResolvableCodeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/")
+            .addImport(nonResolvableCodeOwnerConfigReference)
+            .addCodeOwnerEmail(admin.email())
+            .addCodeOwnerEmail(user.email())
+            .create();
+
+    String path = "/foo/bar/baz.md";
+    CodeOwnersInfo codeOwnersInfo = queryCodeOwners(getCodeOwnersApi().query(), path);
+    assertThat(codeOwnersInfo)
+        .hasCodeOwnersThat()
+        .comparingElementsUsing(hasAccountId())
+        .containsExactly(user.id(), admin.id());
+    assertThat(Iterables.getOnlyElement(codeOwnersInfo.codeOwnerConfigs))
+        .assertKey(backend, keyOfImportingCodeOwnerConfig)
+        .assertNoResolvedImports()
+        .assertUnresolvedImport(
+            backend,
+            keyOfImportedCodeOwnerConfig,
+            nonResolvableCodeOwnerConfigReference.importMode(),
+            String.format("project %s not found", nonExistingProject));
+  }
+
+  @Test
+  public void getCodeOwnersWithResolvedImport() throws Exception {
+    skipTestIfImportsNotSupportedByCodeOwnersBackend();
+
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/baz/")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/")
+            .addImport(codeOwnerConfigReference)
+            .addCodeOwnerEmail(user.email())
+            .create();
+
+    String path = "/foo/bar/baz.md";
+    CodeOwnersInfo codeOwnersInfo = queryCodeOwners(getCodeOwnersApi().query(), path);
+    assertThat(codeOwnersInfo)
+        .hasCodeOwnersThat()
+        .comparingElementsUsing(hasAccountId())
+        .containsExactly(user.id(), admin.id());
+    assertThat(Iterables.getOnlyElement(codeOwnersInfo.codeOwnerConfigs))
+        .assertKey(backend, keyOfImportingCodeOwnerConfig)
+        .assertNoUnresolvedImports()
+        .assertResolvedImport(
+            backend, keyOfImportedCodeOwnerConfig, codeOwnerConfigReference.importMode());
+  }
+
+  @Test
+  public void getCodeOwnersWithNestedImport() throws Exception {
+    skipTestIfImportsNotSupportedByCodeOwnersBackend();
+
+    TestAccount user2 = accountCreator.user2();
+
+    Project.NameKey nonExistingProject = Project.nameKey("non-existing");
+    CodeOwnerConfig.Key keyOfUnresolvableCodeOwnerConfig =
+        CodeOwnerConfig.Key.create(nonExistingProject, "master", "/", "OWNERS");
+    CodeOwnerConfigReference unresolvableCodeOwnerConfigReference =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY,
+            keyOfUnresolvableCodeOwnerConfig);
+
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .addImport(unresolvableCodeOwnerConfigReference)
+            .addCodeOwnerEmail(admin.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference2 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig2);
+
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/baz/")
+            .addImport(codeOwnerConfigReference2)
+            .addCodeOwnerEmail(user2.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference1 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig1);
+
+    CodeOwnerConfig.Key keyOfImportingCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/")
+            .addImport(codeOwnerConfigReference1)
+            .addCodeOwnerEmail(user.email())
+            .create();
+
+    String path = "/foo/bar/baz.md";
+    CodeOwnersInfo codeOwnersInfo = queryCodeOwners(getCodeOwnersApi().query(), path);
+    assertThat(codeOwnersInfo)
+        .hasCodeOwnersThat()
+        .comparingElementsUsing(hasAccountId())
+        .containsExactly(user.id(), user2.id(), admin.id());
+
+    CodeOwnerConfigFileInfo codeOwnerConfigFileInfo =
+        Iterables.getOnlyElement(codeOwnersInfo.codeOwnerConfigs);
+    assertThat(codeOwnerConfigFileInfo)
+        .assertKey(backend, keyOfImportingCodeOwnerConfig)
+        .assertNoImportMode()
+        .assertNoUnresolvedErrorMessage()
+        .assertNoUnresolvedImports()
+        .assertResolvedImport(
+            backend, keyOfImportedCodeOwnerConfig1, codeOwnerConfigReference1.importMode());
+
+    codeOwnerConfigFileInfo = Iterables.getOnlyElement(codeOwnerConfigFileInfo.imports);
+    assertThat(codeOwnerConfigFileInfo)
+        .assertKey(backend, keyOfImportedCodeOwnerConfig1)
+        .assertImportMode(codeOwnerConfigReference1.importMode())
+        .assertNoUnresolvedErrorMessage()
+        .assertNoUnresolvedImports()
+        .assertResolvedImport(
+            backend, keyOfImportedCodeOwnerConfig2, codeOwnerConfigReference2.importMode());
+
+    codeOwnerConfigFileInfo = Iterables.getOnlyElement(codeOwnerConfigFileInfo.imports);
+    assertThat(codeOwnerConfigFileInfo)
+        .assertKey(backend, keyOfImportedCodeOwnerConfig2)
+        .assertImportMode(codeOwnerConfigReference2.importMode())
+        .assertNoUnresolvedErrorMessage()
+        .assertNoResolvedImports()
+        .assertUnresolvedImport(
+            backend,
+            keyOfUnresolvableCodeOwnerConfig,
+            unresolvableCodeOwnerConfigReference.importMode(),
+            String.format("project %s not found", nonExistingProject));
+  }
 }
diff --git a/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImportTest.java b/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImportTest.java
new file mode 100644
index 0000000..b6efbc6
--- /dev/null
+++ b/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerConfigImportTest.java
@@ -0,0 +1,41 @@
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.plugins.codeowners.backend;
+
+import org.junit.Test;
+
+/** Tests for {@link CodeOwnerConfigImport}. */
+public class CodeOwnerConfigImportTest extends AbstractAutoValueTest {
+  @Test
+  public void toStringIncludesAllData_resolvedImport() throws Exception {
+    CodeOwnerConfigImport resolvedImport =
+        CodeOwnerConfigImport.createResolvedImport(
+            CodeOwnerConfig.Key.create(project, "master", "/"),
+            CodeOwnerConfig.Key.create(project, "master", "/bar/"),
+            CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"));
+    assertThatToStringIncludesAllData(resolvedImport, CodeOwnerConfigImport.class);
+  }
+
+  @Test
+  public void toStringIncludesAllData_unresolvedImport() throws Exception {
+    CodeOwnerConfigImport unresolvedImport =
+        CodeOwnerConfigImport.createUnresolvedImport(
+            CodeOwnerConfig.Key.create(project, "master", "/"),
+            CodeOwnerConfig.Key.create(project, "master", "/bar/"),
+            CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"),
+            "test message");
+    assertThatToStringIncludesAllData(unresolvedImport, CodeOwnerConfigImport.class);
+  }
+}
diff --git a/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResultTest.java b/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResultTest.java
index 18ea017..deab817 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResultTest.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/backend/CodeOwnerResolverResultTest.java
@@ -29,7 +29,17 @@
             /* annotations= */ ImmutableMultimap.of(),
             /* ownedByAllUsers= */ false,
             /* hasUnresolvedCodeOwners= */ false,
-            /* hasUnresolvedImports= */ false,
+            ImmutableList.of(
+                CodeOwnerConfigImport.createResolvedImport(
+                    CodeOwnerConfig.Key.create(project, "master", "/"),
+                    CodeOwnerConfig.Key.create(project, "master", "/bar/"),
+                    CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"))),
+            ImmutableList.of(
+                CodeOwnerConfigImport.createUnresolvedImport(
+                    CodeOwnerConfig.Key.create(project, "master", "/"),
+                    CodeOwnerConfig.Key.create(project, "master", "/bar/"),
+                    CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"),
+                    "test message")),
             ImmutableList.of("test message"));
     assertThatToStringIncludesAllData(codeOwnerResolverResult, CodeOwnerResolverResult.class);
   }
diff --git a/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResultTest.java b/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResultTest.java
index d270fdc..d9b3a71 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResultTest.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersResultTest.java
@@ -27,19 +27,27 @@
   @Test
   public void toStringIncludesAllData() throws Exception {
     CodeOwnerConfig.Key codeOwnerConfigKey = CodeOwnerConfig.Key.create(project, "master", "/");
-    CodeOwnerConfigReference codeOwnerConfigReference =
+    CodeOwnerConfigReference resolvableCodeOwnerConfigReference =
         CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS");
+    CodeOwnerConfigReference unresolvableCodeOwnerConfigReference =
+        CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/baz/OWNERS");
     PathCodeOwnersResult pathCodeOwnersResult =
         PathCodeOwnersResult.create(
             Paths.get("/foo/bar/baz.md"),
             CodeOwnerConfig.builder(codeOwnerConfigKey, TEST_REVISION)
-                .addImport(codeOwnerConfigReference)
+                .addImport(resolvableCodeOwnerConfigReference)
+                .addImport(unresolvableCodeOwnerConfigReference)
                 .build(),
             ImmutableList.of(
-                UnresolvedImport.create(
+                CodeOwnerConfigImport.createResolvedImport(
                     codeOwnerConfigKey,
                     CodeOwnerConfig.Key.create(project, "master", "/bar/"),
-                    codeOwnerConfigReference,
+                    resolvableCodeOwnerConfigReference)),
+            ImmutableList.of(
+                CodeOwnerConfigImport.createUnresolvedImport(
+                    codeOwnerConfigKey,
+                    CodeOwnerConfig.Key.create(project, "master", "/baz/"),
+                    unresolvableCodeOwnerConfigReference,
                     "test message")));
     assertThatToStringIncludesAllData(pathCodeOwnersResult, PathCodeOwnersResult.class);
   }
diff --git a/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersTest.java b/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersTest.java
index 9563ade..04df442 100644
--- a/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersTest.java
+++ b/javatests/com/google/gerrit/plugins/codeowners/backend/PathCodeOwnersTest.java
@@ -239,7 +239,8 @@
         pathCodeOwnersFactory.createWithoutCache(
             emptyCodeOwnerConfig, Paths.get("/foo/bar/baz.md"));
     assertThat(pathCodeOwners.resolveCodeOwnerConfig().get().getPathCodeOwners()).isEmpty();
-    assertThat(pathCodeOwners.resolveCodeOwnerConfig().get().hasUnresolvedImports()).isFalse();
+    assertThat(pathCodeOwners.resolveCodeOwnerConfig().get().resolvedImports()).isEmpty();
+    assertThat(pathCodeOwners.resolveCodeOwnerConfig().get().unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -471,6 +472,11 @@
 
   @Test
   public void nonResolveableImportIsIgnored() throws Exception {
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        CodeOwnerConfig.Key.create(project, "master", "/non-existing/", "OWNERS");
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with non-resolveable import
     CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
@@ -478,9 +484,7 @@
             .project(project)
             .branch("master")
             .folderPath("/")
-            .addImport(
-                CodeOwnerConfigReference.create(
-                    CodeOwnerConfigImportMode.ALL, "/non-existing/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(admin.email()).build())
             .create();
 
@@ -494,24 +498,40 @@
 
     // Expectation: we get the global code owner from the importing code owner config, the
     // non-resolveable import is silently ignored
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports()).isTrue();
+    assertThat(pathCodeOwnersResult.resolvedImports()).isEmpty();
+    assertThat(pathCodeOwnersResult.unresolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createUnresolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference,
+                String.format(
+                    "code owner config does not exist (revision = %s)",
+                    projectOperations
+                        .project(keyOfImportedCodeOwnerConfig.project())
+                        .getHead(keyOfImportedCodeOwnerConfig.branchNameKey().branch())
+                        .name())));
   }
 
   @Test
   public void importOfNonCodeOwnerConfigFileIsIgnored() throws Exception {
     // create a file that looks like a code owner config file, but which has a name that is not
     // allowed as code owner config file
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/")
-        .fileName("FOO")
-        .addCodeOwnerEmail(user.email())
-        .create();
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/")
+            .fileName("FOO")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create config with import of non code owner config file
     CodeOwnerConfig.Key importingCodeOwnerConfigKey =
@@ -520,7 +540,7 @@
             .project(project)
             .branch("master")
             .folderPath("/")
-            .addImport(CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/FOO"))
+            .addImport(codeOwnerConfigReference)
             .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(admin.email()).build())
             .create();
 
@@ -538,7 +558,19 @@
     assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email());
-    assertThat(pathCodeOwnersResult.hasUnresolvedImports()).isTrue();
+    assertThat(pathCodeOwnersResult.resolvedImports()).isEmpty();
+    assertThat(pathCodeOwnersResult.unresolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createUnresolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference,
+                String.format(
+                    "code owner config does not exist (revision = %s)",
+                    projectOperations
+                        .project(keyOfImportedCodeOwnerConfig.project())
+                        .getHead(keyOfImportedCodeOwnerConfig.branchNameKey().branch())
+                        .name())));
   }
 
   @Test
@@ -548,14 +580,17 @@
     // parameter fileExtension) or file extensions are enabled for code owner config files (config
     // paramater enableCodeOwnerConfigFilesWithFileExtensions). Both is not the case here, hence any
     // import of this file in another code owner config file should get ignored.
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/")
-        .fileName("OWNERS.foo")
-        .addCodeOwnerEmail(user.email())
-        .create();
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/")
+            .fileName("OWNERS.foo")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create the importing config
     CodeOwnerConfig.Key importingCodeOwnerConfigKey =
@@ -564,8 +599,7 @@
             .project(project)
             .branch("master")
             .folderPath("/")
-            .addImport(
-                CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/OWNERS.FOO"))
+            .addImport(codeOwnerConfigReference)
             .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(admin.email()).build())
             .create();
 
@@ -584,7 +618,19 @@
     assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email());
-    assertThat(pathCodeOwnersResult.hasUnresolvedImports()).isTrue();
+    assertThat(pathCodeOwnersResult.resolvedImports()).isEmpty();
+    assertThat(pathCodeOwnersResult.unresolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createUnresolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference,
+                String.format(
+                    "code owner config does not exist (revision = %s)",
+                    projectOperations
+                        .project(keyOfImportedCodeOwnerConfig.project())
+                        .getHead(keyOfImportedCodeOwnerConfig.branchNameKey().branch())
+                        .name())));
   }
 
   @Test
@@ -595,14 +641,17 @@
     // Create a code owner config file with a file extension. This file is considered as a code
     // owner config file since file extensions for code owner config files are enabled (paramater
     // enableCodeOwnerConfigFilesWithFileExtensions).
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/")
-        .fileName("OWNERS.FOO")
-        .addCodeOwnerEmail(user.email())
-        .create();
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/")
+            .fileName("OWNERS.FOO")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create the importing config
     CodeOwnerConfig.Key importingCodeOwnerConfigKey =
@@ -611,8 +660,7 @@
             .project(project)
             .branch("master")
             .folderPath("/")
-            .addImport(
-                CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/OWNERS.FOO"))
+            .addImport(codeOwnerConfigReference)
             .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(admin.email()).build())
             .create();
 
@@ -630,7 +678,13 @@
     assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
-    assertThat(pathCodeOwnersResult.hasUnresolvedImports()).isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -644,6 +698,19 @@
   }
 
   private void testImportGlobalCodeOwners(CodeOwnerConfigImportMode importMode) throws Exception {
+    // create imported config with global code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(importMode, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import
     CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
@@ -652,18 +719,9 @@
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(CodeOwnerConfigReference.create(importMode, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with global code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
@@ -674,17 +732,40 @@
 
     // Expectation: we get the global code owners from the importing and the imported code owner
     // config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void importPerFileCodeOwners_importModeAll() throws Exception {
+    // create imported config with matching per-file code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .addPathExpression("*.md")
+                    .addCodeOwnerEmail(user.email())
+                    .build())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with matching per-file code owner and import
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -695,44 +776,53 @@
                     .addPathExpression("*.md")
                     .addCodeOwnerEmail(admin.email())
                     .build())
-            .addImport(
-                CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with matching per-file code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .addPathExpression("*.md")
-                .addCodeOwnerEmail(user.email())
-                .build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: we get the matching per-file code owners from the importing and the imported
     // code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void nonMatchingPerFileCodeOwnersAreNotImported_importModeAll() throws Exception {
+    // create imported config with non-matching per-file code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .addPathExpression("*.txt")
+                    .addCodeOwnerEmail(user.email())
+                    .build())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with matching per-file code owner and import
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -743,27 +833,13 @@
                     .addPathExpression("*.md")
                     .addCodeOwnerEmail(admin.email())
                     .build())
-            .addImport(
-                CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with non-matching per-file code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .addPathExpression("*.txt")
-                .addCodeOwnerEmail(user.email())
-                .build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -771,17 +847,41 @@
     // Expectation: we only get the matching per-file code owners from the importing code owner
     // config, the per-file code owners from the imported code owner config are not relevant since
     // they do not match
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void perFileCodeOwnersAreNotImported_importModeGlobalCodeOwnerSetsOnly() throws Exception {
+    // create imported config with matching per-file code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .addPathExpression("*.md")
+                    .addCodeOwnerEmail(user.email())
+                    .build())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
+
     // create importing config with matching per-file code owner and import
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -792,28 +892,13 @@
                     .addPathExpression("*.md")
                     .addCodeOwnerEmail(admin.email())
                     .build())
-            .addImport(
-                CodeOwnerConfigReference.create(
-                    CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with matching per-file code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .addPathExpression("*.md")
-                .addCodeOwnerEmail(user.email())
-                .build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -821,48 +906,57 @@
     // Expectation: we only get the matching per-file code owners from the importing code owner
     // config, the matching per-file code owners from the imported code owner config are not
     // relevant with import mode GLOBAL_CODE_OWNER_SETS_ONLY
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void
       importIgnoreGlobalAndParentCodeOwnersFlagFromMatchingPerFileCodeOwnerSet_importModeAll()
           throws Exception {
+    // create imported config with matching per-file code owner that has the
+    // ignoreGlobalAndParentCodeOwners flag set to true
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .setIgnoreGlobalAndParentCodeOwners()
+                    .addPathExpression("*.md")
+                    .addCodeOwnerEmail(user.email())
+                    .build())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with matching per-file code owner that has the
-    // ignoreGlobalAndParentCodeOwners flag set to true
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .setIgnoreGlobalAndParentCodeOwners()
-                .addPathExpression("*.md")
-                .addCodeOwnerEmail(user.email())
-                .build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -872,50 +966,58 @@
     // the matching per-file code owner set in the imported code owner config has the
     // ignoreGlobalAndParentCodeOwners flag set to true which causes global code owners to be
     // ignored, in addition this flag causes parent code owners to be ignored
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(user.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().ignoreParentCodeOwners())
-        .isTrue();
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.ignoreParentCodeOwners()).isTrue();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void
       ignoreGlobalAndParentCodeOwnersFlagIsNotImportedFromNonMatchingPerFileCodeOwnerSet_importModeAll()
           throws Exception {
+    // create imported config with non-matching per-file code owner that has the
+    // ignoreGlobalAndParentCodeOwners flag set to true
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .setIgnoreGlobalAndParentCodeOwners()
+                    .addPathExpression("*.txt")
+                    .addCodeOwnerEmail(user.email())
+                    .build())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with non-matching per-file code owner that has the
-    // ignoreGlobalAndParentCodeOwners flag set to true
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .setIgnoreGlobalAndParentCodeOwners()
-                .addPathExpression("*.txt")
-                .addCodeOwnerEmail(user.email())
-                .build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -924,50 +1026,58 @@
     // per-file code owners from the imported code owner config and its
     // ignoreGlobalAndParentCodeOwners flag are not relevant since the per-file code owner set does
     // not match
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().ignoreParentCodeOwners())
-        .isFalse();
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.ignoreParentCodeOwners()).isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void ignoreGlobalAndParentCodeOwnersFlagIsNotImported_importModeGlobalCodeOwnerSetsOnly()
       throws Exception {
+    // create imported config with matching per-file code owner that has the
+    // ignoreGlobalAndParentCodeOwners flag set to true
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .setIgnoreGlobalAndParentCodeOwners()
+                    .addPathExpression("*.md")
+                    .addCodeOwnerEmail(user.email())
+                    .build())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.create(
-                    CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with matching per-file code owner that has the
-    // ignoreGlobalAndParentCodeOwners flag set to true
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .setIgnoreGlobalAndParentCodeOwners()
-                .addPathExpression("*.md")
-                .addCodeOwnerEmail(user.email())
-                .build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -976,89 +1086,114 @@
     // matching per-file code owners from the imported code owner config and its
     // ignoreGlobalAndParentCodeOwners flag are not relevant with import mode
     // GLOBAL_CODE_OWNER_SETS_ONLY
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().ignoreParentCodeOwners())
-        .isFalse();
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.ignoreParentCodeOwners()).isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void importIgnoreParentCodeOwnersFlag_importModeAll() throws Exception {
+    // create imported config with the ignoreParentCodeOnwers flag set to true
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .ignoreParentCodeOwners()
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with the ignoreParentCodeOnwers flag set to true
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .ignoreParentCodeOwners()
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: ignoreParentCodeOwners is true because the ignoreParentCodeOwners flag in the
     // imported code owner config is set to true
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().ignoreParentCodeOwners())
-        .isTrue();
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.ignoreParentCodeOwners()).isTrue();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void ignoreParentCodeOwnersFlagNotImported_importModeGlobalCodeOwnerSetsOnly()
       throws Exception {
+    // create imported config with the ignoreParentCodeOnwers flag set to true
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .ignoreParentCodeOwners()
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
+
     // create importing config
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.create(
-                    CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with the ignoreParentCodeOnwers flag set to true
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .ignoreParentCodeOwners()
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: ignoreParentCodeOwners is false because the ignoreParentCodeOwners flag in the
     // imported code owner config is not relevant with import mode GLOBAL_CODE_OWNER_SETS_ONLY
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().ignoreParentCodeOwners())
-        .isFalse();
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.ignoreParentCodeOwners()).isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -1077,51 +1212,69 @@
       throws Exception {
     TestAccount user2 = accountCreator.user2();
 
+    // create config with global code owner that is imported by the imported config
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/baz/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user2.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference2 =
+        createCodeOwnerConfigReference(importMode, keyOfImportedCodeOwnerConfig2);
+
+    // create imported config with global code owner and import
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .addImport(codeOwnerConfigReference2)
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference1 =
+        createCodeOwnerConfigReference(importMode, keyOfImportedCodeOwnerConfig1);
+
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(CodeOwnerConfigReference.create(importMode, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference1)
             .create();
 
-    // create imported config with global code owner and import
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .addImport(CodeOwnerConfigReference.create(importMode, "/baz/OWNERS"))
-        .create();
-
-    // create config with global code owner that is imported by the imported config
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/baz/")
-        .addCodeOwnerEmail(user2.email())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: we get the global owners from the importing code owner config, the imported code
     // owner config and the code owner config that is imported by the imported code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email(), user2.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig1,
+                codeOwnerConfigReference1),
+            CodeOwnerConfigImport.createResolvedImport(
+                keyOfImportedCodeOwnerConfig1,
+                keyOfImportedCodeOwnerConfig2,
+                codeOwnerConfigReference2));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -1130,47 +1283,54 @@
           throws Exception {
     TestAccount user2 = accountCreator.user2();
 
+    // create config with per file code owner that is imported by the imported config
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/baz/")
+            .fileName("OWNERS")
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .addPathExpression("foo.md")
+                    .addCodeOwnerEmail(user2.email())
+                    .build())
+            .create();
+
+    // create imported config with global code owner and import with import mode ALL
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .addImport(
+                createCodeOwnerConfigReference(
+                    CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig2))
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference1 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig1);
+
     // create importing config with global code owner and import with import mode
     // GLOBAL_CODE_OWNER_SETS_ONLY
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.create(
-                    CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference1)
             .create();
 
-    // create imported config with global code owner and import with import mode ALL
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .addImport(CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/baz/OWNERS"))
-        .create();
-
-    // create config with per file code owner that is imported by the imported config
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/baz/")
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .addPathExpression("foo.md")
-                .addCodeOwnerEmail(user2.email())
-                .build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1178,11 +1338,23 @@
     // Expectation: we get the global owners from the importing code owner config and the imported
     // code owner config but not the per file code owner from the code owner config that is imported
     // by the imported code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig1,
+                codeOwnerConfigReference1),
+            CodeOwnerConfigImport.createResolvedImport(
+                keyOfImportedCodeOwnerConfig1,
+                keyOfImportedCodeOwnerConfig2,
+                createCodeOwnerConfigReference(
+                    CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY,
+                    keyOfImportedCodeOwnerConfig2)));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -1197,6 +1369,21 @@
 
   private void testImportCodeOwnerConfigWithNameExtension(String nameOfImportedCodeOwnerConfig)
       throws Exception {
+    // create imported config with global code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .fileName(nameOfImportedCodeOwnerConfig)
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import
     CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
@@ -1205,22 +1392,9 @@
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.create(
-                    CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY,
-                    "/bar/" + nameOfImportedCodeOwnerConfig))
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with global code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .fileName(nameOfImportedCodeOwnerConfig)
-        .addCodeOwnerEmail(user.email())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
@@ -1231,47 +1405,74 @@
 
     // Expectation: we get the global code owners from the importing and the imported code owner
     // config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void cyclicImports() throws Exception {
+    CodeOwnerConfigReference codeOwnerConfigReference2 =
+        CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/OWNERS");
+
+    // create imported config with global code owner and that imports the importing config
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .addImport(codeOwnerConfigReference2)
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference1 =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
+            .fileName("OWNERS")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference1)
             .create();
 
-    // create imported config with global code owner and that imports the importing config
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .addImport(CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/OWNERS"))
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: we get the global owners from the importing and the imported code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference1),
+            CodeOwnerConfigImport.createResolvedImport(
+                keyOfImportedCodeOwnerConfig,
+                importingCodeOwnerConfigKey,
+                codeOwnerConfigReference2));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -1327,72 +1528,91 @@
 
   @Test
   public void importWithRelativePath() throws Exception {
+    // create imported config with global code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/baz/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import with relative path
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/foo/bar/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "../baz/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with global code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/foo/baz/")
-        .addCodeOwnerEmail(user.email())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: we get the global owners from the importing and the imported code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void importFromNonExistingProjectIsIgnored() throws Exception {
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        CodeOwnerConfig.Key.create(Project.nameKey("non-existing"), "master", "/bar/", "OWNERS");
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import from non-existing project
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.builder(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS")
-                    .setProject(Project.nameKey("non-existing"))
-                    .build())
+            .addImport(codeOwnerConfigReference)
             .create();
 
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: we get the global owners from the importing code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports()).isTrue();
+    assertThat(pathCodeOwnersResult.resolvedImports()).isEmpty();
+    assertThat(pathCodeOwnersResult.unresolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createUnresolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference,
+                String.format("project %s not found", keyOfImportedCodeOwnerConfig.project())));
   }
 
   @Test
@@ -1402,32 +1622,33 @@
     ConfigInput configInput = new ConfigInput();
     configInput.state = ProjectState.HIDDEN;
     gApi.projects().name(hiddenProject.get()).config(configInput);
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(hiddenProject)
-        .branch("master")
-        .folderPath("/")
-        .addCodeOwnerEmail(user.email())
-        .create();
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(hiddenProject)
+            .branch("master")
+            .folderPath("/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
 
     // create importing config with global code owner and import from the hidden project
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.builder(CodeOwnerConfigImportMode.ALL, "/OWNERS")
-                    .setProject(hiddenProject)
-                    .build())
+            .addImport(codeOwnerConfigReference)
             .create();
 
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1435,85 +1656,111 @@
     // Expectation: we get the global owners from the importing code owner config, the global code
     // owners from the imported code owner config are ignored since the project that contains the
     // code owner config is hidden
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports()).isTrue();
+    assertThat(pathCodeOwnersResult.resolvedImports()).isEmpty();
+    assertThat(pathCodeOwnersResult.unresolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createUnresolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference,
+                String.format(
+                    "state of project %s doesn't permit read",
+                    keyOfImportedCodeOwnerConfig.project())));
   }
 
   @Test
   public void importFromNonExistingBranchIsIgnored() throws Exception {
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        CodeOwnerConfig.Key.create(project, "non-existing", "/bar/", "OWNERS");
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import from non-existing branch
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.builder(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS")
-                    .setProject(project)
-                    .setBranch("non-existing")
-                    .build())
+            .addImport(codeOwnerConfigReference)
             .create();
 
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: we get the global owners from the importing code owner config
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
     assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports()).isTrue();
+    assertThat(pathCodeOwnersResult.resolvedImports()).isEmpty();
+    assertThat(pathCodeOwnersResult.unresolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createUnresolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference,
+                "code owner config does not exist (revision = current)"));
   }
 
   @Test
   public void importFromOtherProject() throws Exception {
     Project.NameKey otherProject = projectOperations.newProject().create();
 
+    // create imported config with global code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(otherProject)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import with relative path
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.builder(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS")
-                    .setProject(otherProject)
-                    .build())
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with global code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(otherProject)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: we get the global owners from the importing and the imported code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -1527,43 +1774,52 @@
     // Create other branches in other project.
     createBranch(BranchNameKey.create(otherProject, branchName));
 
+    // create imported config with global code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(otherProject)
+            .branch(branchName)
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        CodeOwnerConfigReference.builder(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS")
+            .setProject(otherProject)
+            .build();
+
     // create importing config with global code owner and import with relative path
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch(branchName)
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.builder(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS")
-                    .setProject(otherProject)
-                    .build())
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with global code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(otherProject)
-        .branch(branchName)
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead(branchName),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: we get the global owners from the importing and the imported code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -1572,44 +1828,50 @@
     String otherBranch = "foo";
     createBranch(BranchNameKey.create(project, otherBranch));
 
+    // create imported config with global code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch(otherBranch)
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import with relative path
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.builder(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS")
-                    .setProject(project)
-                    .setBranch(otherBranch)
-                    .build())
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with global code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch(otherBranch)
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: we get the global owners from the importing and the imported code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -1620,48 +1882,60 @@
     String otherBranch = "foo";
     createBranch(BranchNameKey.create(otherProject, otherBranch));
 
+    // create imported config with global code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(otherProject)
+            .branch(otherBranch)
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // create importing config with global code owner and import with relative path
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.builder(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS")
-                    .setProject(otherProject)
-                    .setBranch(otherBranch)
-                    .build())
+            .addImport(codeOwnerConfigReference)
             .create();
 
-    // create imported config with global code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(otherProject)
-        .branch(otherBranch)
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo/bar/baz.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: we get the global owners from the importing and the imported code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void nonResolveablePerFileImportIsIgnored() throws Exception {
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        CodeOwnerConfig.Key.create(project, "master", "/non-existing/", "OWNERS");
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
+
     // create importing config with non-resolveable per file import
     CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
@@ -1673,10 +1947,7 @@
                 CodeOwnerSet.builder()
                     .addCodeOwnerEmail(admin.email())
                     .addPathExpression("foo.md")
-                    .addImport(
-                        CodeOwnerConfigReference.create(
-                            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY,
-                            "/non-existing/OWNERS"))
+                    .addImport(codeOwnerConfigReference)
                     .build())
             .create();
 
@@ -1690,16 +1961,50 @@
 
     // Expectation: we get the per file code owner from the importing code owner config, the
     // non-resolveable per file import is silently ignored
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports()).isTrue();
+    assertThat(pathCodeOwnersResult.resolvedImports()).isEmpty();
+    assertThat(pathCodeOwnersResult.unresolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createUnresolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference,
+                String.format(
+                    "code owner config does not exist (revision = %s)",
+                    projectOperations
+                        .project(keyOfImportedCodeOwnerConfig.project())
+                        .getHead(keyOfImportedCodeOwnerConfig.branchNameKey().branch())
+                        .name())));
   }
 
   @Test
   public void perFileImport() throws Exception {
     TestAccount user2 = accountCreator.user2();
 
+    // create imported config with ignoreParentCodeOwners = true, a global code owner and a per file
+    // code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .ignoreParentCodeOwners()
+            .addCodeOwnerEmail(user.email())
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .addPathExpression("foo.md")
+                    .addCodeOwnerEmail(user2.email())
+                    .build())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
+
     // create importing config with per code owner and per file import
     CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
@@ -1711,28 +2016,10 @@
                 CodeOwnerSet.builder()
                     .addPathExpression("foo.md")
                     .addCodeOwnerEmail(admin.email())
-                    .addImport(
-                        CodeOwnerConfigReference.create(
-                            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/bar/OWNERS"))
+                    .addImport(codeOwnerConfigReference)
                     .build())
             .create();
 
-    // create imported config with ignoreParentCodeOwners = true, a global code owner and a per file
-    // code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .ignoreParentCodeOwners()
-        .addCodeOwnerEmail(user.email())
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .addPathExpression("foo.md")
-                .addCodeOwnerEmail(user2.email())
-                .build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
@@ -1744,23 +2031,58 @@
     // Expectation: we get the per file code owners from the importing and the global code owner
     // from the imported code owner config, but not the per file code owner from the imported code
     // owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
 
     // Expectation: the ignoreParentCodeOwners flag from the imported code owner config is ignored
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().ignoreParentCodeOwners())
-        .isFalse();
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.ignoreParentCodeOwners()).isFalse();
+
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void importsOfPerFileImportedCodeOwnerConfigAreResolved() throws Exception {
     TestAccount user2 = accountCreator.user2();
 
+    // create config with global code owner that is imported by the imported config
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/baz/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user2.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference2 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig2);
+
+    // create imported config with global code owner and global import
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .addImport(codeOwnerConfigReference2)
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference1 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig1);
+
     // create importing config with per file code owner and per file import
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1770,56 +2092,75 @@
                 CodeOwnerSet.builder()
                     .addPathExpression("foo.md")
                     .addCodeOwnerEmail(admin.email())
-                    .addImport(
-                        CodeOwnerConfigReference.create(
-                            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/bar/OWNERS"))
+                    .addImport(codeOwnerConfigReference1)
                     .build())
             .create();
 
-    // create imported config with global code owner and global import
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .addImport(
-            CodeOwnerConfigReference.create(
-                CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/baz/OWNERS"))
-        .create();
-
-    // create config with global code owner that is imported by the imported config
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/baz/")
-        .addCodeOwnerEmail(user2.email())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
 
     // Expectation: we get the global owners from the importing code owner config, the imported code
     // owner config and the code owner config that is imported by the imported code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email(), user2.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig1,
+                codeOwnerConfigReference1),
+            CodeOwnerConfigImport.createResolvedImport(
+                keyOfImportedCodeOwnerConfig1,
+                keyOfImportedCodeOwnerConfig2,
+                codeOwnerConfigReference2));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void onlyGlobalCodeOwnersAreImportedForTransitivePerFileImports() throws Exception {
     TestAccount user2 = accountCreator.user2();
 
+    // create config with per file code owner that is imported by the imported config
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/baz/")
+            .fileName("OWNERS")
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .addPathExpression("foo.md")
+                    .addCodeOwnerEmail(user2.email())
+                    .build())
+            .create();
+
+    // create imported config with per global owner and global import with mode ALL
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .addImport(
+                createCodeOwnerConfigReference(
+                    CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig2))
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference1 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig1);
+
     // create importing config with per file code owner and per file import
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
@@ -1829,39 +2170,14 @@
                 CodeOwnerSet.builder()
                     .addPathExpression("foo.md")
                     .addCodeOwnerEmail(admin.email())
-                    .addImport(
-                        CodeOwnerConfigReference.create(
-                            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/bar/OWNERS"))
+                    .addImport(codeOwnerConfigReference1)
                     .build())
             .create();
 
-    // create imported config with per global owner and global import with mode ALL
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .addImport(CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/baz/OWNERS"))
-        .create();
-
-    // create config with per file code owner that is imported by the imported config
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/baz/")
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .addPathExpression("foo.md")
-                .addCodeOwnerEmail(user2.email())
-                .build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
@@ -1869,104 +2185,156 @@
     // Expectation: we get the global owners from the importing code owner config and the imported
     // code owner config, but not the per file code owner from the code owner config that is
     // imported by the imported code owner config
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig1,
+                codeOwnerConfigReference1),
+            CodeOwnerConfigImport.createResolvedImport(
+                keyOfImportedCodeOwnerConfig1,
+                keyOfImportedCodeOwnerConfig2,
+                createCodeOwnerConfigReference(
+                    CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY,
+                    keyOfImportedCodeOwnerConfig2)));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
   public void onlyMatchingTransitivePerFileImportsAreImported() throws Exception {
     TestAccount user2 = accountCreator.user2();
 
+    // create config with global code owner that is imported by the imported config for *.md files
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/md/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference2 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig2);
+
+    // create config with global code owner that is imported by the imported config for *.txt files
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig3 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/txt/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user2.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference3 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig3);
+
+    // create imported config with 2 per file imports, one for *.md files and one for *.txt
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .addPathExpression("*.md")
+                    .addImport(codeOwnerConfigReference2)
+                    .build())
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .addPathExpression("*.txt")
+                    .addImport(codeOwnerConfigReference3)
+                    .build())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference1 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig1);
+
     // create importing config with global import
-    CodeOwnerConfig.Key rootCodeOwnerConfigKey =
+    CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
             .newCodeOwnerConfig()
             .project(project)
             .branch("master")
             .folderPath("/")
-            .addImport(
-                CodeOwnerConfigReference.create(
-                    CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference1)
             .create();
 
-    // create imported config with 2 per file imports, one for *.md files and one for *.txt
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .addPathExpression("*.md")
-                .addImport(
-                    CodeOwnerConfigReference.create(
-                        CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/md/OWNERS"))
-                .build())
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .addPathExpression("*.txt")
-                .addImport(
-                    CodeOwnerConfigReference.create(
-                        CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/txt/OWNERS"))
-                .build())
-        .create();
-
-    // create config with global code owner that is imported by the imported config for *.md files
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/md/")
-        .addCodeOwnerEmail(user.email())
-        .create();
-
-    // create config with global code owner that is imported by the imported config for *.txt files
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/txt/")
-        .addCodeOwnerEmail(user2.email())
-        .create();
-
     // Expectation for foo.xyz file: code owners is empty since foo.xyz neither matches *.md nor
     // *.txt
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.xyz"));
     assertThat(pathCodeOwners).isPresent();
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners()).isEmpty();
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners()).isEmpty();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig1,
+                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(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.md"));
     assertThat(pathCodeOwners).isPresent();
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(user.email());
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig1,
+                codeOwnerConfigReference1),
+            CodeOwnerConfigImport.createResolvedImport(
+                keyOfImportedCodeOwnerConfig1,
+                keyOfImportedCodeOwnerConfig2,
+                codeOwnerConfigReference2));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
 
     // Expectation for foo.txt file: code owners contains only user2 since foo.txt only matches
     // *.txt
     pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
-            rootCodeOwnerConfigKey,
+            importingCodeOwnerConfigKey,
             projectOperations.project(project).getHead("master"),
             Paths.get("/foo.txt"));
     assertThat(pathCodeOwners).isPresent();
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(user2.email());
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig1,
+                codeOwnerConfigReference1),
+            CodeOwnerConfigImport.createResolvedImport(
+                keyOfImportedCodeOwnerConfig1,
+                keyOfImportedCodeOwnerConfig3,
+                codeOwnerConfigReference3));
   }
 
   @Test
@@ -2090,6 +2458,20 @@
   @Test
   public void perFileRuleThatIgnoresGlobalCodeOwnersCanImportGlobalCodeOwnersFromOtherFile()
       throws Exception {
+    // create imported config with a global code owner
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
+
     // create importing config that:
     // * has a global code owner
     // * has a per-file import for md files
@@ -2105,21 +2487,10 @@
                 CodeOwnerSet.builder()
                     .addPathExpression(testPathExpressions.matchFileType("md"))
                     .setIgnoreGlobalAndParentCodeOwners()
-                    .addImport(
-                        CodeOwnerConfigReference.create(
-                            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/bar/OWNERS"))
+                    .addImport(codeOwnerConfigReference)
                     .build())
             .create();
 
-    // create imported config with a global code owner
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
@@ -2131,11 +2502,17 @@
     // Expectation: we get the global code owner from the imported code owner config (since it is
     // imported by a matching per-file rule), the global code owner from the importing code owner
     // config is ignored (since the matching per-file rule ignores parent and global code owners)
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(user.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -2146,6 +2523,24 @@
     TestAccount user3 =
         accountCreator.create("user3", "user3@example.com", "User3", /* displayName= */ null);
 
+    // create imported config that has a matching per-file rule
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user2.email())
+            .addCodeOwnerSet(
+                CodeOwnerSet.builder()
+                    .addPathExpression(testPathExpressions.matchFileType("md"))
+                    .addCodeOwnerEmail(user3.email())
+                    .build())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, keyOfImportedCodeOwnerConfig);
+
     // 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 =
@@ -2155,8 +2550,7 @@
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"))
+            .addImport(codeOwnerConfigReference)
             .addCodeOwnerSet(
                 CodeOwnerSet.builder()
                     .addPathExpression(testPathExpressions.matchFileType("md"))
@@ -2165,20 +2559,6 @@
                     .build())
             .create();
 
-    // create imported config that has a matching per-file rule
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(project)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user2.email())
-        .addCodeOwnerSet(
-            CodeOwnerSet.builder()
-                .addPathExpression(testPathExpressions.matchFileType("md"))
-                .addCodeOwnerEmail(user3.email())
-                .build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
@@ -2191,11 +2571,17 @@
     // owner config and the code owner from the matching per-file rule in the imported code owner
     // config, the global code owners are ignored since there is a matching per-file rule that
     // ignores parent and global code owners
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(user.email(), user3.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig,
+                codeOwnerConfigReference));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -2204,6 +2590,35 @@
 
     Project.NameKey otherProject = projectOperations.newProject().create();
 
+    // create transitively imported config in other project
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(otherProject)
+            .branch("master")
+            .folderPath("/baz/")
+            .fileName("OWNERS")
+            .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(user2.email()).build())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference2 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig2);
+
+    // create imported config in other project
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(otherProject)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .addImport(codeOwnerConfigReference2)
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference1 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig1);
+
     // create importing config
     CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
@@ -2212,32 +2627,9 @@
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.builder(
-                        CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "/bar/OWNERS")
-                    .setProject(otherProject)
-                    .build())
+            .addImport(codeOwnerConfigReference1)
             .create();
 
-    // create imported config in other project
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(otherProject)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .addImport(CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/baz/OWNERS"))
-        .create();
-
-    // create transitively imported config in other project
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(otherProject)
-        .branch("master")
-        .folderPath("/baz/")
-        .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(user2.email()).build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
@@ -2248,11 +2640,21 @@
 
     // Expectation: we get the global owners from the importing code owner config and from the
     // directly and transitively imported code owner configs in the other project
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
+    assertThat(pathCodeOwnersResult.getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email(), user2.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig1,
+                codeOwnerConfigReference1),
+            CodeOwnerConfigImport.createResolvedImport(
+                keyOfImportedCodeOwnerConfig1,
+                keyOfImportedCodeOwnerConfig2,
+                codeOwnerConfigReference2));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   @Test
@@ -2261,6 +2663,35 @@
 
     Project.NameKey otherProject = projectOperations.newProject().create();
 
+    // create transitively imported config
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(otherProject)
+            .branch("master")
+            .folderPath("/bar/baz/")
+            .fileName("OWNERS")
+            .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(user2.email()).build())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference2 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig2);
+
+    // create imported config
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(otherProject)
+            .branch("master")
+            .folderPath("/bar/")
+            .fileName("OWNERS")
+            .addCodeOwnerEmail(user.email())
+            .addImport(codeOwnerConfigReference2)
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference1 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig1);
+
     // create importing config
     CodeOwnerConfig.Key importingCodeOwnerConfigKey =
         codeOwnerConfigOperations
@@ -2269,32 +2700,9 @@
             .branch("master")
             .folderPath("/")
             .addCodeOwnerEmail(admin.email())
-            .addImport(
-                CodeOwnerConfigReference.builder(
-                        CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, "bar/OWNERS")
-                    .setProject(otherProject)
-                    .build())
+            .addImport(codeOwnerConfigReference1)
             .create();
 
-    // create imported config
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(otherProject)
-        .branch("master")
-        .folderPath("/bar/")
-        .addCodeOwnerEmail(user.email())
-        .addImport(CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "baz/OWNERS"))
-        .create();
-
-    // create transitively imported config
-    codeOwnerConfigOperations
-        .newCodeOwnerConfig()
-        .project(otherProject)
-        .branch("master")
-        .folderPath("/bar/baz/")
-        .addCodeOwnerSet(CodeOwnerSet.builder().addCodeOwnerEmail(user2.email()).build())
-        .create();
-
     Optional<PathCodeOwners> pathCodeOwners =
         pathCodeOwnersFactory.create(
             transientCodeOwnerConfigCacheProvider.get(),
@@ -2305,11 +2713,21 @@
 
     // Expectation: we get the global owners from the importing code owner config and from the
     // directly and transitively imported code owner configs
+    PathCodeOwnersResult pathCodeOwnersResult = pathCodeOwners.get().resolveCodeOwnerConfig().get();
     assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().getPathCodeOwners())
         .comparingElementsUsing(hasEmail())
         .containsExactly(admin.email(), user.email(), user2.email());
-    assertThat(pathCodeOwners.get().resolveCodeOwnerConfig().get().hasUnresolvedImports())
-        .isFalse();
+    assertThat(pathCodeOwnersResult.resolvedImports())
+        .containsExactly(
+            CodeOwnerConfigImport.createResolvedImport(
+                importingCodeOwnerConfigKey,
+                keyOfImportedCodeOwnerConfig1,
+                codeOwnerConfigReference1),
+            CodeOwnerConfigImport.createResolvedImport(
+                keyOfImportedCodeOwnerConfig1,
+                keyOfImportedCodeOwnerConfig2,
+                codeOwnerConfigReference2));
+    assertThat(pathCodeOwnersResult.unresolvedImports()).isEmpty();
   }
 
   private CodeOwnerConfig.Builder createCodeOwnerBuilder() {
diff --git a/javatests/com/google/gerrit/plugins/codeowners/backend/UnresolvedImportTest.java b/javatests/com/google/gerrit/plugins/codeowners/backend/UnresolvedImportTest.java
deleted file mode 100644
index ce0494f..0000000
--- a/javatests/com/google/gerrit/plugins/codeowners/backend/UnresolvedImportTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (C) 2021 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package com.google.gerrit.plugins.codeowners.backend;
-
-import org.junit.Test;
-
-/** Tests for {@link UnresolvedImport}. */
-public class UnresolvedImportTest extends AbstractAutoValueTest {
-  @Test
-  public void toStringIncludesAllData() throws Exception {
-    UnresolvedImport unresolvedImport =
-        UnresolvedImport.create(
-            CodeOwnerConfig.Key.create(project, "master", "/"),
-            CodeOwnerConfig.Key.create(project, "master", "/bar/"),
-            CodeOwnerConfigReference.create(CodeOwnerConfigImportMode.ALL, "/bar/OWNERS"),
-            "test message");
-    assertThatToStringIncludesAllData(unresolvedImport, UnresolvedImport.class);
-  }
-}
diff --git a/javatests/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJsonIT.java b/javatests/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJsonIT.java
new file mode 100644
index 0000000..ed0b301
--- /dev/null
+++ b/javatests/com/google/gerrit/plugins/codeowners/restapi/CodeOwnerConfigFileJsonIT.java
@@ -0,0 +1,388 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.gerrit.plugins.codeowners.restapi;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.gerrit.testing.GerritJUnit.assertThrows;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.gerrit.entities.Project;
+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 org.junit.Before;
+import org.junit.Test;
+
+/** Tests for {@link CodeOwnerConfigFileJson}. */
+public class CodeOwnerConfigFileJsonIT extends AbstractCodeOwnersIT {
+  private CodeOwnerConfigFileJson CodeOwnerConfigFileJson;
+
+  @Before
+  public void setUpCodeOwnersPlugin() throws Exception {
+    CodeOwnerConfigFileJson = plugin.getSysInjector().getInstance(CodeOwnerConfigFileJson.class);
+  }
+
+  @Test
+  public void cannotFormatWithNullCodeOwnerConfigKey() throws Exception {
+    NullPointerException npe =
+        assertThrows(
+            NullPointerException.class,
+            () ->
+                CodeOwnerConfigFileJson.format(
+                    /* codeOwnerConfigKey= */ null,
+                    /* resolvedImports= */ ImmutableList.of(),
+                    /* unresolvedImports= */ ImmutableList.of()));
+    assertThat(npe).hasMessageThat().isEqualTo("codeOwnerConfigKey");
+  }
+
+  @Test
+  public void cannotFormatWithNullResolvedImports() throws Exception {
+    CodeOwnerConfig.Key codeOwnerConfigKey =
+        CodeOwnerConfig.Key.create(Project.nameKey("project"), "master", "/");
+    NullPointerException npe =
+        assertThrows(
+            NullPointerException.class,
+            () ->
+                CodeOwnerConfigFileJson.format(
+                    codeOwnerConfigKey,
+                    /* resolvedImports= */ null,
+                    /* unresolvedImports= */ ImmutableList.of()));
+    assertThat(npe).hasMessageThat().isEqualTo("resolvedImports");
+  }
+
+  @Test
+  public void cannotFormatWithNullUnresolvedImports() throws Exception {
+    CodeOwnerConfig.Key codeOwnerConfigKey =
+        CodeOwnerConfig.Key.create(Project.nameKey("project"), "master", "/");
+    NullPointerException npe =
+        assertThrows(
+            NullPointerException.class,
+            () ->
+                CodeOwnerConfigFileJson.format(
+                    codeOwnerConfigKey,
+                    /* resolvedImports= */ ImmutableList.of(),
+                    /* unresolvedImports= */ null));
+    assertThat(npe).hasMessageThat().isEqualTo("unresolvedImports");
+  }
+
+  @Test
+  public void formatWithoutImports() throws Exception {
+    CodeOwnerConfig.Key codeOwnerConfigKey =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/baz/")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+
+    CodeOwnerConfigFileInfo codeOwnerConfigFileInfo =
+        CodeOwnerConfigFileJson.format(
+            codeOwnerConfigKey,
+            /* resolvedImports= */ ImmutableList.of(),
+            /* unresolvedImports= */ ImmutableList.of());
+    assertThat(codeOwnerConfigFileInfo.project).isEqualTo(codeOwnerConfigKey.project().get());
+    assertThat(codeOwnerConfigFileInfo.branch)
+        .isEqualTo(codeOwnerConfigKey.branchNameKey().branch());
+    assertThat(codeOwnerConfigFileInfo.path)
+        .isEqualTo(codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).getFilePath());
+    assertThat(codeOwnerConfigFileInfo.importMode).isNull();
+    assertThat(codeOwnerConfigFileInfo.imports).isNull();
+    assertThat(codeOwnerConfigFileInfo.unresolvedImports).isNull();
+    assertThat(codeOwnerConfigFileInfo.unresolvedErrorMessage).isNull();
+  }
+
+  @Test
+  public void formatWithUnresolvedImports() throws Exception {
+    CodeOwnerConfig.Key codeOwnerConfigKey =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        CodeOwnerConfig.Key.create(project, "stable", "/foo/baz/");
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
+
+    CodeOwnerConfigFileInfo codeOwnerConfigFileInfo =
+        CodeOwnerConfigFileJson.format(
+            codeOwnerConfigKey,
+            /* resolvedImports= */ ImmutableList.of(),
+            /* unresolvedImports= */ ImmutableList.of(
+                CodeOwnerConfigImport.createUnresolvedImport(
+                    codeOwnerConfigKey,
+                    keyOfImportedCodeOwnerConfig,
+                    codeOwnerConfigReference,
+                    "error message")));
+    assertThat(codeOwnerConfigFileInfo.project).isEqualTo(codeOwnerConfigKey.project().get());
+    assertThat(codeOwnerConfigFileInfo.branch)
+        .isEqualTo(codeOwnerConfigKey.branchNameKey().branch());
+    assertThat(codeOwnerConfigFileInfo.path)
+        .isEqualTo(codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).getFilePath());
+    assertThat(codeOwnerConfigFileInfo.importMode).isNull();
+    assertThat(codeOwnerConfigFileInfo.imports).isNull();
+    assertThat(codeOwnerConfigFileInfo.unresolvedErrorMessage).isNull();
+
+    assertThat(codeOwnerConfigFileInfo.unresolvedImports).hasSize(1);
+    CodeOwnerConfigFileInfo unresolvedImportInfo =
+        Iterables.getOnlyElement(codeOwnerConfigFileInfo.unresolvedImports);
+    assertThat(unresolvedImportInfo.project)
+        .isEqualTo(keyOfImportedCodeOwnerConfig.project().get());
+    assertThat(unresolvedImportInfo.branch)
+        .isEqualTo(keyOfImportedCodeOwnerConfig.branchNameKey().branch());
+    assertThat(unresolvedImportInfo.path)
+        .isEqualTo(
+            codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).getFilePath());
+    assertThat(unresolvedImportInfo.importMode).isEqualTo(codeOwnerConfigReference.importMode());
+    assertThat(unresolvedImportInfo.imports).isNull();
+    assertThat(unresolvedImportInfo.unresolvedImports).isNull();
+    assertThat(unresolvedImportInfo.unresolvedErrorMessage).isEqualTo("error message");
+  }
+
+  @Test
+  public void formatWithImports() throws Exception {
+    CodeOwnerConfig.Key codeOwnerConfigKey =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        CodeOwnerConfig.Key.create(project, "stable", "/foo/baz/");
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
+
+    CodeOwnerConfigFileInfo codeOwnerConfigFileInfo =
+        CodeOwnerConfigFileJson.format(
+            codeOwnerConfigKey,
+            /* resolvedImports= */ ImmutableList.of(
+                CodeOwnerConfigImport.createResolvedImport(
+                    codeOwnerConfigKey, keyOfImportedCodeOwnerConfig, codeOwnerConfigReference)),
+            /* unresolvedImports= */ ImmutableList.of());
+    assertThat(codeOwnerConfigFileInfo.project).isEqualTo(codeOwnerConfigKey.project().get());
+    assertThat(codeOwnerConfigFileInfo.branch)
+        .isEqualTo(codeOwnerConfigKey.branchNameKey().branch());
+    assertThat(codeOwnerConfigFileInfo.path)
+        .isEqualTo(codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).getFilePath());
+    assertThat(codeOwnerConfigFileInfo.importMode).isNull();
+    assertThat(codeOwnerConfigFileInfo.unresolvedImports).isNull();
+    assertThat(codeOwnerConfigFileInfo.unresolvedErrorMessage).isNull();
+
+    assertThat(codeOwnerConfigFileInfo.imports).hasSize(1);
+    CodeOwnerConfigFileInfo resolvedImportInfo =
+        Iterables.getOnlyElement(codeOwnerConfigFileInfo.imports);
+    assertThat(resolvedImportInfo.project).isEqualTo(keyOfImportedCodeOwnerConfig.project().get());
+    assertThat(resolvedImportInfo.branch)
+        .isEqualTo(keyOfImportedCodeOwnerConfig.branchNameKey().branch());
+    assertThat(resolvedImportInfo.path)
+        .isEqualTo(
+            codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).getFilePath());
+    assertThat(resolvedImportInfo.importMode).isEqualTo(codeOwnerConfigReference.importMode());
+    assertThat(resolvedImportInfo.imports).isNull();
+    assertThat(resolvedImportInfo.unresolvedImports).isNull();
+    assertThat(resolvedImportInfo.unresolvedErrorMessage).isNull();
+  }
+
+  @Test
+  public void formatWithNestedImports() throws Exception {
+    CodeOwnerConfig.Key codeOwnerConfigKey =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+
+    CodeOwnerConfig.Key keyOfImportedCodeOwnerConfig =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/baz")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY, keyOfImportedCodeOwnerConfig);
+
+    CodeOwnerConfig.Key keyOfNestedImportedCodeOwnerConfig1 =
+        CodeOwnerConfig.Key.create(project, "stable", "/foo/baz1/");
+    CodeOwnerConfigReference nestedCodeOwnerConfigReference1 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.GLOBAL_CODE_OWNER_SETS_ONLY,
+            keyOfNestedImportedCodeOwnerConfig1);
+
+    CodeOwnerConfig.Key keyOfNestedImportedCodeOwnerConfig2 =
+        CodeOwnerConfig.Key.create(project, "stable", "/foo/baz2/");
+    CodeOwnerConfigReference nestedCodeOwnerConfigReference2 =
+        createCodeOwnerConfigReference(
+            CodeOwnerConfigImportMode.ALL, keyOfNestedImportedCodeOwnerConfig2);
+
+    CodeOwnerConfigFileInfo codeOwnerConfigFileInfo =
+        CodeOwnerConfigFileJson.format(
+            codeOwnerConfigKey,
+            /* resolvedImports= */ ImmutableList.of(
+                CodeOwnerConfigImport.createResolvedImport(
+                    codeOwnerConfigKey, keyOfImportedCodeOwnerConfig, codeOwnerConfigReference),
+                CodeOwnerConfigImport.createResolvedImport(
+                    keyOfImportedCodeOwnerConfig,
+                    keyOfNestedImportedCodeOwnerConfig1,
+                    nestedCodeOwnerConfigReference1)),
+            /* unresolvedImports= */ ImmutableList.of(
+                CodeOwnerConfigImport.createUnresolvedImport(
+                    keyOfImportedCodeOwnerConfig,
+                    keyOfNestedImportedCodeOwnerConfig2,
+                    nestedCodeOwnerConfigReference2,
+                    "error message")));
+    assertThat(codeOwnerConfigFileInfo.project).isEqualTo(codeOwnerConfigKey.project().get());
+    assertThat(codeOwnerConfigFileInfo.branch)
+        .isEqualTo(codeOwnerConfigKey.branchNameKey().branch());
+    assertThat(codeOwnerConfigFileInfo.path)
+        .isEqualTo(codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey).getFilePath());
+    assertThat(codeOwnerConfigFileInfo.importMode).isNull();
+    assertThat(codeOwnerConfigFileInfo.unresolvedImports).isNull();
+    assertThat(codeOwnerConfigFileInfo.unresolvedErrorMessage).isNull();
+
+    assertThat(codeOwnerConfigFileInfo.imports).hasSize(1);
+    CodeOwnerConfigFileInfo resolvedImportInfo =
+        Iterables.getOnlyElement(codeOwnerConfigFileInfo.imports);
+    assertThat(resolvedImportInfo.project).isEqualTo(keyOfImportedCodeOwnerConfig.project().get());
+    assertThat(resolvedImportInfo.branch)
+        .isEqualTo(keyOfImportedCodeOwnerConfig.branchNameKey().branch());
+    assertThat(resolvedImportInfo.path)
+        .isEqualTo(
+            codeOwnerConfigOperations.codeOwnerConfig(keyOfImportedCodeOwnerConfig).getFilePath());
+    assertThat(resolvedImportInfo.importMode).isEqualTo(codeOwnerConfigReference.importMode());
+    assertThat(resolvedImportInfo.unresolvedErrorMessage).isNull();
+
+    assertThat(resolvedImportInfo.imports).hasSize(1);
+    CodeOwnerConfigFileInfo nestedResolvedImportInfo =
+        Iterables.getOnlyElement(resolvedImportInfo.imports);
+    assertThat(nestedResolvedImportInfo.project)
+        .isEqualTo(keyOfNestedImportedCodeOwnerConfig1.project().get());
+    assertThat(nestedResolvedImportInfo.branch)
+        .isEqualTo(keyOfNestedImportedCodeOwnerConfig1.branchNameKey().branch());
+    assertThat(nestedResolvedImportInfo.path)
+        .isEqualTo(
+            codeOwnerConfigOperations
+                .codeOwnerConfig(keyOfNestedImportedCodeOwnerConfig1)
+                .getFilePath());
+    assertThat(nestedResolvedImportInfo.importMode)
+        .isEqualTo(nestedCodeOwnerConfigReference1.importMode());
+    assertThat(nestedResolvedImportInfo.imports).isNull();
+    assertThat(nestedResolvedImportInfo.unresolvedImports).isNull();
+    assertThat(nestedResolvedImportInfo.unresolvedErrorMessage).isNull();
+
+    assertThat(resolvedImportInfo.unresolvedImports).hasSize(1);
+    CodeOwnerConfigFileInfo nestedUnresolvedImportInfo1 =
+        Iterables.getOnlyElement(resolvedImportInfo.unresolvedImports);
+    assertThat(nestedUnresolvedImportInfo1.project)
+        .isEqualTo(keyOfNestedImportedCodeOwnerConfig2.project().get());
+    assertThat(nestedUnresolvedImportInfo1.branch)
+        .isEqualTo(keyOfNestedImportedCodeOwnerConfig2.branchNameKey().branch());
+    assertThat(nestedUnresolvedImportInfo1.path)
+        .isEqualTo(
+            codeOwnerConfigOperations
+                .codeOwnerConfig(keyOfNestedImportedCodeOwnerConfig2)
+                .getFilePath());
+    assertThat(nestedUnresolvedImportInfo1.importMode)
+        .isEqualTo(nestedCodeOwnerConfigReference2.importMode());
+    assertThat(nestedUnresolvedImportInfo1.imports).isNull();
+    assertThat(nestedUnresolvedImportInfo1.unresolvedImports).isNull();
+    assertThat(nestedUnresolvedImportInfo1.unresolvedErrorMessage).isEqualTo("error message");
+  }
+
+  @Test
+  public void formatWithCyclicImports() throws Exception {
+    CodeOwnerConfig.Key codeOwnerConfigKey1 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference1 =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, codeOwnerConfigKey1);
+
+    CodeOwnerConfig.Key codeOwnerConfigKey2 =
+        codeOwnerConfigOperations
+            .newCodeOwnerConfig()
+            .project(project)
+            .branch("master")
+            .folderPath("/foo/bar/baz")
+            .addCodeOwnerEmail(admin.email())
+            .create();
+    CodeOwnerConfigReference codeOwnerConfigReference2 =
+        createCodeOwnerConfigReference(CodeOwnerConfigImportMode.ALL, codeOwnerConfigKey2);
+
+    CodeOwnerConfigFileInfo codeOwnerConfigFileInfo =
+        CodeOwnerConfigFileJson.format(
+            codeOwnerConfigKey1,
+            /* resolvedImports= */ ImmutableList.of(
+                CodeOwnerConfigImport.createResolvedImport(
+                    codeOwnerConfigKey1, codeOwnerConfigKey2, codeOwnerConfigReference1),
+                CodeOwnerConfigImport.createResolvedImport(
+                    codeOwnerConfigKey2, codeOwnerConfigKey1, codeOwnerConfigReference2)),
+            /* unresolvedImports= */ ImmutableList.of());
+
+    assertThat(codeOwnerConfigFileInfo.project).isEqualTo(codeOwnerConfigKey1.project().get());
+    assertThat(codeOwnerConfigFileInfo.branch)
+        .isEqualTo(codeOwnerConfigKey1.branchNameKey().branch());
+    assertThat(codeOwnerConfigFileInfo.path)
+        .isEqualTo(codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey1).getFilePath());
+    assertThat(codeOwnerConfigFileInfo.importMode).isNull();
+    assertThat(codeOwnerConfigFileInfo.unresolvedImports).isNull();
+    assertThat(codeOwnerConfigFileInfo.unresolvedErrorMessage).isNull();
+
+    assertThat(codeOwnerConfigFileInfo.imports).hasSize(1);
+    CodeOwnerConfigFileInfo resolvedImportInfo =
+        Iterables.getOnlyElement(codeOwnerConfigFileInfo.imports);
+    assertThat(resolvedImportInfo.project).isEqualTo(codeOwnerConfigKey2.project().get());
+    assertThat(resolvedImportInfo.branch).isEqualTo(codeOwnerConfigKey2.branchNameKey().branch());
+    assertThat(resolvedImportInfo.path)
+        .isEqualTo(codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey2).getFilePath());
+    assertThat(resolvedImportInfo.importMode).isEqualTo(codeOwnerConfigReference1.importMode());
+    assertThat(resolvedImportInfo.unresolvedErrorMessage).isNull();
+
+    assertThat(resolvedImportInfo.imports).hasSize(1);
+    CodeOwnerConfigFileInfo nestedResolvedImportInfo =
+        Iterables.getOnlyElement(resolvedImportInfo.imports);
+    assertThat(nestedResolvedImportInfo.project).isEqualTo(codeOwnerConfigKey1.project().get());
+    assertThat(nestedResolvedImportInfo.branch)
+        .isEqualTo(codeOwnerConfigKey1.branchNameKey().branch());
+    assertThat(nestedResolvedImportInfo.path)
+        .isEqualTo(codeOwnerConfigOperations.codeOwnerConfig(codeOwnerConfigKey1).getFilePath());
+    assertThat(nestedResolvedImportInfo.importMode)
+        .isEqualTo(codeOwnerConfigReference1.importMode());
+    assertThat(nestedResolvedImportInfo.imports).isNull();
+    assertThat(nestedResolvedImportInfo.unresolvedImports).isNull();
+    assertThat(nestedResolvedImportInfo.unresolvedErrorMessage).isNull();
+  }
+}
diff --git a/resources/Documentation/rest-api.md b/resources/Documentation/rest-api.md
index 04e8ffd..c97ba2c 100644
--- a/resources/Documentation/rest-api.md
+++ b/resources/Documentation/rest-api.md
@@ -499,7 +499,42 @@
       {
         "account": {
           "_account_id": 1001439
-        },
+        }
+      },
+      {
+        "account": {
+          "_account_id": 1007265
+        }
+      },
+      {
+        "account": {
+          "_account_id": 1009877
+        }
+      },
+      {
+        "account": {
+          "_account_id": 1002930
+        }
+      }
+    ],
+    "code_owner_configs": [
+      {
+        "project": "foo/bar",
+        "branch": "master",
+        "path": "/docs/OWNERS"
+      },
+      {
+        "project": "foo/bar",
+        "branch": "master",
+        "path": "/OWNERS",
+        "imports": [
+          {
+            "project": "foo",
+            "branch": "master",
+            "path": "/OWNERS",
+            "import_mode": "ALL",
+          }
+        ]
       }
     ]
   }
@@ -918,6 +953,22 @@
 
 ---
 
+### <a id="code-owner-config-file-info"> CodeOwnerConfigFileInfo
+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.
+| `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.
+| `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.
+
+---
+
 ### <a id="code-owner-config-info"> CodeOwnerConfigInfo
 The `CodeOwnerConfigInfo` entity contains information about a code owner config
 for a path.
@@ -1042,6 +1093,7 @@
 | ------------- | -------- | ----------- |
 | `code_owners` |          | List of code owners as [CodeOwnerInfo](#code-owner-info) entities. The code owners are sorted by a score that is computed from mutliple [scoring factors](#scoringFactors).
 | `owned_by_all_users` | optional | Whether the path is owned by all users. Not set if `false`.
+| `code_owner_configs` || The code owner config files that have been inspected to gather the code owners as [CodeOwnerConfigFileInfo](#code-owner-config-file-info) entities.
 | `debug_logs`  | optional | Debug logs that may help to understand why a user is or isn't suggested as a code owner. Only set if requested via `--debug`. This information is purely for debugging and the output may be changed at any time. This means bot callers must not parse the debug logs.
 
 ### <a id="file-code-owner-status-info"> FileCodeOwnerStatusInfo