feat(api): Add CanCreateModelIngestion model permission check (#436)

* CanCreateModelIngestion check

* assert this way

* correct exception type

.github/workflows/integration-test.yml

@@ -6,10 +6,12 @@ on:
       docker-compose-file:
         required: true
         type: string
-      use-github-container-registry:
+      use-internal-image:
         default: false
         type: boolean
-
+    secrets:
+      CODECOV_TOKEN:
+        required: true
 jobs:
   integration-test:
     env:
@@ -27,7 +29,7 @@ jobs:
           cache-dependency-path: "**/packages.lock.json"
 
       - name: 🔐 Login to Github Container Registry
-        if: ${{ inputs.use-github-container-registry }}
+        if: ${{ inputs.use-internal-image }}
         uses: docker/login-action@v3
         with:
           registry: "ghcr.io"
@@ -43,11 +45,18 @@ jobs:
       - name: 🏗️ Build
         run: dotnet build ${{ env.Solution }} --configuration Release --no-restore -warnaserror
 
-      - name: 🔨 Integration Tests
-        run: dotnet test ${{ env.Solution }} --filter "Category=Integration" --configuration Release --no-build --no-restore --verbosity=normal /p:AltCover=true /p:AltCoverAttributeFilter=ExcludeFromCodeCoverage
+      - name: 🔨 Integration Tests against Public Server
+        if: ${{ !inputs.use-internal-image }}
+        run: dotnet test ${{ env.Solution }} --filter "(Category=Integration)&(Server!=Internal)" --configuration Release --no-build --no-restore --verbosity=normal /p:AltCover=true /p:AltCoverAttributeFilter=ExcludeFromCodeCoverage
+
+      - name: 🔨 Integration Tests against Internal Server
+        if: ${{ inputs.use-internal-image }}
+        run: dotnet test ${{ env.Solution }} --filter "(Category=Integration)&(Server!=Public)" --configuration Release --no-build --no-restore --verbosity=normal /p:AltCover=true /p:AltCoverAttributeFilter=ExcludeFromCodeCoverage
 
       - name: Upload coverage reports to Codecov with GitHub Action
         uses: codecov/codecov-action@v5
+        continue-on-error: true
         with:
+          fail_ci_if_error: true
           files: tests/**/coverage.xml
           token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/pr.yml

@@ -39,7 +39,9 @@ jobs:
 
       - name: Upload coverage reports to Codecov with GitHub Action
         uses: codecov/codecov-action@v5
+        continue-on-error: true
         with:
+          fail_ci_if_error: true
           files: tests/**/coverage.xml
           token: ${{ secrets.CODECOV_TOKEN }}
 
@@ -47,9 +49,13 @@ jobs:
     uses: "./.github/workflows/integration-test.yml"
     with:
       docker-compose-file: "docker-compose-internal.yml"
-      use-github-container-registry: true
-
+      use-internal-image: true
+    secrets: 
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      
   integration-test-public:
     uses: "./.github/workflows/integration-test.yml"
     with:
       docker-compose-file: "docker-compose.yml"
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/release.yml

@@ -48,7 +48,9 @@ jobs:
 
       - name: Upload coverage reports to Codecov with GitHub Action
         uses: codecov/codecov-action@v5
+        continue-on-error: true
         with:
+          fail_ci_if_error: true
           files: tests/**/coverage.xml
           token: ${{ secrets.CODECOV_TOKEN }}
 

.tool-versions

@@ -0,0 +1 @@
+dotnet 8.0.400

Speckle.Sdk.slnx

@@ -10,6 +10,7 @@
     <File Path="Directory.Build.props" />
     <File Path="Directory.Build.Targets" />
     <File Path="Directory.Packages.props" />
+    <File Path="docker-compose-internal.yml" />
     <File Path="docker-compose.yml" />
     <File Path="global.json" />
     <File Path="README.md" />
@@ -17,6 +18,7 @@
     <File Path=".github\git-commit-instructions.md" />
   </Folder>
   <Folder Name="/config/workflows/">
+    <File Path=".github/workflows/integration-test.yml" />
     <File Path=".github/workflows/pr.yml" />
     <File Path=".github/workflows/release.yml" />
   </Folder>

docker-compose-internal.yml

@@ -97,10 +97,7 @@ services:
 
       STRATEGY_LOCAL: "true"
 
-      POSTGRES_URL: "postgres"
-      POSTGRES_USER: "speckle"
-      POSTGRES_PASSWORD: "speckle"
-      POSTGRES_DB: "speckle"
+      POSTGRES_URL: 'postgres://speckle:speckle@postgres:5432/speckle'
       ENABLE_MP: "false"
 
       LOG_PRETTY: "true"

src/Speckle.Objects/Other/RawEncoding.cs

@@ -21,4 +21,5 @@ public static class RawEncodingFormats
 {
   public const string RHINO_3DM = "3dm";
   public const string ACAD_DWG = "dwg";
+  public const string ACAD_SAT = "sat";
 }

src/Speckle.Sdk/Api/GraphQL/Client.cs

@@ -35,6 +35,7 @@ public sealed class Client : ISpeckleGraphQLClient, IClient
   public WorkspaceResource Workspace { get; }
   public ServerResource Server { get; }
   public FileImportResource FileImport { get; }
+  public ModelIngestionResource Ingestion { get; }
 
   public Uri ServerUrl => new(Account.serverInfo.url);
 
@@ -71,6 +72,7 @@ public sealed class Client : ISpeckleGraphQLClient, IClient
     Workspace = new(this);
     Server = new(this);
     FileImport = new(this, blobApiFactory.Create(account));
+    Ingestion = new(this);
   }
 
   [AutoInterfaceIgnore]

src/Speckle.Sdk/Api/GraphQL/Enums/FileUploadConversionStatus.cs

@@ -1,6 +1,9 @@
-namespace Speckle.Sdk.Api.GraphQL.Enums;
+// ReSharper disable InconsistentNaming
+namespace Speckle.Sdk.Api.GraphQL.Enums;
 
