diff --git a/extensions/ql-vscode/src/query-history/store/query-history-domain-mapper.ts b/extensions/ql-vscode/src/query-history/store/query-history-domain-mapper.ts
index 05579f224ad..3c1239dac77 100644
--- a/extensions/ql-vscode/src/query-history/store/query-history-domain-mapper.ts
+++ b/extensions/ql-vscode/src/query-history/store/query-history-domain-mapper.ts
@@ -15,20 +15,19 @@ import {
   SortDirectionDto,
 } from "./query-history-local-query-dto";
 import { QueryHistoryItemDto } from "./query-history-dto";
-import { QueryHistoryVariantAnalysisDto } from "./query-history-variant-analysis-dto";
 import {
   RawResultsSortState,
   SortDirection,
   SortedResultSetInfo,
 } from "../../pure/interface-types";
+import { mapQueryHistoryVariantAnalysisToDto } from "./query-history-variant-analysis-domain-mapper";
 
 export function mapQueryHistoryToDto(
   queries: QueryHistoryInfo[],
 ): QueryHistoryItemDto[] {
   return queries.map((q) => {
     if (q.t === "variant-analysis") {
-      const query: QueryHistoryVariantAnalysisDto = q;
-      return query;
+      return mapQueryHistoryVariantAnalysisToDto(q);
     } else if (q.t === "local") {
       return mapLocalQueryInfoToDto(q);
     } else {
diff --git a/extensions/ql-vscode/src/query-history/store/query-history-dto-mapper.ts b/extensions/ql-vscode/src/query-history/store/query-history-dto-mapper.ts
index 22bbdf6baaa..a2f915d2c87 100644
--- a/extensions/ql-vscode/src/query-history/store/query-history-dto-mapper.ts
+++ b/extensions/ql-vscode/src/query-history/store/query-history-dto-mapper.ts
@@ -5,7 +5,6 @@ import {
 } from "../../query-results";
 import { QueryEvaluationInfo } from "../../run-queries-shared";
 import { QueryHistoryInfo } from "../query-history-info";
-import { VariantAnalysisHistoryItem } from "../variant-analysis-history-item";
 import {
   CompletedQueryInfoDto,
   QueryEvaluationInfoDto,
@@ -23,14 +22,14 @@ import {
   SortDirection,
   SortedResultSetInfo,
 } from "../../pure/interface-types";
+import { mapQueryHistoryVariantAnalysisToDomainModel } from "./query-history-variant-analysis-dto-mapper";
 
 export function mapQueryHistoryToDomainModel(
   queries: QueryHistoryItemDto[],
 ): QueryHistoryInfo[] {
   return queries.map((d) => {
     if (d.t === "variant-analysis") {
-      const query: VariantAnalysisHistoryItem = d;
-      return query;
+      return mapQueryHistoryVariantAnalysisToDomainModel(d);
     } else if (d.t === "local") {
       return mapLocalQueryItemToDomainModel(d);
     }
diff --git a/extensions/ql-vscode/src/query-history/store/query-history-variant-analysis-domain-mapper.ts b/extensions/ql-vscode/src/query-history/store/query-history-variant-analysis-domain-mapper.ts
new file mode 100644
index 00000000000..24b22582bf3
--- /dev/null
+++ b/extensions/ql-vscode/src/query-history/store/query-history-variant-analysis-domain-mapper.ts
@@ -0,0 +1,235 @@
+import {
+  QueryHistoryVariantAnalysisDto,
+  QueryLanguageDto,
+  QueryStatusDto,
+  VariantAnalysisDto,
+  VariantAnalysisFailureReasonDto,
+  VariantAnalysisRepoStatusDto,
+  VariantAnalysisScannedRepositoryDto,
+  VariantAnalysisSkippedRepositoriesDto,
+  VariantAnalysisSkippedRepositoryDto,
+  VariantAnalysisSkippedRepositoryGroupDto,
+  VariantAnalysisStatusDto,
+} from "./query-history-variant-analysis-dto";
+import {
+  VariantAnalysis,
+  VariantAnalysisFailureReason,
+  VariantAnalysisRepoStatus,
+  VariantAnalysisScannedRepository,
+  VariantAnalysisSkippedRepositories,
+  VariantAnalysisSkippedRepository,
+  VariantAnalysisSkippedRepositoryGroup,
+  VariantAnalysisStatus,
+} from "../../variant-analysis/shared/variant-analysis";
+import { assertNever } from "../../pure/helpers-pure";
+import { QueryLanguage } from "../../common/query-language";
+import { QueryStatus } from "../../query-status";
+import { VariantAnalysisHistoryItem } from "../variant-analysis-history-item";
+
+export function mapQueryHistoryVariantAnalysisToDto(
+  item: VariantAnalysisHistoryItem,
+): QueryHistoryVariantAnalysisDto {
+  return {
+    t: "variant-analysis",
+    failureReason: item.failureReason,
+    resultCount: item.resultCount,
+    status: mapQueryStatusToDto(item.status),
+    completed: item.completed,
+    variantAnalysis: mapVariantAnalysisDtoToDto(item.variantAnalysis),
+    userSpecifiedLabel: item.userSpecifiedLabel,
+  };
+}
+
+function mapVariantAnalysisDtoToDto(
+  variantAnalysis: VariantAnalysis,
+): VariantAnalysisDto {
+  return {
+    id: variantAnalysis.id,
+    controllerRepo: {
+      id: variantAnalysis.controllerRepo.id,
+      fullName: variantAnalysis.controllerRepo.fullName,
+      private: variantAnalysis.controllerRepo.private,
+    },
+    query: {
+      name: variantAnalysis.query.name,
+      filePath: variantAnalysis.query.filePath,
+      language: mapQueryLanguageToDto(variantAnalysis.query.language),
+      text: variantAnalysis.query.text,
+    },
+    databases: {
+      repositories: variantAnalysis.databases.repositories,
+      repositoryLists: variantAnalysis.databases.repositoryLists,
+      repositoryOwners: variantAnalysis.databases.repositoryOwners,
+    },
+    createdAt: variantAnalysis.createdAt,
+    updatedAt: variantAnalysis.updatedAt,
+    executionStartTime: variantAnalysis.executionStartTime,
+    status: mapVariantAnalysisStatusToDto(variantAnalysis.status),
+    completedAt: variantAnalysis.completedAt,
+    actionsWorkflowRunId: variantAnalysis.actionsWorkflowRunId,
+    failureReason:
+      variantAnalysis.failureReason &&
+      mapVariantAnalysisFailureReasonToDto(variantAnalysis.failureReason),
+    scannedRepos:
+      variantAnalysis.scannedRepos &&
+      mapVariantAnalysisScannedRepositoriesToDto(variantAnalysis.scannedRepos),
+    skippedRepos:
+      variantAnalysis.skippedRepos &&
+      mapVariantAnalysisSkippedRepositoriesToDto(variantAnalysis.skippedRepos),
+  };
+}
+
+function mapVariantAnalysisScannedRepositoriesToDto(
+  repos: VariantAnalysisScannedRepository[],
+): VariantAnalysisScannedRepositoryDto[] {
+  return repos.map(mapVariantAnalysisScannedRepositoryToDto);
+}
+
+function mapVariantAnalysisScannedRepositoryToDto(
+  repo: VariantAnalysisScannedRepository,
+): VariantAnalysisScannedRepositoryDto {
+  return {
+    repository: {
+      id: repo.repository.id,
+      fullName: repo.repository.fullName,
+      private: repo.repository.private,
+      stargazersCount: repo.repository.stargazersCount,
+      updatedAt: repo.repository.updatedAt,
+    },
+    analysisStatus: mapVariantAnalysisRepoStatusToDto(repo.analysisStatus),
+    resultCount: repo.resultCount,
+    artifactSizeInBytes: repo.artifactSizeInBytes,
+    failureMessage: repo.failureMessage,
+  };
+}
+
+function mapVariantAnalysisSkippedRepositoriesToDto(
+  repos: VariantAnalysisSkippedRepositories,
+): VariantAnalysisSkippedRepositoriesDto {
+  return {
+    accessMismatchRepos:
+      repos.accessMismatchRepos &&
+      mapVariantAnalysisSkippedRepositoryGroupToDto(repos.accessMismatchRepos),
+    notFoundRepos:
+      repos.notFoundRepos &&
+      mapVariantAnalysisSkippedRepositoryGroupToDto(repos.notFoundRepos),
+    noCodeqlDbRepos:
+      repos.noCodeqlDbRepos &&
+      mapVariantAnalysisSkippedRepositoryGroupToDto(repos.noCodeqlDbRepos),
+    overLimitRepos:
+      repos.overLimitRepos &&
+      mapVariantAnalysisSkippedRepositoryGroupToDto(repos.overLimitRepos),
+  };
+}
+
+function mapVariantAnalysisSkippedRepositoryGroupToDto(
+  repoGroup: VariantAnalysisSkippedRepositoryGroup,
+): VariantAnalysisSkippedRepositoryGroupDto {
+  return {
+    repositoryCount: repoGroup.repositoryCount,
+    repositories: repoGroup.repositories.map(
+      mapVariantAnalysisSkippedRepositoryToDto,
+    ),
+  };
+}
+
+function mapVariantAnalysisSkippedRepositoryToDto(
+  repo: VariantAnalysisSkippedRepository,
+): VariantAnalysisSkippedRepositoryDto {
+  return {
+    id: repo.id,
+    fullName: repo.fullName,
+    private: repo.private,
+    stargazersCount: repo.stargazersCount,
+    updatedAt: repo.updatedAt,
+  };
+}
+
+function mapVariantAnalysisFailureReasonToDto(
+  failureReason: VariantAnalysisFailureReason,
+): VariantAnalysisFailureReasonDto {
+  switch (failureReason) {
+    case VariantAnalysisFailureReason.NoReposQueried:
+      return VariantAnalysisFailureReasonDto.NoReposQueried;
+    case VariantAnalysisFailureReason.ActionsWorkflowRunFailed:
+      return VariantAnalysisFailureReasonDto.ActionsWorkflowRunFailed;
+    case VariantAnalysisFailureReason.InternalError:
+      return VariantAnalysisFailureReasonDto.InternalError;
+    default:
+      assertNever(failureReason);
+  }
+}
+
+function mapVariantAnalysisRepoStatusToDto(
+  status: VariantAnalysisRepoStatus,
+): VariantAnalysisRepoStatusDto {
+  switch (status) {
+    case VariantAnalysisRepoStatus.Pending:
+      return VariantAnalysisRepoStatusDto.Pending;
+    case VariantAnalysisRepoStatus.InProgress:
+      return VariantAnalysisRepoStatusDto.InProgress;
+    case VariantAnalysisRepoStatus.Succeeded:
+      return VariantAnalysisRepoStatusDto.Succeeded;
+    case VariantAnalysisRepoStatus.Failed:
+      return VariantAnalysisRepoStatusDto.Failed;
+    case VariantAnalysisRepoStatus.Canceled:
+      return VariantAnalysisRepoStatusDto.Canceled;
+    case VariantAnalysisRepoStatus.TimedOut:
+      return VariantAnalysisRepoStatusDto.TimedOut;
+    default:
+      assertNever(status);
+  }
+}
+
+function mapVariantAnalysisStatusToDto(
+  status: VariantAnalysisStatus,
+): VariantAnalysisStatusDto {
+  switch (status) {
+    case VariantAnalysisStatus.InProgress:
+      return VariantAnalysisStatusDto.InProgress;
+    case VariantAnalysisStatus.Succeeded:
+      return VariantAnalysisStatusDto.Succeeded;
+    case VariantAnalysisStatus.Failed:
+      return VariantAnalysisStatusDto.Failed;
+    case VariantAnalysisStatus.Canceled:
+      return VariantAnalysisStatusDto.Canceled;
+    default:
+      assertNever(status);
+  }
+}
+
+function mapQueryLanguageToDto(language: QueryLanguage): QueryLanguageDto {
+  switch (language) {
+    case QueryLanguage.CSharp:
+      return QueryLanguageDto.CSharp;
+    case QueryLanguage.Cpp:
+      return QueryLanguageDto.Cpp;
+    case QueryLanguage.Go:
+      return QueryLanguageDto.Go;
+    case QueryLanguage.Java:
+      return QueryLanguageDto.Java;
+    case QueryLanguage.Javascript:
+      return QueryLanguageDto.Javascript;
+    case QueryLanguage.Python:
+      return QueryLanguageDto.Python;
+    case QueryLanguage.Ruby:
+      return QueryLanguageDto.Ruby;
+    case QueryLanguage.Swift:
+      return QueryLanguageDto.Swift;
+    default:
+      assertNever(language);
+  }
+}
+
+function mapQueryStatusToDto(status: QueryStatus): QueryStatusDto {
+  switch (status) {
+    case QueryStatus.InProgress:
+      return QueryStatusDto.InProgress;
+    case QueryStatus.Completed:
+      return QueryStatusDto.Completed;
+    case QueryStatus.Failed:
+      return QueryStatusDto.Failed;
+    default:
+      assertNever(status);
+  }
+}
diff --git a/extensions/ql-vscode/src/query-history/store/query-history-variant-analysis-dto-mapper.ts b/extensions/ql-vscode/src/query-history/store/query-history-variant-analysis-dto-mapper.ts
new file mode 100644
index 00000000000..e05451bf010
--- /dev/null
+++ b/extensions/ql-vscode/src/query-history/store/query-history-variant-analysis-dto-mapper.ts
@@ -0,0 +1,253 @@
+import {
+  QueryHistoryVariantAnalysisDto,
+  QueryLanguageDto,
+  QueryStatusDto,
+  VariantAnalysisDto,
+  VariantAnalysisFailureReasonDto,
+  VariantAnalysisRepoStatusDto,
+  VariantAnalysisScannedRepositoryDto,
+  VariantAnalysisSkippedRepositoriesDto,
+  VariantAnalysisSkippedRepositoryDto,
+  VariantAnalysisSkippedRepositoryGroupDto,
+  VariantAnalysisStatusDto,
+} from "./query-history-variant-analysis-dto";
+import {
+  VariantAnalysis,
+  VariantAnalysisFailureReason,
+  VariantAnalysisRepoStatus,
+  VariantAnalysisScannedRepository,
+  VariantAnalysisSkippedRepositories,
+  VariantAnalysisSkippedRepository,
+  VariantAnalysisSkippedRepositoryGroup,
+  VariantAnalysisStatus,
+} from "../../variant-analysis/shared/variant-analysis";
+import { assertNever } from "../../pure/helpers-pure";
+import { QueryLanguage } from "../../common/query-language";
+import { QueryStatus } from "../../query-status";
+import { VariantAnalysisHistoryItem } from "../variant-analysis-history-item";
+
+export function mapQueryHistoryVariantAnalysisToDomainModel(
+  item: QueryHistoryVariantAnalysisDto,
+): VariantAnalysisHistoryItem {
+  return {
+    t: "variant-analysis",
+    failureReason: item.failureReason,
+    resultCount: item.resultCount,
+    status: mapQueryStatusToDomainModel(item.status),
+    completed: item.completed,
+    variantAnalysis: mapVariantAnalysisToDomainModel(item.variantAnalysis),
+    userSpecifiedLabel: item.userSpecifiedLabel,
+  };
+}
+
+function mapVariantAnalysisToDomainModel(
+  variantAnalysis: VariantAnalysisDto,
+): VariantAnalysis {
+  return {
+    id: variantAnalysis.id,
+    controllerRepo: {
+      id: variantAnalysis.controllerRepo.id,
+      fullName: variantAnalysis.controllerRepo.fullName,
+      private: variantAnalysis.controllerRepo.private,
+    },
+    query: {
+      name: variantAnalysis.query.name,
+      filePath: variantAnalysis.query.filePath,
+      language: mapQueryLanguageToDomainModel(variantAnalysis.query.language),
+      text: variantAnalysis.query.text,
+    },
+    databases: {
+      repositories: variantAnalysis.databases.repositories,
+      repositoryLists: variantAnalysis.databases.repositoryLists,
+      repositoryOwners: variantAnalysis.databases.repositoryOwners,
+    },
+    createdAt: variantAnalysis.createdAt,
+    updatedAt: variantAnalysis.updatedAt,
+    executionStartTime: variantAnalysis.executionStartTime,
+    status: mapVariantAnalysisStatusToDomainModel(variantAnalysis.status),
+    completedAt: variantAnalysis.completedAt,
+    actionsWorkflowRunId: variantAnalysis.actionsWorkflowRunId,
+    failureReason:
+      variantAnalysis.failureReason &&
+      mapVariantAnalysisFailureReasonToDomainModel(
+        variantAnalysis.failureReason,
+      ),
+    scannedRepos:
+      variantAnalysis.scannedRepos &&
+      mapVariantAnalysisScannedRepositoriesToDomainModel(
+        variantAnalysis.scannedRepos,
+      ),
+    skippedRepos:
+      variantAnalysis.skippedRepos &&
+      mapVariantAnalysisSkippedRepositoriesToDomainModel(
+        variantAnalysis.skippedRepos,
+      ),
+  };
+}
+
+function mapVariantAnalysisScannedRepositoriesToDomainModel(
+  repos: VariantAnalysisScannedRepositoryDto[],
+): VariantAnalysisScannedRepository[] {
+  return repos.map(mapVariantAnalysisScannedRepositoryToDomainModel);
+}
+
+function mapVariantAnalysisScannedRepositoryToDomainModel(
+  repo: VariantAnalysisScannedRepositoryDto,
+): VariantAnalysisScannedRepository {
+  return {
+    repository: {
+      id: repo.repository.id,
+      fullName: repo.repository.fullName,
+      private: repo.repository.private,
+      stargazersCount: repo.repository.stargazersCount,
+      updatedAt: repo.repository.updatedAt,
+    },
+    analysisStatus: mapVariantAnalysisRepoStatusToDomainModel(
+      repo.analysisStatus,
+    ),
+    resultCount: repo.resultCount,
+    artifactSizeInBytes: repo.artifactSizeInBytes,
+    failureMessage: repo.failureMessage,
+  };
+}
+
+function mapVariantAnalysisSkippedRepositoriesToDomainModel(
+  repos: VariantAnalysisSkippedRepositoriesDto,
+): VariantAnalysisSkippedRepositories {
+  return {
+    accessMismatchRepos:
+      repos.accessMismatchRepos &&
+      mapVariantAnalysisSkippedRepositoryGroupToDomainModel(
+        repos.accessMismatchRepos,
+      ),
+    notFoundRepos:
+      repos.notFoundRepos &&
+      mapVariantAnalysisSkippedRepositoryGroupToDomainModel(
+        repos.notFoundRepos,
+      ),
+    noCodeqlDbRepos:
+      repos.noCodeqlDbRepos &&
+      mapVariantAnalysisSkippedRepositoryGroupToDomainModel(
+        repos.noCodeqlDbRepos,
+      ),
+    overLimitRepos:
+      repos.overLimitRepos &&
+      mapVariantAnalysisSkippedRepositoryGroupToDomainModel(
+        repos.overLimitRepos,
+      ),
+  };
+}
+
+function mapVariantAnalysisSkippedRepositoryGroupToDomainModel(
+  repoGroup: VariantAnalysisSkippedRepositoryGroupDto,
+): VariantAnalysisSkippedRepositoryGroup {
+  return {
+    repositoryCount: repoGroup.repositoryCount,
+    repositories: repoGroup.repositories.map(
+      mapVariantAnalysisSkippedRepositoryToDomainModel,
+    ),
+  };
+}
+
+function mapVariantAnalysisSkippedRepositoryToDomainModel(
+  repo: VariantAnalysisSkippedRepositoryDto,
+): VariantAnalysisSkippedRepository {
+  return {
+    id: repo.id,
+    fullName: repo.fullName,
+    private: repo.private,
+    stargazersCount: repo.stargazersCount,
+    updatedAt: repo.updatedAt,
+  };
+}
+
+function mapVariantAnalysisFailureReasonToDomainModel(
+  failureReason: VariantAnalysisFailureReasonDto,
+): VariantAnalysisFailureReason {
+  switch (failureReason) {
+    case VariantAnalysisFailureReasonDto.NoReposQueried:
+      return VariantAnalysisFailureReason.NoReposQueried;
+    case VariantAnalysisFailureReasonDto.ActionsWorkflowRunFailed:
+      return VariantAnalysisFailureReason.ActionsWorkflowRunFailed;
+    case VariantAnalysisFailureReasonDto.InternalError:
+      return VariantAnalysisFailureReason.InternalError;
+    default:
+      assertNever(failureReason);
+  }
+}
+
+function mapVariantAnalysisRepoStatusToDomainModel(
+  status: VariantAnalysisRepoStatusDto,
+): VariantAnalysisRepoStatus {
+  switch (status) {
+    case VariantAnalysisRepoStatusDto.Pending:
+      return VariantAnalysisRepoStatus.Pending;
+    case VariantAnalysisRepoStatusDto.InProgress:
+      return VariantAnalysisRepoStatus.InProgress;
+    case VariantAnalysisRepoStatusDto.Succeeded:
+      return VariantAnalysisRepoStatus.Succeeded;
+    case VariantAnalysisRepoStatusDto.Failed:
+      return VariantAnalysisRepoStatus.Failed;
+    case VariantAnalysisRepoStatusDto.Canceled:
+      return VariantAnalysisRepoStatus.Canceled;
+    case VariantAnalysisRepoStatusDto.TimedOut:
+      return VariantAnalysisRepoStatus.TimedOut;
+    default:
+      assertNever(status);
+  }
+}
+
+function mapVariantAnalysisStatusToDomainModel(
+  status: VariantAnalysisStatusDto,
+): VariantAnalysisStatus {
+  switch (status) {
+    case VariantAnalysisStatusDto.InProgress:
+      return VariantAnalysisStatus.InProgress;
+    case VariantAnalysisStatusDto.Succeeded:
+      return VariantAnalysisStatus.Succeeded;
+    case VariantAnalysisStatusDto.Failed:
+      return VariantAnalysisStatus.Failed;
+    case VariantAnalysisStatusDto.Canceled:
+      return VariantAnalysisStatus.Canceled;
+    default:
+      assertNever(status);
+  }
+}
+
+function mapQueryLanguageToDomainModel(
+  language: QueryLanguageDto,
+): QueryLanguage {
+  switch (language) {
+    case QueryLanguageDto.CSharp:
+      return QueryLanguage.CSharp;
+    case QueryLanguageDto.Cpp:
+      return QueryLanguage.Cpp;
+    case QueryLanguageDto.Go:
+      return QueryLanguage.Go;
+    case QueryLanguageDto.Java:
+      return QueryLanguage.Java;
+    case QueryLanguageDto.Javascript:
+      return QueryLanguage.Javascript;
+    case QueryLanguageDto.Python:
+      return QueryLanguage.Python;
+    case QueryLanguageDto.Ruby:
+      return QueryLanguage.Ruby;
+    case QueryLanguageDto.Swift:
+      return QueryLanguage.Swift;
+    default:
+      assertNever(language);
+  }
+}
+
+function mapQueryStatusToDomainModel(status: QueryStatusDto): QueryStatus {
+  switch (status) {
+    case QueryStatusDto.InProgress:
+      return QueryStatus.InProgress;
+    case QueryStatusDto.Completed:
+      return QueryStatus.Completed;
+    case QueryStatusDto.Failed:
+      return QueryStatus.Failed;
+    default:
+      assertNever(status);
+  }
+}
diff --git a/extensions/ql-vscode/src/query-history/store/query-history-variant-analysis-dto.ts b/extensions/ql-vscode/src/query-history/store/query-history-variant-analysis-dto.ts
index 06c79b54269..78654510085 100644
--- a/extensions/ql-vscode/src/query-history/store/query-history-variant-analysis-dto.ts
+++ b/extensions/ql-vscode/src/query-history/store/query-history-variant-analysis-dto.ts
@@ -1,27 +1,17 @@
 // Contains models and consts for the data we want to store in the query history store.
 // Changes to these models should be done carefully and account for backwards compatibility of data.
 
-import { QueryLanguage } from "../../common/query-language";
-import { QueryStatus } from "../../query-status";
-import {
-  VariantAnalysisFailureReason,
-  VariantAnalysisRepoStatus,
-  VariantAnalysisStatus,
-} from "../../variant-analysis/shared/variant-analysis";
-
-// All data points are modelled, except enums.
-
 export interface QueryHistoryVariantAnalysisDto {
   readonly t: "variant-analysis";
   failureReason?: string;
   resultCount?: number;
-  status: QueryStatus;
+  status: QueryStatusDto;
   completed: boolean;
-  variantAnalysis: VariantAnalysisQueryHistoryDto;
+  variantAnalysis: VariantAnalysisDto;
   userSpecifiedLabel?: string;
 }
 
-export interface VariantAnalysisQueryHistoryDto {
+export interface VariantAnalysisDto {
   id: number;
   controllerRepo: {
     id: number;
@@ -31,7 +21,7 @@ export interface VariantAnalysisQueryHistoryDto {
   query: {
     name: string;
     filePath: string;
-    language: QueryLanguage;
+    language: QueryLanguageDto;
     text: string;
   };
   databases: {
@@ -42,10 +32,10 @@ export interface VariantAnalysisQueryHistoryDto {
   createdAt: string;
   updatedAt: string;
   executionStartTime: number;
-  status: VariantAnalysisStatus;
+  status: VariantAnalysisStatusDto;
   completedAt?: string;
   actionsWorkflowRunId?: number;
-  failureReason?: VariantAnalysisFailureReason;
+  failureReason?: VariantAnalysisFailureReasonDto;
   scannedRepos?: VariantAnalysisScannedRepositoryDto[];
   skippedRepos?: VariantAnalysisSkippedRepositoriesDto;
 }
@@ -58,7 +48,7 @@ export interface VariantAnalysisScannedRepositoryDto {
     stargazersCount: number;
     updatedAt: string | null;
   };
-  analysisStatus: VariantAnalysisRepoStatus;
+  analysisStatus: VariantAnalysisRepoStatusDto;
   resultCount?: number;
   artifactSizeInBytes?: number;
   failureMessage?: string;
@@ -83,3 +73,42 @@ export interface VariantAnalysisSkippedRepositoryDto {
   stargazersCount?: number;
   updatedAt?: string | null;
 }
+
+export enum VariantAnalysisFailureReasonDto {
+  NoReposQueried = "noReposQueried",
+  ActionsWorkflowRunFailed = "actionsWorkflowRunFailed",
+  InternalError = "internalError",
+}
+
+export enum VariantAnalysisRepoStatusDto {
+  Pending = "pending",
+  InProgress = "inProgress",
+  Succeeded = "succeeded",
+  Failed = "failed",
+  Canceled = "canceled",
+  TimedOut = "timedOut",
+}
+
+export enum VariantAnalysisStatusDto {
+  InProgress = "inProgress",
+  Succeeded = "succeeded",
+  Failed = "failed",
+  Canceled = "canceled",
+}
+
+export enum QueryLanguageDto {
+  CSharp = "csharp",
+  Cpp = "cpp",
+  Go = "go",
+  Java = "java",
+  Javascript = "javascript",
+  Python = "python",
+  Ruby = "ruby",
+  Swift = "swift",
+}
+
+export enum QueryStatusDto {
+  InProgress = "InProgress",
+  Completed = "Completed",
+  Failed = "Failed",
+}
diff --git a/extensions/ql-vscode/test/vscode-tests/no-workspace/data/variant-analysis/workspace-query-history.json b/extensions/ql-vscode/test/vscode-tests/no-workspace/data/variant-analysis/workspace-query-history.json
index add4195f2cb..d17874be94d 100644
--- a/extensions/ql-vscode/test/vscode-tests/no-workspace/data/variant-analysis/workspace-query-history.json
+++ b/extensions/ql-vscode/test/vscode-tests/no-workspace/data/variant-analysis/workspace-query-history.json
@@ -7,7 +7,11 @@
       "completed": true,
       "variantAnalysis": {
         "id": 98574321397,
-        "controllerRepoId": 128321,
+        "controllerRepo": {
+          "id": 128321,
+          "fullName": "github/codeql",
+          "private": false
+        },
         "query": {
           "name": "Variant Analysis Integration Test 1",
           "filePath": "PLACEHOLDER/q2.ql",
@@ -30,7 +34,11 @@
       "completed": true,
       "variantAnalysis": {
         "id": 98574321397,
-        "controllerRepoId": 128321,
+        "controllerRepo": {
+          "id": 128321,
+          "fullName": "github/codeql",
+          "private": false
+        },
         "query": {
           "name": "Variant Analysis Integration Test 2",
           "filePath": "PLACEHOLDER/q2.ql",