-//This enum isn't explicitly defined in the schema, instead its usages are int typed (But represent an enum)
+/// <remarks>
+/// This enum isn't explicitly defined in the schema, instead its usages are int typed (But represent an enum)
+/// </remarks>
 public enum FileUploadConversionStatus
 {
   Queued = 0,

src/Speckle.Sdk/Api/GraphQL/Enums/ModelIngestionStatus.cs

@@ -0,0 +1,14 @@
+// ReSharper disable InconsistentNaming
+namespace Speckle.Sdk.Api.GraphQL.Enums;
+
+/// <remarks>
+/// string based enum
+/// </remarks>
+public enum ModelIngestionStatus
+{
+  cancelled,
+  failed,
+  processing,
+  queued,
+  success,
+}

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectCommentsUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectCommentsUpdatedMessageType
 {
   ARCHIVED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectFileImportUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectFileImportUpdatedMessageType
 {
   CREATED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectModelIngestionUpdatedMessageType.cs

@@ -0,0 +1,13 @@
+// ReSharper disable InconsistentNaming
+namespace Speckle.Sdk.Api.GraphQL.Enums;
+
+/// <remarks>
+/// string based enum
+/// </remarks>
+public enum ProjectModelIngestionUpdatedMessageType
+{
+  cancellationRequested,
+  created,
+  deleted,
+  updated,
+}

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectModelsUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectModelsUpdatedMessageType
 {
   CREATED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectPendingModelsUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectPendingModelsUpdatedMessageType
 {
   CREATED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectUpdatedMessageType
 {
   DELETED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectVersionsUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectVersionsUpdatedMessageType
 {
   CREATED,

src/Speckle.Sdk/Api/GraphQL/Enums/ProjectVisibility.cs

@@ -1,5 +1,9 @@
+// ReSharper disable InconsistentNaming
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ProjectVisibility
 {
   Private,

src/Speckle.Sdk/Api/GraphQL/Enums/ResourceType.cs

@@ -1,5 +1,9 @@
-namespace Speckle.Sdk.Api.GraphQL.Enums;
+// ReSharper disable InconsistentNaming
+namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum ResourceType
 {
   commit,

src/Speckle.Sdk/Api/GraphQL/Enums/UserProjectsUpdatedMessageType.cs

@@ -1,5 +1,8 @@
 namespace Speckle.Sdk.Api.GraphQL.Enums;
 
+/// <remarks>
+/// string based enum
+/// </remarks>
 public enum UserProjectsUpdatedMessageType
 {
   ADDED,

src/Speckle.Sdk/Api/GraphQL/Inputs/FileImportInputs.cs

@@ -2,8 +2,10 @@
 
 public record GenerateFileUploadUrlInput(string projectId, string fileName);
 
+[Obsolete(FileImportInputBase.FILE_IMPORT_DEPRECATION_MESSAGE)]
 public record StartFileImportInput(string projectId, string modelId, string fileId, string etag);
 
+[Obsolete(FileImportInputBase.FILE_IMPORT_DEPRECATION_MESSAGE)]
 public record FileImportResult(
   double durationSeconds,
   double downloadDurationSeconds,
@@ -14,14 +16,23 @@ public record FileImportResult(
 
 public abstract class FileImportInputBase
 {
+  internal const string FILE_IMPORT_DEPRECATION_MESSAGE =
+    "Part of the old API surface and will be removed in the future. Use the new ingestion API instead. Field will be deleted on June 1st, 2026";
+
+  [Obsolete(FileImportInputBase.FILE_IMPORT_DEPRECATION_MESSAGE)]
+  protected FileImportInputBase() { }
+
   public required string projectId { get; init; }
   public required string jobId { get; init; }
   public required IReadOnlyCollection<string> warnings { get; init; }
+
+  [Obsolete(FileImportInputBase.FILE_IMPORT_DEPRECATION_MESSAGE)]
   public required FileImportResult result { get; init; }
 }
 
 #pragma warning disable CA1822 //Mark members as static
 
+[Obsolete(FILE_IMPORT_DEPRECATION_MESSAGE)]
 public sealed class FileImportSuccessInput() : FileImportInputBase()
 {
   public const string TYPE_STATUS = "success";
@@ -29,6 +40,7 @@ public sealed class FileImportSuccessInput() : FileImportInputBase()
   public string status => TYPE_STATUS;
 }
 
+[Obsolete(FILE_IMPORT_DEPRECATION_MESSAGE)]
 public sealed class FileImportErrorInput() : FileImportInputBase()
 {
   public const string TYPE_STATUS = "error";

src/Speckle.Sdk/Api/GraphQL/Inputs/ModelIngestionInputs.cs

@@ -0,0 +1,70 @@
+using Speckle.Newtonsoft.Json;
+using Speckle.Sdk.Api.GraphQL.Enums;
+
+namespace Speckle.Sdk.Api.GraphQL.Inputs;
+
+public record SourceDataInput(
+  string sourceApplicationSlug,
+  string sourceApplicationVersion,
+  string? fileName,
+  long? fileSizeBytes
+);
+
+public record ModelIngestionCreateInput(
+  string modelId,
+  string projectId,
+  string progressMessage,
+  SourceDataInput sourceData
+);
+
+public record ModelIngestionUpdateInput(string ingestionId, string projectId, string progressMessage, double? progress);
+
+public record ModelIngestionSuccessInput(
+  string ingestionId,
+  string projectId,
+  string rootObjectId,
+  string? versionMessage
+);
+
+public record ModelIngestionFailedInput(
+  string ingestionId,
+  string projectId,
+  string errorReason,
+  string? errorStacktrace
+)
+{
+  public static ModelIngestionFailedInput FromException(string ingestionId, string projectId, Exception ex)
+  {
+    return new ModelIngestionFailedInput(ingestionId, projectId, ex.Message, ex.ToString());
+  }
+}
+
+public record ModelIngestionCancelledInput(string ingestionId, string projectId, string cancellationMessage);
+
+public record ModelIngestionStartProcessingInput(
+  string ingestionId,
+  string projectId,
+  string progressMessage,
+  SourceDataInput sourceData
+);
+
+public record ModelIngestionRequeueInput(string ingestionId, string projectId, string progressMessage);
+
+public record ProjectModelIngestionSubscriptionInput(
+  string projectId,
+  ModelIngestionReference ingestionReference,
+  [property: JsonIgnore] ProjectModelIngestionUpdatedMessageType messageType
+)
+{
+  // The Newtonsoft serializer is setup to handle SCREAMING_CASE enums.
+  // But the API requires the enum to look exactly like they are
+  [JsonProperty(nameof(messageType))]
+  public string serializedType => messageType.ToString();
+}
+
+/// <remarks>
+/// <c>@oneOf</c> i.e. server expects <b>either</b> <paramref name="ingestionId"/> or <paramref name="modelId"/>, but not both.
+/// </remarks>
+/// <param name="ingestionId"></param>
+/// <param name="modelId"></param>
+public record ModelIngestionReference(string? ingestionId, string? modelId);

src/Speckle.Sdk/Api/GraphQL/Inputs/VersionInputs.cs

@@ -1,4 +1,6 @@
-namespace Speckle.Sdk.Api.GraphQL.Inputs;
+using Version = Speckle.Sdk.Api.GraphQL.Models.Version;
+
+namespace Speckle.Sdk.Api.GraphQL.Inputs;
 
 public record UpdateVersionInput(string versionId, string projectId, string? message);
 
@@ -16,6 +18,10 @@ public record CreateVersionInput(
   IReadOnlyList<string>? parents = null
 );
 
+/// <param name="versionId"></param>
+/// <param name="projectId"></param>
+/// <param name="sourceApplication">IMPORTANT: this is meant to be the slug of the application that has done the receiving, not to be confused with <see cref="Version.sourceApplication"/></param>
+/// <param name="message"></param>
 public record MarkReceivedVersionInput(
   string versionId,
   string projectId,

src/Speckle.Sdk/Api/GraphQL/Models/ModelIngestion.cs

@@ -0,0 +1,12 @@
+namespace Speckle.Sdk.Api.GraphQL.Models;
+
+public sealed class ModelIngestion
+{
+  public required string id { get; init; }
+  public required DateTime createdAt { get; init; }
+  public required DateTime updatedAt { get; init; }
+  public required string modelId { get; init; }
+  public required bool cancellationRequested { get; init; }
+  public required ModelIngestionStatusData statusData { get; init; }
+  // public required LimitedUser user { get; init; }
+}

src/Speckle.Sdk/Api/GraphQL/Models/ModelIngestionStatusData.cs

@@ -0,0 +1,9 @@
+using Speckle.Sdk.Api.GraphQL.Enums;
+
+namespace Speckle.Sdk.Api.GraphQL.Models;
+
+public sealed class ModelIngestionStatusData
+{
+  public required ModelIngestionStatus status { get; init; }
+  public required string? progressMessage { get; init; }
+}

src/Speckle.Sdk/Api/GraphQL/Models/ModelPermissionChecks.cs

@@ -0,0 +1,8 @@
+namespace Speckle.Sdk.Api.GraphQL.Models;
+
+public sealed class ModelPermissionChecks
+{
+  public PermissionCheckResult canUpdate { get; init; }
+  public PermissionCheckResult canDelete { get; init; }
+  public PermissionCheckResult canCreateVersion { get; init; }
+}

src/Speckle.Sdk/Api/GraphQL/Models/PendingStreamCollaborator.cs

@@ -10,7 +10,7 @@ public sealed class PendingStreamCollaborator
   public string projectName { get; init; }
   public string title { get; init; }
   public string role { get; init; }
-  public LimitedUser invitedBy { get; init; }
+  public LimitedUser? invitedBy { get; init; }
   public LimitedUser? user { get; init; }
   public string? token { get; init; }
 }

src/Speckle.Sdk/Api/GraphQL/Models/ProjectPermissionChecks.cs

@@ -5,5 +5,7 @@ public sealed class ProjectPermissionChecks
   public PermissionCheckResult canCreateModel { get; init; }
   public PermissionCheckResult canDelete { get; init; }
   public PermissionCheckResult canLoad { get; init; }
+
+  [Obsolete("Use ModelPermissionChecks.CanCreateVersion instead", true)]
   public PermissionCheckResult canPublish { get; init; }
 }

src/Speckle.Sdk/Api/GraphQL/Models/SubscriptionMessages.cs

@@ -6,10 +6,10 @@ namespace Speckle.Sdk.Api.GraphQL.Models;
 public sealed class UserProjectsUpdatedMessage : EventArgs
 {
   [JsonRequired]
-  public string id { get; init; }
+  public required string id { get; init; }
 
   [JsonRequired]
-  public UserProjectsUpdatedMessageType type { get; init; }
+  public required UserProjectsUpdatedMessageType type { get; init; }
 
   public Project? project { get; init; }
 }
@@ -17,10 +17,10 @@ public sealed class UserProjectsUpdatedMessage : EventArgs
 public sealed class ProjectCommentsUpdatedMessage : EventArgs
 {
   [JsonRequired]
-  public string id { get; init; }
+  public required string id { get; init; }
 
   [JsonRequired]
-  public ProjectCommentsUpdatedMessageType type { get; init; }
+  public required ProjectCommentsUpdatedMessageType type { get; init; }
 
   public Comment? comment { get; init; }
 }
@@ -28,10 +28,10 @@ public sealed class ProjectCommentsUpdatedMessage : EventArgs
 public sealed class ProjectFileImportUpdatedMessage : EventArgs
 {
   [JsonRequired]
-  public string id { get; init; }
+  public required string id { get; init; }
 
   [JsonRequired]
-  public ProjectFileImportUpdatedMessageType type { get; init; }
+  public required ProjectFileImportUpdatedMessageType type { get; init; }
 
   public FileUpload? upload { get; init; }
 }
@@ -39,10 +39,10 @@ public sealed class ProjectFileImportUpdatedMessage : EventArgs
 public sealed class ProjectModelsUpdatedMessage : EventArgs
 {
   [JsonRequired]
-  public string id { get; init; }
+  public required string id { get; init; }
 
   [JsonRequired]
-  public ProjectModelsUpdatedMessageType type { get; init; }
+  public required ProjectModelsUpdatedMessageType type { get; init; }
 
   public Model? model { get; init; }
 }
@@ -50,10 +50,10 @@ public sealed class ProjectModelsUpdatedMessage : EventArgs
 public sealed class ProjectPendingModelsUpdatedMessage : EventArgs
 {
   [JsonRequired]
-  public string id { get; init; }
+  public required string id { get; init; }
 
   [JsonRequired]
-  public ProjectPendingModelsUpdatedMessageType type { get; init; }
+  public required ProjectPendingModelsUpdatedMessageType type { get; init; }
 
   public FileUpload? model { get; init; }
 }
@@ -61,10 +61,10 @@ public sealed class ProjectPendingModelsUpdatedMessage : EventArgs
 public sealed class ProjectUpdatedMessage : EventArgs
 {
   [JsonRequired]
-  public string id { get; init; }
+  public required string id { get; init; }
 
   [JsonRequired]
-  public ProjectUpdatedMessageType type { get; init; }
+  public required ProjectUpdatedMessageType type { get; init; }
 
   public Project? project { get; init; }
 }
@@ -72,13 +72,22 @@ public sealed class ProjectUpdatedMessage : EventArgs
 public sealed class ProjectVersionsUpdatedMessage : EventArgs
 {
   [JsonRequired]
-  public string id { get; init; }
+  public required string id { get; init; }
 
   [JsonRequired]
-  public ProjectVersionsUpdatedMessageType type { get; init; }
+  public required ProjectVersionsUpdatedMessageType type { get; init; }
 
   [JsonRequired]
-  public string modelId { get; init; }
+  public required string modelId { get; init; }
 
   public Version? version { get; init; }
 }
+
+public sealed class ProjectModelIngestionUpdatedMessage : EventArgs
+{
+  [JsonRequired]
+  public required ModelIngestion modelIngestion { get; init; }
+
+  [JsonRequired]
+  public required ProjectModelIngestionUpdatedMessageType type { get; init; }
+}

src/Speckle.Sdk/Api/GraphQL/Resources/ActiveUserResource.cs

@@ -397,11 +397,6 @@ public sealed class ActiveUserResource
                   authorized
                   message
                 }
-                canPublish {
-                  code
-                  authorized
-                  message
-                }
               }
             }
           }

src/Speckle.Sdk/Api/GraphQL/Resources/FileImportResource.cs

@@ -29,8 +29,10 @@ public sealed class FileImportResource : IDisposable
   /// <remarks>
   /// Only use this if you are writing a file importer, that is responsible for
   /// processing file import jobs.
-  /// Only works on servers version >=2.25.8
+  /// Only works on servers version >=2.25.8 but from 3.0.7 onwards has been deprecated and replaced by model ingestion api
+  /// see <see cref="ModelIngestionResource.Complete"/>
   /// </remarks>
+  [Obsolete(FileImportInputBase.FILE_IMPORT_DEPRECATION_MESSAGE)]
   public async Task<bool> FinishFileImportJob(FileImportInputBase input, CancellationToken cancellationToken)
   {
     //language=graphql
@@ -57,7 +59,11 @@ public sealed class FileImportResource : IDisposable
   /// <param name="cancellationToken"></param>
   /// <returns></returns>
   /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
-  /// <remarks>Only works on servers version >=2.25.8</remarks>
+  /// <remarks>
+  /// Only works on servers version >=2.25.8 but from 3.0.7 onwards has been deprecated and replaced by model ingestion api
+  /// see <see cref="ModelIngestionResource.StartProcessing"/>
+  /// </remarks>
+  [Obsolete(FileImportInputBase.FILE_IMPORT_DEPRECATION_MESSAGE)]
   public async Task<FileImport> StartFileImportJob(
     StartFileImportInput input,
     CancellationToken cancellationToken = default

src/Speckle.Sdk/Api/GraphQL/Resources/ModelIngestionResource.cs

@@ -0,0 +1,486 @@
+using GraphQL;
+using Speckle.Sdk.Api.GraphQL.Inputs;
+using Speckle.Sdk.Api.GraphQL.Models;
+using Speckle.Sdk.Api.GraphQL.Models.Responses;
+
+namespace Speckle.Sdk.Api.GraphQL.Resources;
+
+/// <remarks>
+/// Model Ingestion API is available for server versions <c>3.0.3</c> and above
+/// </remarks>
+public sealed class ModelIngestionResource
+{
+  private readonly ISpeckleGraphQLClient _client;
+
+  internal ModelIngestionResource(ISpeckleGraphQLClient client)
+  {
+    _client = client;
+  }
+
+  /// <summary>
+  /// Create a new model ingestion
+  /// </summary>
+  /// <remarks>
+  /// The model ingestion created will have a <c>processing</c> state (not <c>queued</c>). This mutation is designed to be used
+  /// by client/connectors that are immediately processing
+  /// Model Ingestion API is available for server versions <c>3.0.3</c> and above
+  /// </remarks>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<ModelIngestion> Create(
+    ModelIngestionCreateInput input,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation IngestionCreate($input: ModelIngestionCreateInput!) {
+        data: projectMutations {
+          data: modelIngestionMutations {
+            data: create(input: $input) {
+              id
+              createdAt
+              updatedAt
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
+                }
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelIngestion>>>>(
+        request,
+        cancellationToken
+      )
+      .ConfigureAwait(false);
+
+    return res.data.data.data;
+  }
+
+  /// <remarks>
+  /// Model Ingestion API is available for server versions <c>3.0.3</c> and above
+  /// </remarks>
+  /// <param name="modelIngestionId"></param>
+  /// <param name="projectId"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<ModelIngestion> Get(
+    string modelIngestionId,
+    string projectId,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      query Query($projectId: String!, $modelIngestionId: ID!) {
+        data:project(id: $projectId) {
+          data:ingestion(id: $modelIngestionId) {
+            id
+            createdAt
+            updatedAt
+            modelId
+            cancellationRequested
+            statusData {
+              ... on HasModelIngestionStatus {
+                status
+              }
+              ... on HasProgressMessage {
+                progressMessage
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { projectId, modelIngestionId } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<ModelIngestion>>>(request, cancellationToken)
+      .ConfigureAwait(false);
+
+    return res.data.data;
+  }
+
+  /// <summary>
+  /// For File Import / Cloud integrations only
+  /// </summary>
+  /// <remarks>
+  /// Model Ingestion API is available for server versions <c>3.0.3</c> and above
+  /// </remarks>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<ModelIngestion> StartProcessing(
+    ModelIngestionStartProcessingInput input,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation IngestionStartProcessing($input: ModelIngestionStartProcessingInput!) {
+        data: projectMutations {
+          data: modelIngestionMutations {
+            data: startProcessing(input: $input) {
+              id
+              createdAt
+              updatedAt
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
+                }
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelIngestion>>>>(
+        request,
+        cancellationToken
+      )
+      .ConfigureAwait(false);
+
+    return res.data.data.data;
+  }
+
+  /// <summary>
+  /// For File Import / Cloud integrations only
+  /// </summary>
+  /// <remarks>
+  /// Model Ingestion API is available for server versions <c>3.0.3</c> and above
+  /// </remarks>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<ModelIngestion> Requeue(
+    ModelIngestionRequeueInput input,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation IngestionStartProcessing($input: ModelIngestionRequeueInput!) {
+        data: projectMutations {
+          data: modelIngestionMutations {
+            data: requeue(input: $input) {
+              id
+              createdAt
+              updatedAt
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
+                }
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelIngestion>>>>(
+        request,
+        cancellationToken
+      )
+      .ConfigureAwait(false);
+
+    return res.data.data.data;
+  }
+
+  /// <remarks>
+  /// Model Ingestion API is available for server versions <c>3.0.3</c> and above
+  /// </remarks>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<ModelIngestion> UpdateProgress(
+    ModelIngestionUpdateInput input,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation IngestionUpdateProgress(
+        $input: ModelIngestionUpdateInput!
+      ) {
+        data: projectMutations {
+          data: modelIngestionMutations {
+            data: updateProgress(input: $input) {
+              id
+              createdAt
+              updatedAt
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
+                }
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelIngestion>>>>(
+        request,
+        cancellationToken
+      )
+      .ConfigureAwait(false);
+
+    return res.data.data.data;
+  }
+
+  /// <summary>
+  /// Request that the server completes the ingestion by creating a version
+  /// If successful, the job will be in a terminal "successful" state.
+  /// </summary>
+  /// <remarks>
+  /// Model Ingestion API is available for server versions <c>3.0.3</c> and above
+  /// </remarks>
+  /// <seealso cref="FailWithError"/>
+  /// <seealso cref="FailWithCancel"/>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns>The version id</returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<string> Complete(ModelIngestionSuccessInput input, CancellationToken cancellationToken = default)
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation IngestionComplete($input: ModelIngestionSuccessInput!) {
+        data: projectMutations {
+          data: modelIngestionMutations {
+            data: completeWithVersion(input: $input) {
+              data:statusData {
+                ... on ModelIngestionSuccessStatus {
+                  data:versionId
+                }
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<
+        RequiredResponse<RequiredResponse<RequiredResponse<RequiredResponse<RequiredResponse<string>>>>>
+      >(request, cancellationToken)
+      .ConfigureAwait(false);
+
+    return res.data.data.data.data.data;
+  }
+
+  /// <summary>
+  /// Fail the job with an error.
+  /// </summary>
+  /// <remarks>
+  /// For requested user cancellation, use <see cref="FailWithCancel"/> instead<br/>
+  /// Model Ingestion API is available for server versions <c>3.0.3</c> and above
+  /// </remarks>
+  /// <seealso cref="FailWithCancel"/>
+  /// <seealso cref="Complete"/>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<ModelIngestion> FailWithError(
+    ModelIngestionFailedInput input,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation IngestionFailWithError($input: ModelIngestionFailedInput!) {
+        data: projectMutations {
+          data: modelIngestionMutations {
+            data: failWithError(input: $input) {
+              id
+              createdAt
+              updatedAt
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
+                }
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelIngestion>>>>(
+        request,
+        cancellationToken
+      )
+      .ConfigureAwait(false);
+
+    return res.data.data.data;
+  }
+
+  /// <summary>
+  /// Fail the ingestion with a <c>canceled</c> status.
+  /// This should only be done if the user has explicitly requested cancellation
+  /// Other forms of cancellation use <see cref="FailWithError"/>.
+  /// The ingestion should then enter a terminal "canceled" state.<br/>
+  /// Model Ingestion API is available for server versions <c>3.0.3</c> and above
+  /// </summary>
+  /// <seealso cref="FailWithError"/>
+  /// <seealso cref="Complete"/>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<ModelIngestion> FailWithCancel(
+    ModelIngestionCancelledInput input,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation IngestionFailWithCancel($input: ModelIngestionCancelledInput!) {
+        data: projectMutations {
+          data: modelIngestionMutations {
+            data: failWithCancel(input: $input) {
+              id
+              createdAt
+              updatedAt
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
+                }
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelIngestion>>>>(
+        request,
+        cancellationToken
+      )
+      .ConfigureAwait(false);
+
+    return res.data.data.data;
+  }
+
+  /// <summary>
+  /// Request that the <see cref="ModelIngestion"/> is canceled.
+  /// </summary>
+  /// <remarks>
+  /// Note simply calling this mutation does not imediatly cancel, it doesn't even guarantee it will be canceled at all.
+  /// It's up to the client to observe this cancellation request
+  /// via <see cref="SubscriptionResource.CreateProjectModelIngestionCancellationRequestedSubscription"/>
+  /// and report it as canceled via  <see cref="ModelIngestionResource.FailWithCancel"/>
+  /// See "cooperative cancellation pattern"<br/>
+  /// Model Ingestion API is available for server versions <c>3.0.3</c> and above
+  /// </remarks>
+  /// <seealso cref="FailWithError"/>
+  /// <seealso cref="Complete"/>
+  /// <param name="input"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<ModelIngestion> RequestCancellation(
+    ModelIngestionCancelledInput input,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      mutation IngestionRequestCancellation($input: ModelIngestionRequestCancellationInput!) {
+        data: projectMutations {
+          data: modelIngestionMutations {
+            data: requestCancellation (input: $input) {
+              id
+              createdAt
+              updatedAt
+              modelId
+              cancellationRequested
+              statusData {
+                ... on HasModelIngestionStatus {
+                  status
+                }
+                ... on HasProgressMessage {
+                  progressMessage
+                }
+              }
+            }
+          }
+        }
+      }
+      """;
+
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    var res = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelIngestion>>>>(
+        request,
+        cancellationToken
+      )
+      .ConfigureAwait(false);
+
+    return res.data.data.data;
+  }
+}

src/Speckle.Sdk/Api/GraphQL/Resources/ModelResource.cs

@@ -312,4 +312,88 @@ public sealed class ModelResource
 
     return res.data.data;
   }
+
+  /// <param name="projectId"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<ModelPermissionChecks> GetPermissions(
+    string projectId,
+    string modelId,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      query ModelPermissions($projectId: String!, $modelId: String!) {
+        data:project(id: $projectId) {
+          data:model(id: $modelId) {
+            data:permissions {
+              canUpdate {
+                authorized
+                code
+                message
+              }
+              canDelete {
+                authorized
+                code
+                message
+              }
+              canCreateVersion {
+                authorized
+                code
+                message
+              }
+            }
+          }
+        }
+      }
+      """;
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { projectId, modelId } };
+
+    var response = await _client
+      .ExecuteGraphQLRequest<RequiredResponse<RequiredResponse<RequiredResponse<ModelPermissionChecks>>>>(
+        request,
+        cancellationToken
+      )
+      .ConfigureAwait(false);
+    return response.data.data.data;
+  }
+
+  /// <param name="projectId"></param>
+  /// <param name="cancellationToken"></param>
+  /// <returns></returns>
+  /// <exception cref="SpeckleGraphQLBadInputException">server versions &lt;3.0.11 do not have <c>canCreateIngestion</c> and will throw this exception</exception>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.ExecuteGraphQLRequest{T}"/>
+  public async Task<PermissionCheckResult> CanCreateModelIngestion(
+    string projectId,
+    string modelId,
+    CancellationToken cancellationToken = default
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      query ModelPermissions($projectId: String!, $modelId: String!) {
+        data:project(id: $projectId) {
+          data:model(id: $modelId) {
+            data:permissions {
+              data:canCreateIngestion {
+                authorized
+                code
+                message
+              }
+            }
+          }
+        }
+      }
+      """;
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { projectId, modelId } };
+
+    var response = await _client
+      .ExecuteGraphQLRequest<
+        RequiredResponse<RequiredResponse<RequiredResponse<RequiredResponse<PermissionCheckResult>>>>
+      >(request, cancellationToken)
+      .ConfigureAwait(false);
+    return response.data.data.data.data;
+  }
 }

src/Speckle.Sdk/Api/GraphQL/Resources/SubscriptionResource.cs

@@ -1,4 +1,5 @@
 using GraphQL;
+using Speckle.Sdk.Api.GraphQL.Enums;
 using Speckle.Sdk.Api.GraphQL.Inputs;
 using Speckle.Sdk.Api.GraphQL.Models;
 using Speckle.Sdk.Api.GraphQL.Models.Responses;
@@ -212,6 +213,60 @@ public sealed class SubscriptionResource : IDisposable
     return subscription;
   }
 
+  /// <summary>Subscribe to a cancellation request being made for a Model Ingestion</summary>
+  /// <remarks><inheritdoc cref="CreateUserProjectsUpdatedSubscription"/></remarks>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.SubscribeTo{T}"/>
+  public Subscription<ProjectModelIngestionUpdatedMessage> CreateProjectModelIngestionUpdatedSubscription(
+    ProjectModelIngestionSubscriptionInput input
+  )
+  {
+    //language=graphql
+    const string QUERY = """
+      subscription IngestionUpdated($input: ProjectModelIngestionSubscriptionInput!) {
+        data: projectModelIngestionUpdated(input: $input) {
+          modelIngestion {
+            id
+            createdAt
+            updatedAt
+            modelId
+            cancellationRequested
+            statusData {
+              ... on HasModelIngestionStatus {
+                status
+              }
+              ... on HasProgressMessage {
+                progressMessage
+              }
+            }
+          }
+          type
+        }
+      }
+      """;
+    GraphQLRequest request = new() { Query = QUERY, Variables = new { input } };
+
+    Subscription<ProjectModelIngestionUpdatedMessage> subscription = new(_client, request);
+    _subscriptions.Add(subscription);
+    return subscription;
+  }
+
+  /// <summary>Subscribe to a cancellation request being made for a Model Ingestion</summary>
+  /// <remarks><inheritdoc cref="CreateUserProjectsUpdatedSubscription"/></remarks>
+  /// <inheritdoc cref="ISpeckleGraphQLClient.SubscribeTo{T}"/>
+  public Subscription<ProjectModelIngestionUpdatedMessage> CreateProjectModelIngestionCancellationRequestedSubscription(
+    string ingestionId,
+    string projectId
+  )
+  {
+    return CreateProjectModelIngestionUpdatedSubscription(
+      new ProjectModelIngestionSubscriptionInput(
+        projectId,
+        new(ingestionId, null),
+        ProjectModelIngestionUpdatedMessageType.cancellationRequested
+      )
+    );
+  }
+
   public void Dispose()
   {
     foreach (var subscription in _subscriptions)

src/Speckle.Sdk/Api/GraphQL/Resources/graphql.config.yml

@@ -1,2 +1,2 @@
-schema: https://app.speckle.systems/graphql
+schema: https://latest.speckle.systems/graphql
 documents: '**/*.graphql'

src/Speckle.Sdk/Host/TypeLoader.cs

@@ -140,7 +140,22 @@ internal static class TypeLoader
     return typeof(Base);
   }
 
-  //Don't use unless you're testing
+  /// <summary>
+  /// For testing purposes only
+  /// </summary>
+  internal static void ReInitialize(params Assembly[] assemblies)
+  {
+    lock (s_availableTypes)
+    {
+      Reset();
+      Load(assemblies);
+      s_initialized = true;
+    }
+  }
+
+  /// <summary>
+  /// For testing purposes only
+  /// </summary>
   public static void Reset()
   {
     s_availableTypes = new();

tests/Speckle.Sdk.Serialization.Tests/SerializationTests.cs

@@ -184,7 +184,7 @@ public class SerializationTests
     idToBase.Count.Should().Be(count);
   }
 
-  [Theory]
+  [Theory(Skip = "Takes too long")]
   [InlineData(1)]
   [InlineData(4)]
   public async Task Roundtrip_Test_New(int concurrency)

tests/Speckle.Sdk.Tests.Integration/Api/GraphQL/Resources/ModelIngestionResourceExceptionalTests.cs

@@ -0,0 +1,71 @@
+using Speckle.Sdk.Api;
+using Speckle.Sdk.Api.GraphQL.Inputs;
+using Speckle.Sdk.Api.GraphQL.Models;
+using Speckle.Sdk.Api.GraphQL.Resources;
+
+namespace Speckle.Sdk.Tests.Integration.API.GraphQL.Resources;
+
+[Trait("Server", "Internal")]
+public sealed class ModelIngestionResourceExceptionalTests : IAsyncLifetime
+{
+  private IClient _testUser;
+  private ModelIngestionResource Sut => _testUser.Ingestion;
+  private Project _project;
+  private Model _model;
+
+  public Task DisposeAsync() => Task.CompletedTask;
+
+  public async Task InitializeAsync()
+  {
+    _testUser = await Fixtures.SeedUserWithClient();
+    _project = await _testUser.Project.Create(new("Test project", "", null));
+    _model = await _testUser.Model.Create(new("Test Model 1", "", _project.id));
+  }
+
+  [Fact]
+  public async Task CreateIngestionNonExistentProject()
+  {
+    var createInput = new ModelIngestionCreateInput(
+      _model.id,
+      "Doesn't exist...",
+      "Starting processing",
+      new(".NET test runner", "0.0.0", null, null)
+    );
+
+    var ex = await Assert.ThrowsAsync<AggregateException>(async () =>
+    {
+      _ = await Sut.Create(createInput);
+    });
+    Assert.Single(ex.InnerExceptions);
+    Assert.All(ex.InnerExceptions, item => Assert.IsType<SpeckleGraphQLStreamNotFoundException>(item));
+  }
+
+  [Fact]
+  public async Task UpdateNonExistentNonExistent()
+  {
+    var updateInput = new ModelIngestionUpdateInput("Doesn't exist", _project.id, "Can't be", 0.5);
+
+    var ex = await Assert.ThrowsAsync<AggregateException>(async () =>
+    {
+      _ = await Sut.UpdateProgress(updateInput);
+    });
+    Assert.Single(ex.InnerExceptions);
+    Assert.All(ex.InnerExceptions, item => Assert.IsType<SpeckleGraphQLException>(item));
+  }
+
+  [Fact]
+  public async Task CancelNonExistentIngestion()
+  {
+    var input = new ModelIngestionCancelledInput(
+      "Non-existent-ingestion",
+      _project.id,
+      cancellationMessage: "This was cancelled for testing purposes"
+    );
+    var ex = await Assert.ThrowsAsync<AggregateException>(async () =>
+    {
+      _ = await Sut.FailWithCancel(input);
+    });
+    Assert.Single(ex.InnerExceptions);
+    Assert.All(ex.InnerExceptions, item => Assert.IsType<SpeckleGraphQLException>(item));
+  }
+}

tests/Speckle.Sdk.Tests.Integration/Api/GraphQL/Resources/ModelIngestionResourceTests.cs

@@ -0,0 +1,189 @@
+using Microsoft.Extensions.DependencyInjection;
+using Speckle.Sdk.Api;
+using Speckle.Sdk.Api.GraphQL.Enums;
+using Speckle.Sdk.Api.GraphQL.Inputs;
+using Speckle.Sdk.Api.GraphQL.Models;
+using Speckle.Sdk.Api.GraphQL.Resources;
+using Speckle.Sdk.Models;
+using Speckle.Sdk.Transports;
+using Version = Speckle.Sdk.Api.GraphQL.Models.Version;
+
+namespace Speckle.Sdk.Tests.Integration.API.GraphQL.Resources;
+
+[Trait("Server", "Internal")]
+public sealed class ModelIngestionResourceTests : IAsyncLifetime
+{
+  private IClient _testUser;
+  private ModelIngestionResource Sut => _testUser.Ingestion;
+  private Project _project;
+  private Model _model;
+  private IOperations _operations;
+
+  public Task DisposeAsync() => Task.CompletedTask;
+
+  public async Task InitializeAsync()
+  {
+    var serviceProvider = TestServiceSetup.GetServiceProvider();
+    _operations = serviceProvider.GetRequiredService<IOperations>();
+
+    _testUser = await Fixtures.SeedUserWithClient();
+    _project = await _testUser.Project.Create(new("Test project", "", null));
+    _model = await _testUser.Model.Create(new("Test Model 1", "", _project.id));
+  }
+
+  [Fact]
+  public async Task CreateAndError()
+  {
+    var createInput = new ModelIngestionCreateInput(
+      _model.id,
+      _project.id,
+      "Starting processing",
+      new(".NET test runner", "0.0.0", null, null)
+    );
+    ModelIngestion ingest = await Sut.Create(createInput);
+
+    var errorInput = new ModelIngestionFailedInput(ingest.id, _project.id, "A bad thing happened", "Over hear!");
+    var res = await Sut.FailWithError(errorInput);
+    Assert.Equal(ingest.id, res.id);
+  }
+
+  [Fact]
+  public async Task CreateAndUpdate()
+  {
+    var createInput = new ModelIngestionCreateInput(
+      _model.id,
+      _project.id,
+      "Starting processing",
+      new(".NET test runner", "0.0.0", null, null)
+    );
+    ModelIngestion ingest = await Sut.Create(createInput);
+
+    await Update(null, "None");
+    await Update(0.1, "0.1");
+    await Update(0.5, "Whoa-oh! We're half way there!");
+    await Update(1, "Finished");
+    await Update(0.2, "Back to processing again");
+
+    async Task Update(double? progress, string message)
+    {
+      var updateInput = new ModelIngestionUpdateInput(ingest.id, _project.id, message, progress);
+      var res = await Sut.UpdateProgress(updateInput);
+
+      Assert.Equal(message, res.statusData.progressMessage);
+      Assert.False(res.cancellationRequested);
+      Assert.Equal(ModelIngestionStatus.processing, res.statusData.status);
+    }
+  }
+
+  [Fact]
+  public async Task CreateAndCancel()
+  {
+    var createInput = new ModelIngestionCreateInput(
+      _model.id,
+      _project.id,
+      "Starting processing",
+      new(".NET test runner", "0.0.0", null, null)
+    );
+    ModelIngestion ingest = await Sut.Create(createInput);
+
+    var input = new ModelIngestionCancelledInput(
+      ingest.id,
+      _project.id,
+      cancellationMessage: "This was cancelled for testing purposes"
+    );
+    var res = await Sut.FailWithCancel(input);
+    Assert.Equal(ingest.id, res.id);
+  }
+
+  [Fact]
+  public async Task CreateAndComplete()
+  {
+    ModelIngestionCreateInput createInput = new(
+      _model.id,
+      _project.id,
+      "Starting processing",
+      new(".NET test runner", "0.0.0", null, null)
+    );
+    ModelIngestion ingest = await Sut.Create(createInput);
+
+    Base myObject = Fixtures.GenerateNestedObject();
+    var sendResult = await _operations.Send2(
+      _testUser.ServerUrl,
+      _project.id,
+      _testUser.Account.token,
+      myObject,
+      new Progress<ProgressArgs>(x =>
+      {
+        var updateInput = new ModelIngestionUpdateInput(
+          ingest.id,
+          _project.id,
+          $"{x.Count} / {x.Total}",
+          x.Total == null ? null : x.Count / x.Total
+        );
+        _ = Sut.UpdateProgress(updateInput).Result;
+      }),
+      CancellationToken.None,
+      new(true, true)
+    );
+
+    ModelIngestionSuccessInput finish = new(ingest.id, _project.id, sendResult.RootId, "yay!");
+    string versionId = await Sut.Complete(finish);
+    Version version = await _testUser.Version.Get(versionId, _project.id);
+    Assert.Equal(version.id, versionId);
+    Assert.Equal(sendResult.RootId, version.referencedObject);
+  }
+
+  [Fact]
+  public async Task CreateAndGet()
+  {
+    var createInput = new ModelIngestionCreateInput(
+      _model.id,
+      _project.id,
+      "Starting processing",
+      new(".NET test runner", "0.0.0", null, null)
+    );
+    ModelIngestion ingest = await Sut.Create(createInput);
+
+    ModelIngestion res = await Sut.Get(ingest.id, _project.id);
+    Assert.Equal(ingest.id, res.id);
+    Assert.Equal(ingest.statusData.status, res.statusData.status);
+  }
+
+  [Fact]
+  public async Task TestRequeue()
+  {
+    //Not sure if is desirable that ingestions created by the modelIngestionMutations.create mutation can be re-queued
+    //But the server allows it, so we test it
+    var createInput = new ModelIngestionCreateInput(
+      _model.id,
+      _project.id,
+      "Starting processing",
+      new(".NET test runner", "0.0.0", null, null)
+    );
+    var ingestion = await Sut.Create(createInput);
+    var res = await Sut.Requeue(new(ingestion.id, _project.id, "we'll try and requeue this ingestion"));
+
+    Assert.Equal(ingestion.id, res.id);
+    Assert.Equal(ModelIngestionStatus.queued, res.statusData.status);
+  }
+
+  [Fact]
+  public async Task TestStartProcessing()
+  {
+    //Not sure if is desirable that StartProcessing can be used by ingestions created by the modelIngestionMutations.create mutation
+    //But the server allows it, so we test it
+    var createInput = new ModelIngestionCreateInput(
+      _model.id,
+      _project.id,
+      "Starting processing",
+      new(".NET test runner", "0.0.0", null, null)
+    );
+    var ingestion = await Sut.Create(createInput);
+    var res = await Sut.StartProcessing(
+      new(ingestion.id, _project.id, "", new SourceDataInput("what", "happens", "now", 0))
+    );
+
+    Assert.Equal(ingestion.id, res.id);
+    Assert.Equal(ModelIngestionStatus.processing, res.statusData.status);
+  }
+}

tests/Speckle.Sdk.Tests.Integration/Api/GraphQL/Resources/ModelResourceTests.cs

@@ -1,5 +1,6 @@
 using FluentAssertions;
 using Speckle.Sdk.Api;
+using Speckle.Sdk.Api.GraphQL.Enums;
 using Speckle.Sdk.Api.GraphQL.Inputs;
 using Speckle.Sdk.Api.GraphQL.Models;
 using Speckle.Sdk.Api.GraphQL.Resources;
@@ -17,7 +18,7 @@ public class ModelResourceTests : IAsyncLifetime
   {
     // Runs instead of [SetUp] in NUnit
     _testUser = await Fixtures.SeedUserWithClient();
-    _project = await _testUser.Project.Create(new("Test project", "", null));
+    _project = await _testUser.Project.Create(new("Test project", "", ProjectVisibility.Public));
     _model = await _testUser.Model.Create(new("Test Model", "", _project.id));
   }
 
@@ -123,4 +124,40 @@ public class ModelResourceTests : IAsyncLifetime
     var delEx = await FluentActions.Invoking(() => Sut.Delete(input)).Should().ThrowAsync<AggregateException>();
     getEx.WithInnerExceptionExactly<SpeckleGraphQLException>();
   }
+
+  [Fact]
+  public async Task TestUserHasModelPermissions()
+  {
+    var ownerResult = await Sut.GetPermissions(_project.id, _model.id);
+    ownerResult.canUpdate.authorized.Should().Be(true);
+    ownerResult.canCreateVersion.authorized.Should().Be(true);
+    ownerResult.canDelete.authorized.Should().Be(true);
+
+    // Test with another user
+    var guest = await Fixtures.SeedUserWithClient();
+
+    var guestResult = await guest.Model.GetPermissions(_project.id, _model.id);
+    guestResult.canUpdate.authorized.Should().Be(false);
+    guestResult.canCreateVersion.authorized.Should().Be(false);
+    guestResult.canDelete.authorized.Should().Be(false);
+  }
+
+  [Fact]
+  [Trait("Server", "Internal")]
+  public async Task TestCanCreateModelIngestion_InternalServer()
+  {
+    var ownerResult = await Sut.CanCreateModelIngestion(_project.id, _model.id);
+    ownerResult.authorized.Should().Be(true);
+  }
+
+  [Fact]
+  [Trait("Server", "Public")]
+  public async Task TestCanCreateModelIngestion_PublicServer_Throws()
+  {
+    var ex = await Assert.ThrowsAsync<AggregateException>(async () =>
+      await Sut.CanCreateModelIngestion(_project.id, _model.id)
+    );
+    ex.InnerExceptions.Should().HaveCount(1);
+    ex.InnerExceptions.Should().AllBeOfType<SpeckleGraphQLInvalidQueryException>();
+  }
 }

tests/Speckle.Sdk.Tests.Integration/Api/GraphQL/Resources/ProjectResourceTests.cs

@@ -103,8 +103,30 @@ public class ProjectResourceTests
   [Fact]
   public async Task TestUserHasProjectPermissions()
   {
-    var res = await Sut.GetPermissions(_testProject.id);
+    var privateProject = await _testUser.Project.Create(
+      new ProjectCreateInput("asdfasdf", "desc", ProjectVisibility.Private)
+    );
+
+    var resp = await Sut.GetPermissions(privateProject.id);
+    resp.canCreateModel.authorized.Should().Be(true);
+    resp.canDelete.authorized.Should().Be(true);
+    resp.canLoad.authorized.Should().Be(true);
+
+    var publicProject = await _testUser.Project.Create(
+      new ProjectCreateInput("asdfasdf", "desc", ProjectVisibility.Public)
+    );
+
+    var res = await Sut.GetPermissions(publicProject.id);
     res.canCreateModel.authorized.Should().Be(true);
     res.canDelete.authorized.Should().Be(true);
+    res.canLoad.authorized.Should().Be(true);
+
+    // Test with another user
+    var guest = await Fixtures.SeedUserWithClient();
+
+    var guestResult = await guest.Project.GetPermissions(publicProject.id);
+    guestResult.canCreateModel.authorized.Should().Be(false);
+    guestResult.canDelete.authorized.Should().Be(false);
+    guestResult.canLoad.authorized.Should().Be(false);
   }
 }

tests/Speckle.Sdk.Tests.Integration/Api/GraphQL/Resources/SubscriptionResourceTests.cs

@@ -1,4 +1,4 @@
-using FluentAssertions;
+using FluentAssertions;
 using Speckle.Sdk.Api;
 using Speckle.Sdk.Api.GraphQL.Enums;
 using Speckle.Sdk.Api.GraphQL.Inputs;
@@ -11,11 +11,11 @@ namespace Speckle.Sdk.Tests.Integration.API.GraphQL.Resources;
 public class SubscriptionResourceTests : IAsyncLifetime
 {
 #if DEBUG
-  private const int WAIT_PERIOD = 3000; // WSL is slow AF, so for local runs, we're being extra generous
+  private const int WAIT_PERIOD = 4000; // WSL is slow AF, so for local runs, we're being extra generous
 #else
-  private const int WAIT_PERIOD = 400; // For CI runs, a much smaller wait time is acceptable
+  private const int WAIT_PERIOD = 500; // For CI runs, a much smaller wait time is acceptable
 #endif
-  private const int TIMEOUT = WAIT_PERIOD + WAIT_PERIOD + 400;
+  private const int TIMEOUT = WAIT_PERIOD + WAIT_PERIOD + 500;
   private IClient _testUser;
   private Project _testProject;
   private Model _testModel;
@@ -80,15 +80,15 @@ public class SubscriptionResourceTests : IAsyncLifetime
   public async Task ProjectUpdated_SubscriptionIsCalled()
   {
     TaskCompletionSource<ProjectUpdatedMessage> tcs = new();
-    using var sub = Sut.CreateProjectUpdatedSubscription(_testProject.id);
+    using Subscription<ProjectUpdatedMessage> sub = Sut.CreateProjectUpdatedSubscription(_testProject.id);
     sub.Listeners += (_, message) => tcs.SetResult(message);
 
     await Task.Delay(WAIT_PERIOD); // Give time to subscription to be setup
 
-    var input = new ProjectUpdateInput(_testProject.id, "This is my new name");
-    var created = await _testUser.Project.Update(input);
+    ProjectUpdateInput input = new(_testProject.id, "This is my new name");
+    Project created = await _testUser.Project.Update(input);
 
-    var subscriptionMessage = await tcs.Task;
+    ProjectUpdatedMessage subscriptionMessage = await tcs.Task;
 
     subscriptionMessage.Should().NotBeNull();
     subscriptionMessage.id.Should().Be(created.id);
@@ -135,4 +135,74 @@ public class SubscriptionResourceTests : IAsyncLifetime
     subscriptionMessage.type.Should().Be(ProjectCommentsUpdatedMessageType.CREATED);
     subscriptionMessage.comment.Should().NotBeNull();
   }
+
+  [Fact(Timeout = TIMEOUT), Trait("Server", "Internal")]
+  public async Task ProjectModelIngestionCancellationRequested_SubscriptionIsCalled()
+  {
+    ModelIngestion ingestion = await _testUser.Ingestion.Create(
+      new(_testModel.id, _testProject.id, "", new(".NET test", "0.0.0", null, null))
+    );
+    TaskCompletionSource<ProjectModelIngestionUpdatedMessage> tcs = new();
+
+    using var sub = Sut.CreateProjectModelIngestionCancellationRequestedSubscription(ingestion.id, _testProject.id);
+    sub.Listeners += (_, message) => tcs.SetResult(message);
+
+    await Task.Delay(WAIT_PERIOD); // Give time to subscription to be setup
+
+    await _testUser.Ingestion.RequestCancellation(new(ingestion.id, _testProject.id, "please cancel"));
+
+    var subscriptionMessage = await tcs.Task;
+
+    subscriptionMessage.Should().NotBeNull();
+    subscriptionMessage.type.Should().Be(ProjectModelIngestionUpdatedMessageType.cancellationRequested);
+    subscriptionMessage.modelIngestion.id.Should().Be(ingestion.id);
+  }
+
+  [Fact(Timeout = TIMEOUT), Trait("Server", "Internal")]
+  public async Task ProjectModelIngestionUpdate_UpdateSubscriptionIs()
+  {
+    ModelIngestion ingestion = await _testUser.Ingestion.Create(
+      new(_testModel.id, _testProject.id, "", new(".NET test", "0.0.0", null, null))
+    );
+    TaskCompletionSource<ProjectModelIngestionUpdatedMessage> tcs = new();
+
+    using var sub = Sut.CreateProjectModelIngestionUpdatedSubscription(
+      new(
+        _testProject.id,
+        new ModelIngestionReference(ingestion.id, null),
+        ProjectModelIngestionUpdatedMessageType.updated
+      )
+    );
+    sub.Listeners += (_, message) => tcs.SetResult(message);
+
+    await Task.Delay(WAIT_PERIOD); // Give time to subscription to be setup
+
+    await _testUser.Ingestion.UpdateProgress(new(ingestion.id, _testProject.id, "Here's an update", 0.314));
+
+    var subscriptionMessage = await tcs.Task;
+
+    subscriptionMessage.Should().NotBeNull();
+    subscriptionMessage.type.Should().Be(ProjectModelIngestionUpdatedMessageType.updated);
+    subscriptionMessage.modelIngestion.id.Should().Be(ingestion.id);
+  }
+
+  [Fact(Timeout = TIMEOUT), Trait("Server", "Internal")]
+  public async Task ProjectModelIngestionUpdate_CancelSubscriptionIsNotCalled()
+  {
+    ModelIngestion ingestion = await _testUser.Ingestion.Create(
+      new(_testModel.id, _testProject.id, "", new(".NET test", "0.0.0", null, null))
+    );
+    TaskCompletionSource<ProjectModelIngestionUpdatedMessage> tcs = new();
+
+    using var sub = Sut.CreateProjectModelIngestionCancellationRequestedSubscription(ingestion.id, _testProject.id);
+    sub.Listeners += (_, message) => tcs.SetResult(message);
+
+    await Task.Delay(WAIT_PERIOD); // Give time to subscription to be setup
+
+    await _testUser.Ingestion.UpdateProgress(new(ingestion.id, _testProject.id, "this shouldn't cancel", null));
+
+    await Task.Delay(WAIT_PERIOD); // Give time to subscription to maybe fire
+
+    tcs.Task.IsCompleted.Should().BeFalse();
+  }
 }

tests/Speckle.Sdk.Tests.Integration/Fixtures.cs

@@ -17,6 +17,11 @@ using Version = Speckle.Sdk.Api.GraphQL.Models.Version;
 
 [assembly: AssemblyTrait("Category", "Integration")]
 
+#if DEBUG
+[assembly: CollectionBehavior(MaxParallelThreads = 8)]
+
+#endif
+
 namespace Speckle.Sdk.Tests.Integration;
 
 public static class Fixtures

tests/Speckle.Sdk.Tests.Integration/MemoryTransportTests.cs

@@ -1,8 +1,6 @@
-using System.Reflection;
-using FluentAssertions;
+using FluentAssertions;
 using Microsoft.Extensions.DependencyInjection;
 using Speckle.Sdk.Api;
-using Speckle.Sdk.Host;
 using Speckle.Sdk.Models;
 using Speckle.Sdk.Transports;
 
@@ -16,8 +14,7 @@ public class MemoryTransportTests : IDisposable
   public MemoryTransportTests()
   {
     CleanData();
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, Assembly.GetExecutingAssembly());
+
     var serviceProvider = TestServiceSetup.GetServiceProvider();
     _operations = serviceProvider.GetRequiredService<IOperations>();
   }

tests/Speckle.Sdk.Tests.Integration/SendReceiveTests.cs

@@ -1,11 +1,8 @@
-using System.Reflection;
-using System.Text;
+using System.Text;
 using Microsoft.Extensions.DependencyInjection;
 using Speckle.Sdk.Api;
 using Speckle.Sdk.Api.GraphQL.Enums;
 using Speckle.Sdk.Api.GraphQL.Models;
-using Speckle.Sdk.Host;
-using Speckle.Sdk.Models;
 
 namespace Speckle.Sdk.Tests.Integration;
 
@@ -19,8 +16,6 @@ public sealed class SendReceiveTests : IAsyncLifetime
 
   public async Task InitializeAsync()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, Assembly.GetExecutingAssembly());
     var serviceProvider = TestServiceSetup.GetServiceProvider();
     _operations = serviceProvider.GetRequiredService<IOperations>();
     ClearCache();

tests/Speckle.Sdk.Tests.Unit/Api/Operations/ClosureTests.cs

@@ -10,14 +10,14 @@ using Speckle.Sdk.Transports;
 
 namespace Speckle.Sdk.Tests.Unit.Api.Operations;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class Closures
 {
   private readonly IOperations _operations;
 
   public Closures()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(TableLegFixture).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(TableLegFixture).Assembly);
     var serviceProvider = TestServiceSetup.GetServiceProvider();
     _operations = serviceProvider.GetRequiredService<IOperations>();
   }

tests/Speckle.Sdk.Tests.Unit/Api/Operations/OperationsReceiveTests.cs

@@ -7,6 +7,7 @@ using Speckle.Sdk.Transports;
 
 namespace Speckle.Sdk.Tests.Unit.Api.Operations;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public sealed partial class OperationsReceiveTests : IDisposable
 {
   private static readonly Base[] s_testObjects;
@@ -44,8 +45,7 @@ public sealed partial class OperationsReceiveTests : IDisposable
 
   private static void Reset()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, Assembly.GetExecutingAssembly());
+    TypeLoader.ReInitialize(typeof(Base).Assembly, Assembly.GetExecutingAssembly());
   }
 
   public static IEnumerable<object[]> TestCases()

tests/Speckle.Sdk.Tests.Unit/Api/Operations/SendObjectReferences.cs

@@ -7,14 +7,14 @@ using Speckle.Sdk.Transports;
 
 namespace Speckle.Sdk.Tests.Unit.Api.Operations;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class SendObjectReferences
 {
   private readonly IOperations _operations;
 
   public SendObjectReferences()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(DataChunk).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(DataChunk).Assembly);
     var serviceProvider = TestServiceSetup.GetServiceProvider();
     _operations = serviceProvider.GetRequiredService<IOperations>();
   }

tests/Speckle.Sdk.Tests.Unit/Api/Operations/SendReceiveLocal.cs

@@ -9,14 +9,14 @@ using Speckle.Sdk.Transports;
 
 namespace Speckle.Sdk.Tests.Unit.Api.Operations;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public sealed class SendReceiveLocal : IDisposable
 {
   private readonly IOperations _operations;
 
   public SendReceiveLocal()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(Point).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(Point).Assembly);
     var serviceProvider = TestServiceSetup.GetServiceProvider();
     _operations = serviceProvider.GetRequiredService<IOperations>();
   }

tests/Speckle.Sdk.Tests.Unit/Api/Operations/SerializationTests.cs

@@ -9,14 +9,14 @@ using Point = Speckle.Sdk.Tests.Unit.Host.Point;
 
 namespace Speckle.Sdk.Tests.Unit.Api.Operations;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class ObjectSerialization
 {
   private readonly IOperations _operations;
 
   public ObjectSerialization()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(DataChunk).Assembly, typeof(ColorMock).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(DataChunk).Assembly, typeof(ColorMock).Assembly);
     var serviceProvider = TestServiceSetup.GetServiceProvider();
     _operations = serviceProvider.GetRequiredService<IOperations>();
   }

tests/Speckle.Sdk.Tests.Unit/Assembly.cs

@@ -1 +1 @@
-[assembly: CollectionBehavior(DisableTestParallelization = true)]
+[assembly: CollectionBehavior()]

tests/Speckle.Sdk.Tests.Unit/Collections.cs

@@ -0,0 +1,7 @@
+namespace Speckle.Sdk.Tests.Unit;
+
+[CollectionDefinition(nameof(RequiresTypeLoaderCollection), DisableParallelization = true)]
+public class RequiresTypeLoaderCollection;
+
+[CollectionDefinition(nameof(RequiresSqLiteAccountDb), DisableParallelization = true)]
+public class RequiresSqLiteAccountDb;

tests/Speckle.Sdk.Tests.Unit/Credentials/AccountManagerTests.cs

@@ -9,6 +9,7 @@ using Speckle.Sdk.Testing;
 
 namespace Speckle.Sdk.Tests.Unit.Credentials;
 
+[Collection(nameof(RequiresSqLiteAccountDb))]
 public sealed class AccountManagerTests : MoqTest
 {
   private class TestAccountFactory : IAccountFactory

tests/Speckle.Sdk.Tests.Unit/Credentials/AccountServerMigrationTests.cs

@@ -5,6 +5,7 @@ using Speckle.Sdk.Credentials;
 
 namespace Speckle.Sdk.Tests.Unit.Credentials;
 
+[Collection(nameof(RequiresSqLiteAccountDb))]
 public class AccountServerMigrationTests : IDisposable
 {
   private readonly List<Account> _accountsToCleanUp = [];

tests/Speckle.Sdk.Tests.Unit/Credentials/Accounts.cs

@@ -5,6 +5,7 @@ using Speckle.Sdk.Credentials;
 
 namespace Speckle.Sdk.Tests.Unit.Credentials;
 
+[Collection(nameof(RequiresSqLiteAccountDb))]
 public class CredentialInfrastructure : IDisposable
 {
   private readonly IAccountManager _accountManager;

tests/Speckle.Sdk.Tests.Unit/Models/BaseTests.cs

@@ -5,12 +5,12 @@ using Speckle.Sdk.Models;
 
 namespace Speckle.Sdk.Tests.Unit.Models;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class BaseTests
 {
   public BaseTests()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(BaseTests).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(BaseTests).Assembly);
   }
 
   [Fact]

tests/Speckle.Sdk.Tests.Unit/Models/DynamicBaseTests.cs

@@ -5,12 +5,12 @@ using Speckle.Sdk.Models;
 
 namespace Speckle.Sdk.Tests.Unit.Models;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class DynamicBaseTests
 {
   public DynamicBaseTests()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(BaseTests).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(BaseTests).Assembly);
   }
 
   [Fact]

tests/Speckle.Sdk.Tests.Unit/Models/Extensions/BaseExtensionsTests.cs

@@ -6,12 +6,12 @@ using Speckle.Sdk.Models.Extensions;
 
 namespace Speckle.Sdk.Tests.Unit.Models.Extensions;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class BaseExtensionsTests
 {
   public BaseExtensionsTests()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(TestBase).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(TestBase).Assembly);
   }
 
   [Theory]

tests/Speckle.Sdk.Tests.Unit/Models/Extensions/DisplayValueTests.cs

@@ -5,6 +5,7 @@ using Speckle.Sdk.Models.Extensions;
 
 namespace Speckle.Sdk.Tests.Unit.Models.Extensions;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class DisplayValueTests
 {
   private const string PAYLOAD = "This is my payload";
@@ -17,8 +18,7 @@ public class DisplayValueTests
 
   private static void Reset()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly);
   }
 
   [Fact]

tests/Speckle.Sdk.Tests.Unit/Models/GraphTraversal/GraphTraversalTests.cs

@@ -6,12 +6,12 @@ using Speckle.Sdk.Models.GraphTraversal;
 
 namespace Speckle.Sdk.Tests.Unit.Models.GraphTraversal;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class GraphTraversalTests
 {
   public GraphTraversalTests()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(TraversalMock).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(TraversalMock).Assembly);
   }
 
   private static IEnumerable<TraversalContext> Traverse(Base testCase, params ITraversalRule[] rules)

tests/Speckle.Sdk.Tests.Unit/Models/Hashing.cs

@@ -6,13 +6,12 @@ using Speckle.Sdk.Tests.Unit.Host;
 
 namespace Speckle.Sdk.Tests.Unit.Models;
 
-// Removed [TestFixture] and [TestOf] annotations as they are NUnit specific
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class Hashing
 {
   public Hashing()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(DiningTable).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(DiningTable).Assembly);
   }
 
   [Fact(DisplayName = "Checks that hashing (as represented by object IDs) actually works.")]

tests/Speckle.Sdk.Tests.Unit/Models/SpeckleType.cs

@@ -5,13 +5,13 @@ using Speckle.Sdk.Tests.Unit.Models.TestModels;
 
 namespace Speckle.Sdk.Tests.Unit.Models
 {
+  [Collection(nameof(RequiresTypeLoaderCollection))]
   public class SpeckleTypeTests
   {
     public SpeckleTypeTests()
     {
       // Setup logic during test class initialization
-      TypeLoader.Reset();
-      TypeLoader.Initialize(typeof(Base).Assembly, typeof(Foo).Assembly);
+      TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(Foo).Assembly);
     }
 
     [Theory]

tests/Speckle.Sdk.Tests.Unit/Serialisation/ChunkingTests.cs

@@ -7,13 +7,13 @@ using Speckle.Sdk.Transports;
 
 namespace Speckle.Sdk.Tests.Unit.Serialisation;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class ChunkingTests
 {
   public static IEnumerable<object[]> TestCases()
   {
     // Initialize type loader
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(IgnoreTest).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(IgnoreTest).Assembly);
 
     // Return test data as a collection of objects for xUnit
     yield return [CreateDynamicTestCase(10, 100), 10];

tests/Speckle.Sdk.Tests.Unit/Serialisation/JsonIgnoreAttributeTests.cs

@@ -12,12 +12,12 @@ namespace Speckle.Sdk.Tests.Unit.Serialisation;
 /// Tests that the <see cref="JsonIgnoreAttribute"/> leads to properties being ignored both from the final JSON output,
 /// But also from the id calculation
 /// </summary>
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public sealed class JsonIgnoreRespected
 {
   public JsonIgnoreRespected()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(IgnoreTest).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(IgnoreTest).Assembly);
   }
 
   public static IEnumerable<object[]> IgnoredTestCases()

tests/Speckle.Sdk.Tests.Unit/Serialisation/ObjectModelDeprecationTests.cs

@@ -5,13 +5,13 @@ using Speckle.Sdk.Serialisation.Deprecated;
 
 namespace Speckle.Sdk.Tests.Unit.Serialisation
 {
+  [Collection(nameof(RequiresTypeLoaderCollection))]
   public class TypeLoaderTests
   {
     // Constructor replaces the [SetUp] functionality in NUnit
     public TypeLoaderTests()
     {
-      TypeLoader.Reset();
-      TypeLoader.Initialize(typeof(Base).Assembly, typeof(MySpeckleBase).Assembly);
+      TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(MySpeckleBase).Assembly);
     }
 
     [Fact] // Replaces [Test]

tests/Speckle.Sdk.Tests.Unit/Serialisation/SerializerBreakingChanges.cs

@@ -14,6 +14,7 @@ namespace Speckle.Sdk.Tests.Unit.Serialisation;
 /// This doesn't guarantee things work this way for SpecklePy
 /// Nor does it encompass other tricks (like deserialize callback, or computed json ignored properties)
 /// </summary>
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class SerializerBreakingChanges : PrimitiveTestFixture
 {
   private readonly IOperations _operations;
@@ -21,8 +22,7 @@ public class SerializerBreakingChanges : PrimitiveTestFixture
   // xUnit does not support a Setup method; instead, you can use the constructor for initialization.
   public SerializerBreakingChanges()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(Base).Assembly, typeof(Point).Assembly);
+    TypeLoader.ReInitialize(typeof(Base).Assembly, typeof(Point).Assembly);
     var serviceProvider = TestServiceSetup.GetServiceProvider();
     _operations = serviceProvider.GetRequiredService<IOperations>();
   }

tests/Speckle.Sdk.Tests.Unit/Serialisation/SerializerNonBreakingChanges.cs

@@ -9,14 +9,14 @@ using Matrix4x4 = Speckle.DoubleNumerics.Matrix4x4;
 
 namespace Speckle.Sdk.Tests.Unit.Serialisation;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class SerializerNonBreakingChanges : PrimitiveTestFixture
 {
   private readonly IOperations _operations;
 
   public SerializerNonBreakingChanges()
   {
-    TypeLoader.Reset();
-    TypeLoader.Initialize(typeof(StringValueMock).Assembly);
+    TypeLoader.ReInitialize(typeof(StringValueMock).Assembly);
     var serviceProvider = TestServiceSetup.GetServiceProvider();
     _operations = serviceProvider.GetRequiredService<IOperations>();
   }

tests/Speckle.Sdk.Tests.Unit/Serialisation/SimpleRoundTripTests.cs

@@ -1,17 +1,20 @@
 using FluentAssertions;
 using Microsoft.Extensions.DependencyInjection;
 using Speckle.Sdk.Api;
+using Speckle.Sdk.Host;
 using Speckle.Sdk.Models;
 using Speckle.Sdk.Tests.Unit.Host;
 
 namespace Speckle.Sdk.Tests.Unit.Serialisation;
 
+[Collection(nameof(RequiresTypeLoaderCollection))]
 public class SimpleRoundTripTests
 {
   private readonly IOperations _operations;
 
   public SimpleRoundTripTests()
   {
+    TypeLoader.ReInitialize(typeof(DiningTable).Assembly);
     var serviceProvider = TestServiceSetup.GetServiceProvider();
     _operations = serviceProvider.GetRequiredService<IOperations>();
   }