diff --git a/.editorconfig b/.editorconfig
index bcf8005..b56ce51 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -133,3 +133,34 @@ resharper_place_attribute_on_same_line = false
 # dotnet options
 #dotnet_sort_system_directives_first = true
 #dotnet_separate_import_directive_groups = false
+
+# dotnet field naming rules
+dotnet_naming_rule.private_constants_rule.severity = error
+dotnet_naming_rule.private_constants_rule.style = k_upper_camel_case_style
+dotnet_naming_rule.private_constants_rule.symbols = private_constants_symbols
+dotnet_naming_rule.private_instance_fields_rule.severity = error
+dotnet_naming_rule.private_instance_fields_rule.style = m_upper_camel_case_style
+dotnet_naming_rule.private_instance_fields_rule.symbols = private_instance_fields_symbols
+dotnet_naming_rule.private_static_fields_rule.severity = error
+dotnet_naming_rule.private_static_fields_rule.style = s_upper_camel_case_style
+dotnet_naming_rule.private_static_fields_rule.symbols = private_static_fields_symbols
+dotnet_naming_rule.private_static_readonly_rule.severity = error
+dotnet_naming_rule.private_static_readonly_rule.style = k_upper_camel_case_style
+dotnet_naming_rule.private_static_readonly_rule.symbols = private_static_readonly_symbols
+dotnet_naming_style.k_upper_camel_case_style.capitalization = pascal_case
+dotnet_naming_style.k_upper_camel_case_style.required_prefix = k_
+dotnet_naming_style.m_upper_camel_case_style.capitalization = pascal_case
+dotnet_naming_style.m_upper_camel_case_style.required_prefix = m_
+dotnet_naming_style.s_upper_camel_case_style.capitalization = pascal_case
+dotnet_naming_style.s_upper_camel_case_style.required_prefix = s_
+dotnet_naming_symbols.private_constants_symbols.applicable_accessibilities = private
+dotnet_naming_symbols.private_constants_symbols.applicable_kinds = field
+dotnet_naming_symbols.private_constants_symbols.required_modifiers = const
+dotnet_naming_symbols.private_instance_fields_symbols.applicable_accessibilities = private
+dotnet_naming_symbols.private_instance_fields_symbols.applicable_kinds = field
+dotnet_naming_symbols.private_static_fields_symbols.applicable_accessibilities = private
+dotnet_naming_symbols.private_static_fields_symbols.applicable_kinds = field
+dotnet_naming_symbols.private_static_fields_symbols.required_modifiers = static
+dotnet_naming_symbols.private_static_readonly_symbols.applicable_accessibilities = private
+dotnet_naming_symbols.private_static_readonly_symbols.applicable_kinds = field
+dotnet_naming_symbols.private_static_readonly_symbols.required_modifiers = static, readonly
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3331408..9e7fafc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,12 +5,46 @@ All notable changes to UGS CLI will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+# [1.0.0-beta.5] - 2023-06-28
+
+### Added
+- Added Batching to import and deploy to help prevent "Too Many Requests" error.
+- Cloud Code Modules now supports `import` and `export` commands.
+- Cloud Code Scripts now supports `import` and `export` commands.
+- Lobby now supports `import` and `export` commands.
+- Leaderboard now supports `import` and `export` commands.
+- Remote Config now supports `import` and `export` commands.
+- Alpine build now added to the release.
+- New option `--services` to deploy and fetch commands. This option perform commands only to specified services.
+  * **[Breaking Change]** This option is mandatory when using the `--reconcile` flag.
+
+### Changed
+- **[Breaking Change]** CloudCode `list` command for Modules and Scripts is more descriptive.
+- Using standardized output for all Import/Export implementations.
+- Plain text Deploy/Fetch Output now prints full path.
+  * This is to disambiguate output regarding files with same name, but different path.
+- **[Breaking Change]** Messages are directed to StdErr and Output into Stdout.
+  * This allows to pipe individual parts such as `ugs cmd 1>output 2>logs.txt`.
+  * In both json and regular formats.
+- **[Breaking Change]** Cloud Code create, delete, get, list, new-file, publish and update commands are now under a parent command `scripts` and can be called with `cloud-code scripts <command>`.
+
+### Fixed
+- CloudCode files that failed to read now reported properly in the output.
+- CloudCode deleted files properly reported in the Deploy output.
+- RemoteConfig Entries properly reported in the Deploy output.
+- RemoteConfig Fetch properly bubbles issues in loading files.
+- **[Breaking Change]** Deploy and Fetch output have been modified to match each other.
+  * Status have been updated to reflect what is happening in the editor.
+- An issue where fetching a file from Cloud Code that had no parameters would keep appending `module.exports.parameters = {}`.
+- Using Cloud Code fetch and deploy multiple times does not keep appending new lines anymore.
+- Improved error handling to provide more detail on certain unhandled exceptions.
+- Cloud Code script with invalid parameters will fail to fetch and show in the "failed" result section.
+
 ## [1.0.0-beta.4] - 2023-04-24
 
 ### Added
 
 - npm distribution. Install the CLI by running `npm install -g ugs`.
-- new-file command for economy
 - `ugs fetch` now supports cloud code scripts.
 - Get player command in Player Module. Run `ugs player get -h` to show usage.
 - List player command in Player Module. Run `ugs player list -h` to show usage.
@@ -21,6 +55,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - **[Breaking Change]** Replace Jint with Node.js for cloud code javascript parameter parsing. User will need to install Node.js with
   version > 14.0.0 to parse cloud code javascript.
 - Updated Diagnostics to use UnityAnalyticSender instead of TelemetrySender
+- Add support for `import` and `export` commands to the Lobby module.
 
 ### Fixed
 
diff --git a/Samples/Deploy/Economy/resource.ec b/Samples/Deploy/Economy/resource.ec
new file mode 100644
index 0000000..70335a9
--- /dev/null
+++ b/Samples/Deploy/Economy/resource.ec
@@ -0,0 +1,8 @@
+{
+    "id": "GOLD",
+    "name": "Gold",
+    "type": "CURRENCY",
+    "initial": 10,
+    "max": 1000,
+    "customData": null
+}
diff --git a/Samples/Deploy/instructions.md b/Samples/Deploy/instructions.md
index ad4677b..dd2a31e 100644
--- a/Samples/Deploy/instructions.md
+++ b/Samples/Deploy/instructions.md
@@ -57,6 +57,30 @@ To create a deployable remote config file, you need a `.rc` file with the follow
 ```
 Please take [configuration.rc] as an example. For more details, please check [Remote Config files].
 
+## Deploy Economy
+
+Run command from [Samples/Deploy] directory:
+```
+ugs deploy ./Economy
+```
+You will find the resource from [resource.ec] published in your dashboard for the configured project and environment.
+
+### Create Economy Files:
+
+To create a deployable economy file, you need a `.ec` file with the following pattern:
+```Json
+{
+  "id": "GOLD",
+  "name": "Gold",
+  "type": "CURRENCY",
+  "initial": 10,
+  "max": 1000,
+  "customData": null
+}
+```
+Please take [resource.ec] as an example. There are other patterns for Inventory item, virtual and real money purchase, for more details, please check [Economy resource schemas].
+
+
 ## Deploy all Samples
 Run command from [Samples/Deploy] directory:
 ```
@@ -67,9 +91,11 @@ You will find all the contents deployed in your dashboard for the configured pro
 ---
 [`deploy`]: https://services.docs.unity.com/guides/ugs-cli/latest/general/base-commands/deploy
 [Remote Config files]: https://docs.unity3d.com/Packages/com.unity.remote-config@3.3/manual/Authoring/remote_config_files.html
+[Economy resource schemas]: https://services.docs.unity.com/economy-admin/v2#tag/Economy-Admin/operation/addConfigResource
 [Declare parameters in the script]: https://docs.unity.com/cloud-code/authoring-scripts-editor.html#Declare_parameters_in_the_script
 [Script.js]: /Samples/Deploy/CloudCode/Script.js
 [configuration.rc]: /Samples/Deploy/RemoteConfig/configuration.rc
+[resource.ec]: /Samples/Deploy/Economy/resource.ec
 [Samples/Deploy]: /Samples/Deploy
 [Deploy Command]: https://services.docs.unity.com/guides/ugs-cli/latest/general/troubleshooting/project-roles#deploy-command
 [Service Account]: https://services.docs.unity.com/docs/service-account-auth/index.html
diff --git a/Third Party Notices.md b/Third Party Notices.md
index 68b9211..ff5cf69 100644
--- a/Third Party Notices.md	
+++ b/Third Party Notices.md	
@@ -1,5 +1,73 @@
 # This package contains third-party software components governed by the license(s) indicated below:
 
+Component Name: Polly
+
+License Type: BSD 3-Clause License
+
+Copyright (c) 2015-2023, App vNext
+
+https://github.com/App-vNext/Polly/blob/main/LICENSE
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+<hr>
+
+Component Name: Polly.Extensions.Http
+
+License Type: New BSD License
+
+Copyright (c) 2015-2018, App vNext
+All rights reserved.
+
+https://github.com/App-vNext/Polly.Extensions.Http/blob/master/LICENSE.txt
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+* Neither the name of App vNext nor the
+names of its contributors may be used to endorse or promote products
+derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+<hr>
+
 Component Name: Coverlet
 
 License Type: MIT
diff --git a/Unity.Services.Cli/.run/Cli.run.xml b/Unity.Services.Cli/.run/Cli.run.xml
index 864c9b0..1c779dc 100644
--- a/Unity.Services.Cli/.run/Cli.run.xml
+++ b/Unity.Services.Cli/.run/Cli.run.xml
@@ -17,4 +17,4 @@
       <option name="Build" />
     </method>
   </configuration>
-</component>
\ No newline at end of file
+</component>
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/AccessModuleTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/AccessModuleTests.cs
index 71caa17..77da005 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/AccessModuleTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/AccessModuleTests.cs
@@ -15,7 +15,7 @@ namespace Unity.Services.Cli.Access.UnitTest;
 [TestFixture]
 public class AccessModuleTests
 {
-    private readonly AccessModule k_AccessModule = new();
+    readonly AccessModule k_AccessModule = new();
 
     [Test]
     public void BuildCommands_CreateCommands()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetAllPlayerPoliciesHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetAllPlayerPoliciesHandlerTests.cs
index 904078c..17f5222 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetAllPlayerPoliciesHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetAllPlayerPoliciesHandlerTests.cs
@@ -16,9 +16,9 @@ namespace Unity.Services.Cli.Access.UnitTest.Handlers;
 [TestFixture]
 public class GetAllPlayerPoliciesHandlerTests
 {
-    private readonly Mock<IAccessService> m_MockAccessService = new();
-    private readonly Mock<ILogger> m_MockLogger = new();
-    private readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<IAccessService> m_MockAccessService = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
     [SetUp]
     public void SetUp()
@@ -35,7 +35,7 @@ public async Task GetAllPlayerPoliciesAsync_CallsLoadingIndicator()
         await GetAllPlayerPoliciesHandler.GetAllPlayerPoliciesAsync(null!, null!, null!, null!,
             mockLoadingIndicator.Object, CancellationToken.None);
         mockLoadingIndicator.Verify(ex => ex
-            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?,Task>>()), Times.Once);
+            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?, Task>>()), Times.Once);
     }
 
     [Test]
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetPlayerPolicyHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetPlayerPolicyHandlerTests.cs
index dc9d233..142963d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetPlayerPolicyHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetPlayerPolicyHandlerTests.cs
@@ -17,9 +17,9 @@ namespace Unity.Services.Cli.Access.UnitTest.Handlers;
 [TestFixture]
 public class GetPlayerPolicyHandlerTests
 {
-    private readonly Mock<IAccessService> m_MockAccessService = new();
-    private readonly Mock<ILogger> m_MockLogger = new();
-    private readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<IAccessService> m_MockAccessService = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
     [SetUp]
     public void SetUp()
@@ -36,7 +36,7 @@ public async Task GetPlayerPolicyAsync_CallsLoadingIndicator()
         await GetPlayerPolicyHandler.GetPlayerPolicyAsync(null!, null!, null!, null!,
             mockLoadingIndicator.Object, CancellationToken.None);
         mockLoadingIndicator.Verify(ex => ex
-            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?,Task>>()), Times.Once);
+            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?, Task>>()), Times.Once);
     }
 
     [Test]
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetProjectPolicyHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetProjectPolicyHandlerTests.cs
index 2a062b2..03a459e 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetProjectPolicyHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Handlers/GetProjectPolicyHandlerTests.cs
@@ -17,9 +17,9 @@ namespace Unity.Services.Cli.Access.UnitTest.Handlers;
 [TestFixture]
 public class GetProjectPolicyHandlerTests
 {
-    private readonly Mock<IAccessService> m_MockAccessService = new();
-    private readonly Mock<ILogger> m_MockLogger = new();
-    private readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<IAccessService> m_MockAccessService = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
     [SetUp]
     public void SetUp()
@@ -36,7 +36,7 @@ public async Task GetProjectPolicyAsync_CallsLoadingIndicator()
         await GetProjectPolicyHandler.GetProjectPolicyAsync(null!, null!, null!, null!,
             mockLoadingIndicator.Object, CancellationToken.None);
         mockLoadingIndicator.Verify(ex => ex
-            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?,Task>>()), Times.Once);
+            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?, Task>>()), Times.Once);
     }
 
     [Test]
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Service/AccessServiceTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Service/AccessServiceTests.cs
index 7743e3c..0f5f845 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Service/AccessServiceTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access.UnitTest/Service/AccessServiceTests.cs
@@ -15,15 +15,15 @@ namespace Unity.Services.Cli.Access.UnitTest.Service;
 public class AccessServiceTests
 {
     readonly Mock<IServiceAccountAuthenticationService> m_AuthenticationServiceObject = new();
-    private readonly Mock<IPlayerPolicyApi> m_PlayerPolicyApi = new();
-    private readonly Mock<IProjectPolicyApi> m_ProjectPolicyApi = new();
+    readonly Mock<IPlayerPolicyApi> m_PlayerPolicyApi = new();
+    readonly Mock<IProjectPolicyApi> m_ProjectPolicyApi = new();
 
-    AccessService m_AccessService;
-    FileInfo m_PolicyFile;
-    FileInfo m_DeleteOptionsFile;
-    FileInfo m_WrongFormattedFile;
+    AccessService? m_AccessService;
+    FileInfo? m_PolicyFile;
+    FileInfo? m_DeleteOptionsFile;
+    FileInfo? m_WrongFormattedFile;
 
-    private static async Task<FileInfo> GetFileInfoObjectAsync(string fileName, string jsonString)
+    static async Task<FileInfo> GetFileInfoObjectAsync(string fileName, string jsonString)
     {
         var filePath = Path.Combine(Path.GetTempPath(), fileName);
 
@@ -209,7 +209,7 @@ public void DeletePolicyStatementsAsync_InvalidInput()
     [Test]
     public async Task DeletePlayerPolicyStatementsAsync_Valid()
     {
-        m_PlayerPolicyApi.Setup(a => a.DeletePlayerPolicyStatementsAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),It.IsAny<DeleteOptions>(), It.IsAny<int>(), CancellationToken.None));
+        m_PlayerPolicyApi.Setup(a => a.DeletePlayerPolicyStatementsAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<DeleteOptions>(), It.IsAny<int>(), CancellationToken.None));
 
         await m_AccessService!.DeletePlayerPolicyStatementsAsync(TestValues.ValidProjectId, TestValues.ValidEnvironmentId, TestValues.ValidPlayerId, m_DeleteOptionsFile,
             CancellationToken.None);
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/DeletePlayerPolicyStatementsHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/DeletePlayerPolicyStatementsHandler.cs
index 0e1f7f2..abb59a4 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/DeletePlayerPolicyStatementsHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/DeletePlayerPolicyStatementsHandler.cs
@@ -6,7 +6,7 @@
 
 namespace Unity.Services.Cli.Access.Handlers;
 
-internal static class DeletePlayerPolicyStatementsHandler
+static class DeletePlayerPolicyStatementsHandler
 {
     public static async Task DeletePlayerPolicyStatementsAsync(AccessInput input, IUnityEnvironment environment, IAccessService accessService,
         ILogger logger, ILoadingIndicator loadingIndicator, CancellationToken cancellationToken)
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/DeleteProjectPolicyStatementsHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/DeleteProjectPolicyStatementsHandler.cs
index 7897080..35787cf 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/DeleteProjectPolicyStatementsHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/DeleteProjectPolicyStatementsHandler.cs
@@ -6,7 +6,7 @@
 
 namespace Unity.Services.Cli.Access.Handlers;
 
-internal static class DeleteProjectPolicyStatementsHandler
+static class DeleteProjectPolicyStatementsHandler
 {
     public static async Task DeleteProjectPolicyStatementsAsync(AccessInput input, IUnityEnvironment environment, IAccessService accessService,
         ILogger logger, ILoadingIndicator loadingIndicator, CancellationToken cancellationToken)
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetAllPlayerPoliciesHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetAllPlayerPoliciesHandler.cs
index ec33aba..80f764f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetAllPlayerPoliciesHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetAllPlayerPoliciesHandler.cs
@@ -8,7 +8,7 @@
 
 namespace Unity.Services.Cli.Access.Handlers;
 
-internal static class GetAllPlayerPoliciesHandler
+static class GetAllPlayerPoliciesHandler
 {
     public static async Task GetAllPlayerPoliciesAsync(CommonInput input, IUnityEnvironment environment, IAccessService accessService,
         ILogger logger, ILoadingIndicator loadingIndicator, CancellationToken cancellationToken)
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetPlayerPolicyHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetPlayerPolicyHandler.cs
index dc15368..8c4f368 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetPlayerPolicyHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetPlayerPolicyHandler.cs
@@ -8,7 +8,7 @@
 
 namespace Unity.Services.Cli.Access.Handlers;
 
-internal static class GetPlayerPolicyHandler
+static class GetPlayerPolicyHandler
 {
     public static async Task GetPlayerPolicyAsync(AccessInput input, IUnityEnvironment environment, IAccessService accessService,
         ILogger logger, ILoadingIndicator loadingIndicator, CancellationToken cancellationToken)
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetProjectPolicyHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetProjectPolicyHandler.cs
index 7d8a7fa..7257eb8 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetProjectPolicyHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/GetProjectPolicyHandler.cs
@@ -8,7 +8,7 @@
 
 namespace Unity.Services.Cli.Access.Handlers;
 
-internal static class GetProjectPolicyHandler
+static class GetProjectPolicyHandler
 {
     public static async Task GetProjectPolicyAsync(CommonInput input, IUnityEnvironment environment, IAccessService accessService,
         ILogger logger, ILoadingIndicator loadingIndicator, CancellationToken cancellationToken)
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/UpsertPlayerPolicyHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/UpsertPlayerPolicyHandler.cs
index 45e71bb..112e19d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/UpsertPlayerPolicyHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/UpsertPlayerPolicyHandler.cs
@@ -6,7 +6,7 @@
 
 namespace Unity.Services.Cli.Access.Handlers;
 
-internal static class UpsertPlayerPolicyHandler
+static class UpsertPlayerPolicyHandler
 {
     public static async Task UpsertPlayerPolicyAsync(AccessInput input, IUnityEnvironment environment, IAccessService accessService,
         ILogger logger, ILoadingIndicator loadingIndicator, CancellationToken cancellationToken)
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/UpsertProjectPolicyHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/UpsertProjectPolicyHandler.cs
index 19e3c07..389f0b6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/UpsertProjectPolicyHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Handlers/UpsertProjectPolicyHandler.cs
@@ -6,7 +6,7 @@
 
 namespace Unity.Services.Cli.Access.Handlers;
 
-internal static class UpsertProjectPolicyHandler
+static class UpsertProjectPolicyHandler
 {
     public static async Task UpsertProjectPolicyAsync(AccessInput input, IUnityEnvironment environment, IAccessService accessService,
         ILogger logger, ILoadingIndicator loadingIndicator, CancellationToken cancellationToken)
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetAllPlayerPoliciesResponseOutput.cs b/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetAllPlayerPoliciesResponseOutput.cs
index 1ad894b..ce24b42 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetAllPlayerPoliciesResponseOutput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetAllPlayerPoliciesResponseOutput.cs
@@ -3,7 +3,7 @@
 
 namespace Unity.Services.Cli.Access.Models;
 
-internal class GetAllPlayerPoliciesResponseOutput
+class GetAllPlayerPoliciesResponseOutput
 {
     public List<PlayerPolicy> Results { get; }
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetPlayerPolicyResponseOutput.cs b/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetPlayerPolicyResponseOutput.cs
index f6be9a6..4828423 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetPlayerPolicyResponseOutput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetPlayerPolicyResponseOutput.cs
@@ -3,7 +3,7 @@
 
 namespace Unity.Services.Cli.Access.Models;
 
-internal class GetPlayerPolicyResponseOutput
+class GetPlayerPolicyResponseOutput
 {
     public PlayerPolicy Policy { get; }
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetPolicyResponseOutput.cs b/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetPolicyResponseOutput.cs
index edad8af..2820d80 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetPolicyResponseOutput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Models/GetPolicyResponseOutput.cs
@@ -3,7 +3,7 @@
 
 namespace Unity.Services.Cli.Access.Models;
 
-internal class GetPolicyResponseOutput
+class GetPolicyResponseOutput
 {
     public Policy Policy { get; }
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Service/AccessService.cs b/Unity.Services.Cli/Unity.Services.Cli.Access/Service/AccessService.cs
index 46ffe3f..7aae91a 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Service/AccessService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Service/AccessService.cs
@@ -22,9 +22,9 @@ public AccessService(IProjectPolicyApi projectPolicyApi, IPlayerPolicyApi player
         m_AuthenticationService = authenticationService;
     }
 
-    private const string JsonIncorrectFormatExceptionMessage = "Please make sure that the format of your JSON input is correct and all required fields are included. If you need help, please refer to the documentation.";
+    const string JsonIncorrectFormatExceptionMessage = "Please make sure that the format of your JSON input is correct and all required fields are included. If you need help, please refer to the documentation.";
 
-    private static string ReadFile(FileInfo file)
+    static string ReadFile(FileInfo file)
     {
         if (!file.Exists)
         {
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Access/Unity.Services.Cli.Access.csproj b/Unity.Services.Cli/Unity.Services.Cli.Access/Unity.Services.Cli.Access.csproj
index 7a4bea4..aa5c268 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Access/Unity.Services.Cli.Access.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.Access/Unity.Services.Cli.Access.csproj
@@ -22,7 +22,7 @@
     <PackageReference Include="Unity.Services.Gateway.AccessApiV1.Generated" Version="1.0.1" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="YamlDotNet" Version="13.0.2" />
+    <PackageReference Include="YamlDotNet" Version="13.1.0" />
   </ItemGroup>
   <PropertyGroup>
     <DefineConstants Condition=" '$(ExtraDefineConstants)' != '' ">$(DefineConstants);$(ExtraDefineConstants)</DefineConstants>
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Compression/ZipArchiverTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Compression/ZipArchiverTests.cs
index 423f074..59d0529 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Compression/ZipArchiverTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Compression/ZipArchiverTests.cs
@@ -2,13 +2,14 @@
 using System.IO;
 using NUnit.Framework;
 using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Common.Exceptions;
 
 namespace Unity.Services.Cli.Authoring.UnitTest.Compression;
 
 [TestFixture]
 public class ZipArchiverTests
 {
-    ZipArchiver<string> m_Archiver = new();
+    IZipArchiver m_Archiver = new ZipArchiver();
 
     IReadOnlyList<string> m_Data = new[]
     {
@@ -17,37 +18,55 @@ public class ZipArchiverTests
         "Check"
     };
 
-    const string k_Extension = "test-zip";
-    const string k_Path = "test";
-    const string k_EntryName = "__ugs-cli";
-    const string k_DirectoryName = "test-zip";
+    const string k_Path = "testdata/test.test-zip";
+
+    static string DirectoryName => Path.GetDirectoryName(k_Path)!;
 
     [SetUp]
     public void SetUp()
     {
-        if (Directory.Exists(k_Path))
+        if (Directory.Exists(DirectoryName))
         {
-            Directory.Delete(k_Path, true);
+            Directory.Delete(DirectoryName, true);
         }
-        Directory.CreateDirectory(k_Path);
+        Directory.CreateDirectory(DirectoryName);
     }
 
     [TearDown]
     public void TearDown()
     {
-        if (Directory.Exists(k_Path))
+        if (Directory.Exists(DirectoryName))
         {
-            Directory.Delete(k_Path, true);
+            Directory.Delete(DirectoryName, true);
         }
     }
 
     [Test]
-    public void TestZipAndUnZipDataAreEqual()
+    public async Task ZipAndUnzipDataAreEqual()
+    {
+        var entryName = "test";
+
+        await m_Archiver.ZipAsync(k_Path, entryName, m_Data);
+        var unZipData = await m_Archiver.UnzipAsync<string>(k_Path, entryName);
+
+        Assert.AreEqual(m_Data, unZipData);
+    }
+
+    [Test]
+    public async Task ZipAndUnzipEntryWithDirectoryDataAreEqual()
     {
-        m_Archiver.Zip(k_Path, k_DirectoryName, k_EntryName, k_Extension, m_Data);
+        var entryName = "testdir/testentry";
 
-        var unZipData = m_Archiver.Unzip(k_Path, k_EntryName, k_Extension);
+        await m_Archiver.ZipAsync(k_Path, entryName, m_Data);
+        var unZipData = await m_Archiver.UnzipAsync<string>(k_Path, entryName);
 
         Assert.AreEqual(m_Data, unZipData);
     }
+
+    [Test]
+    public async Task UnzipNoEntryThrows()
+    {
+        await m_Archiver.ZipAsync(k_Path, "notUsed", m_Data);
+        Assert.ThrowsAsync<CliException>(() => m_Archiver.UnzipAsync<string>(k_Path, "nonexistentEntry"));
+    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Export/BaseExporterTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Export/BaseExporterTests.cs
new file mode 100644
index 0000000..f88e065
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Export/BaseExporterTests.cs
@@ -0,0 +1,171 @@
+using System.IO.Abstractions;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export;
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.TestUtils;
+
+namespace Unity.Services.Cli.Authoring.UnitTest.Export;
+
+public class BaseExporterTests
+{
+    readonly Mock<IZipArchiver> m_ZipArchiverMock = new();
+    readonly Mock<IUnityEnvironment> m_UnityEnvironment = new();
+    readonly Mock<IFileSystem> m_FileSystemMock = new();
+    readonly Mock<ILogger> m_LoggerMock = new();
+
+    readonly string m_FileName = "test.zip";
+    readonly string m_EntryName = "test";
+    TestBaseExporter? m_TestBaseExporter;
+
+    class TestBaseExporter : BaseExporter<int>
+    {
+        public TestBaseExporter(
+            IZipArchiver zipArchiver,
+            IUnityEnvironment unityEnvironment,
+            IFileSystem fileSystem,
+            ILogger logger,
+            string fileName,
+            string entryName) :
+            base(
+                zipArchiver,
+                unityEnvironment,
+                fileSystem,
+                logger)
+        {
+            FileName = fileName;
+            EntryName = entryName;
+        }
+
+        protected override string FileName { get; }
+        protected override string EntryName { get; }
+
+        protected override Task<IEnumerable<int>> ListConfigsAsync(string projectId, string environmentId, CancellationToken cancellationToken)
+        {
+            return Task.FromResult(Enumerable.Range(10, 6));
+        }
+
+        protected override ImportExportEntry<int> ToImportExportEntry(int value)
+        {
+            return new ImportExportEntry<int>(value.GetHashCode(), value.ToString(), value);
+        }
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_ZipArchiverMock.Reset();
+        m_UnityEnvironment.Reset();
+        m_FileSystemMock.Reset();
+        m_LoggerMock.Reset();
+
+        m_TestBaseExporter = new TestBaseExporter(
+            m_ZipArchiverMock.Object,
+            m_UnityEnvironment.Object,
+            m_FileSystemMock.Object,
+            m_LoggerMock.Object,
+            m_FileName,
+            m_EntryName);
+    }
+
+    [Test]
+    public async Task ExportAsync_WillZipCorrectConfigs()
+    {
+        var fileName = "other.zip";
+
+        var exportInput = new ExportInput
+        {
+            OutputDirectory = "mock_output_directory",
+            FileName = fileName
+        };
+
+        m_FileSystemMock.Setup(
+            e => e
+                .Directory
+                .CreateDirectory(It.IsAny<string>()));
+
+        m_FileSystemMock.Setup(
+            e => e
+                .Path
+                .Join(It.IsAny<string?>(), It.IsAny<string?>()));
+
+        m_FileSystemMock.Setup(
+                e => e
+                    .File
+                    .Exists(It.IsAny<string>()))
+            .Returns<string>((path) => false);
+
+        var result = m_TestBaseExporter!.ExportAsync(exportInput, CancellationToken.None);
+
+        await result;
+
+        m_ZipArchiverMock.Verify(
+            e =>
+                e.ZipAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    Enumerable.Range(10, 6),
+                    It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task ExportAsync_DryRunCorrectOutput()
+    {
+        var fileName = "other.zip";
+
+        var exportInput = new ExportInput
+        {
+            OutputDirectory = "mock_output_directory",
+            FileName = fileName,
+            DryRun = true
+        };
+
+        var result = m_TestBaseExporter!.ExportAsync(exportInput, CancellationToken.None);
+
+        await result;
+
+        TestsHelper.VerifyLoggerWasCalled(m_LoggerMock, LogLevel.Critical, expectedTimes: Times.Once);
+    }
+
+    [Test]
+    public void ExportAsync_FailsWhenFileExist()
+    {
+        var fileName = "other.zip";
+
+        var exportInput = new ExportInput
+        {
+            OutputDirectory = "mock_output_directory",
+            FileName = fileName
+        };
+
+        m_FileSystemMock.Setup(
+            e => e
+                .Directory
+                .CreateDirectory(It.IsAny<string>()));
+
+        m_FileSystemMock.Setup(
+            e => e
+                .Path
+                .Join(It.IsAny<string?>(), It.IsAny<string?>()));
+
+        m_FileSystemMock.Setup(
+                e => e
+                    .File
+                    .Exists(It.IsAny<string>()))
+            .Returns<string>((path) => true);
+
+        var exception = Assert.ThrowsAsync<CliException>(
+            async () =>
+            {
+                await m_TestBaseExporter!.ExportAsync(exportInput, CancellationToken.None);
+            });
+
+        Assert.That(exception!.Message, Is.EqualTo("The filename to export to already exists. Please create a new file"));
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Handlers/DeployHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Handlers/DeployHandlerTests.cs
index 15685d0..d2ce36f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Handlers/DeployHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Handlers/DeployHandlerTests.cs
@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
@@ -18,6 +14,7 @@
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.Authoring.Service;
 using Unity.Services.Cli.TestUtils;
+using Unity.Services.DeploymentApi.Editor;
 
 namespace Unity.Services.Cli.Authoring.UnitTest.Handlers;
 
@@ -36,9 +33,11 @@ public class DeployHandlerTests
     public class TestDeploymentService : IDeploymentService
     {
         string m_ServiceType = "Test";
+        string m_ServiceName = "test";
         string m_DeployFileExtension = ".test";
 
         string IDeploymentService.ServiceType => m_ServiceType;
+        string IDeploymentService.ServiceName => m_ServiceName;
 
         string IDeploymentService.DeployFileExtension => m_DeployFileExtension;
 
@@ -58,9 +57,11 @@ public Task<DeploymentResult> Deploy(DeployInput deployInput, IReadOnlyList<stri
     public class TestDeploymentFailureService : IDeploymentService
     {
         string m_ServiceType = "Test";
+        string m_ServiceName = "test";
         string m_DeployFileExtension = ".test";
 
         string IDeploymentService.ServiceType => m_ServiceType;
+        string IDeploymentService.ServiceName => m_ServiceName;
 
         string IDeploymentService.DeployFileExtension => m_DeployFileExtension;
 
@@ -86,9 +87,11 @@ public Task<DeploymentResult> Deploy(DeployInput deployInput, IReadOnlyList<stri
     public class TestDeploymentUnhandledExceptionService : IDeploymentService
     {
         string m_ServiceType = "Test";
+        string m_ServiceName = "test";
         string m_DeployFileExtension = ".test";
 
         string IDeploymentService.ServiceType => m_ServiceType;
+        string IDeploymentService.ServiceName => m_ServiceName;
 
         string IDeploymentService.DeployFileExtension => m_DeployFileExtension;
 
@@ -109,8 +112,30 @@ public void SetUp()
         m_Logger.Reset();
         m_UnityEnvironment.Reset();
         m_DeployFileService.Reset();
+
+        m_DeploymentService.Setup(s => s.ServiceName)
+            .Returns("mock_test");
+
+        m_DeploymentService.Setup(
+                s => s.Deploy(
+                    It.IsAny<DeployInput>(),
+                    It.IsAny<IReadOnlyList<string>>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<StatusContext?>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(
+                Task.FromResult(
+                    new DeploymentResult(
+                        Array.Empty<IDeploymentItem>(),
+                        Array.Empty<IDeploymentItem>(),
+                        Array.Empty<IDeploymentItem>(),
+                        Array.Empty<IDeploymentItem>(),
+                        Array.Empty<IDeploymentItem>())));
+
         var collection = m_Bridge.CreateBuilder(new ServiceCollection());
         collection.AddScoped<IDeploymentService, TestDeploymentService>();
+        collection.AddScoped<IDeploymentService>((_) => m_DeploymentService.Object);
         var provider = m_Bridge.CreateServiceProvider(collection);
 
         m_Host.Setup(x => x.Services)
@@ -197,5 +222,128 @@ await DeployHandler.DeployAsync(
                 m_UnityEnvironment.Object,
                 m_Logger.Object, (StatusContext)null!, CancellationToken.None);
         });
+
+    }
+
+    [Test]
+    public async Task DeployAsync_ReconcileWillNotExecutedWithNoServiceFlag()
+    {
+        var input = new DeployInput()
+        {
+            Reconcile = true
+        };
+
+        await DeployHandler.DeployAsync(
+            m_Host.Object,
+            input,
+            m_DeployFileService.Object,
+            m_UnityEnvironment.Object,
+            m_Logger.Object,
+            (StatusContext)null!,
+            CancellationToken.None);
+
+        m_DeploymentService.Verify(
+            s => s.Deploy(
+                It.IsAny<DeployInput>(),
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<StatusContext?>(),
+                It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    [Test]
+    public async Task DeployAsync_ReconcileExecuteWithServiceFlag()
+    {
+        var input = new DeployInput()
+        {
+            Reconcile = true,
+            Services = new[]
+            {
+                "mock_test"
+            }
+        };
+
+        await DeployHandler.DeployAsync(
+            m_Host.Object,
+            input,
+            m_DeployFileService.Object,
+            m_UnityEnvironment.Object,
+            m_Logger.Object,
+            (StatusContext)null!,
+            CancellationToken.None);
+
+        m_DeploymentService.Verify(
+            s => s.Deploy(
+                It.IsAny<DeployInput>(),
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<StatusContext?>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task DeployAsync_ExecuteWithCorrectServiceFlag()
+    {
+        var input = new DeployInput()
+        {
+            Services = new[]
+            {
+                "mock_test"
+            }
+        };
+
+        await DeployHandler.DeployAsync(
+            m_Host.Object,
+            input,
+            m_DeployFileService.Object,
+            m_UnityEnvironment.Object,
+            m_Logger.Object,
+            (StatusContext)null!,
+            CancellationToken.None);
+
+        m_DeploymentService.Verify(
+            s => s.Deploy(
+                It.IsAny<DeployInput>(),
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<StatusContext?>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task DeployAsync_NotExecuteWithIncorrectServiceFlag()
+    {
+        var input = new DeployInput()
+        {
+            Services = new[]
+            {
+                "non-test"
+            }
+        };
+
+        await DeployHandler.DeployAsync(
+            m_Host.Object,
+            input,
+            m_DeployFileService.Object,
+            m_UnityEnvironment.Object,
+            m_Logger.Object,
+            (StatusContext)null!,
+            CancellationToken.None);
+
+        m_DeploymentService.Verify(
+            s => s.Deploy(
+                It.IsAny<DeployInput>(),
+                It.IsAny<IReadOnlyList<string>>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<StatusContext?>(),
+                It.IsAny<CancellationToken>()),
+            Times.Never);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Handlers/FetchHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Handlers/FetchHandlerTests.cs
index e9ba68c..e089fac 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Handlers/FetchHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Handlers/FetchHandlerTests.cs
@@ -16,6 +16,7 @@
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.Authoring.Service;
 using Unity.Services.Cli.TestUtils;
+using Unity.Services.DeploymentApi.Editor;
 
 namespace Unity.Services.Cli.Authoring.UnitTest.Handlers;
 
@@ -25,46 +26,66 @@ public class FetchHandlerTests
     readonly Mock<IHost> m_Host = new();
     readonly Mock<ILogger> m_Logger = new();
     readonly Mock<IServiceProvider> m_ServiceProvider = new();
-    readonly Mock<IDeploymentService> m_DeploymentService = new();
-
-    class TestFetchService : IFetchService
-    {
-        string m_ServiceType = "Test";
-        string m_DeployFileExtension = ".test";
-
-        string IFetchService.ServiceType => m_ServiceType;
-
-        string IFetchService.FileExtension => m_DeployFileExtension;
-
-        public Task<FetchResult> FetchAsync(FetchInput input, StatusContext? loadingContext, CancellationToken cancellationToken)
-        {
-            var res = new FetchResult(
-                new[] { "updated1" },
-                new[] { "deleted1" },
-                Array.Empty<string>(),
-                new[] { "file1" },
-                Array.Empty<string>());
-            return Task.FromResult(res);
-        }
-    }
+    readonly Mock<IFetchService> m_FetchService = new();
 
     [SetUp]
     public void SetUp()
     {
         m_Host.Reset();
         m_ServiceProvider.Reset();
-        m_DeploymentService.Reset();
+        m_FetchService.Reset();
         m_Logger.Reset();
 
+        m_FetchService.Setup(s => s.ServiceName)
+            .Returns("mock_test");
+
+        m_FetchService.Setup(
+                s => s.FetchAsync(
+                    It.IsAny<FetchInput>(),
+                    It.IsAny<StatusContext?>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(
+                Task.FromResult(
+                    new FetchResult(
+                        Array.Empty<IDeploymentItem>(),
+                        Array.Empty<IDeploymentItem>(),
+                        Array.Empty<IDeploymentItem>(),
+                        Array.Empty<IDeploymentItem>(),
+                        Array.Empty<IDeploymentItem>())));
+
         var bridge = new ServiceTypesBridge();
         var collection = bridge.CreateBuilder(new ServiceCollection());
         collection.AddScoped<IFetchService, TestFetchService>();
+        collection.AddScoped<IFetchService>((_) => m_FetchService.Object);
         var provider = bridge.CreateServiceProvider(collection);
 
         m_Host.Setup(x => x.Services)
             .Returns(provider);
     }
 
+    class TestFetchService : IFetchService
+    {
+        string m_ServiceType = "Test";
+        string m_ServiceName = "test";
+        string m_DeployFileExtension = ".test";
+
+        string IFetchService.ServiceType => m_ServiceType;
+        string IFetchService.ServiceName => m_ServiceName;
+
+        string IFetchService.FileExtension => m_DeployFileExtension;
+
+        public Task<FetchResult> FetchAsync(FetchInput input, StatusContext? loadingContext, CancellationToken cancellationToken)
+        {
+            var res = new FetchResult(
+                StringsToDeployContent(new[] { "updated1" }),
+                StringsToDeployContent (new[] { "deleted1" }),
+                Array.Empty<DeployContent>(),
+                StringsToDeployContent(new[] { "file1" }),
+                Array.Empty<DeployContent>());
+            return Task.FromResult(res);
+        }
+    }
+
     [Test]
     public async Task FetchAsync_WithLoadingIndicator_CallsLoadingIndicatorStartLoading()
     {
@@ -77,6 +98,30 @@ await FetchHandler.FetchAsync(
             ex => ex.StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?, Task>>()), Times.Once);
     }
 
+    [Test]
+    [TestCase(true, Description = "Dry-Run is dry")]
+    [TestCase(false, Description = "Wet-Run is wet")]
+    public async Task FetchAsync_PrintsCorrectDryRun(bool dryRun)
+    {
+        var mockLogger = new Mock<ILogger>();
+        var fetchInput = new FetchInput { DryRun = dryRun };
+
+        await FetchHandler.FetchAsync(
+            m_Host.Object,
+            fetchInput,
+            mockLogger.Object,
+            (StatusContext?)null,
+            CancellationToken.None);
+
+        mockLogger.Verify(l => l.Log(
+            LogLevel.Critical,
+            LoggerExtension.ResultEventId,
+            It.Is<object>(
+                (o, t) => ((FetchResult)o).DryRun == dryRun),
+            null,
+            It.IsAny<Func<object, Exception?, string>>()));
+    }
+
 
     [Test]
     public async Task FetchAsync_CallsGetServicesCorrectly()
@@ -88,4 +133,145 @@ await FetchHandler.FetchAsync(
 
         TestsHelper.VerifyLoggerWasCalled(m_Logger, LogLevel.Critical, LoggerExtension.ResultEventId, Times.Once);
     }
+
+    static IReadOnlyList<DeployContent> StringsToDeployContent(IEnumerable<string> strs)
+    {
+        return strs.Select(s => new DeployContent(s, string.Empty, string.Empty)).ToList();
+    }
+
+    [Test]
+    public void FetchAsync_ThrowsAggregateException()
+    {
+        m_Host.Reset();
+        var bridge = new ServiceTypesBridge();
+        var collection = bridge.CreateBuilder(new ServiceCollection());
+        collection.AddScoped<IFetchService, TestFetchUnhandleExceptionFetchService>();
+        var provider = bridge.CreateServiceProvider(collection);
+        m_Host.Setup(x => x.Services).Returns(provider);
+        var fetchInput = new FetchInput();
+        Assert.ThrowsAsync<AggregateException>(async () =>
+        {
+            await FetchHandler.FetchAsync(
+                m_Host.Object, fetchInput, m_Logger.Object, (StatusContext)null!, CancellationToken.None);
+        });
+    }
+
+    [Test]
+    public async Task FetchAsync_ReconcileWillNotExecutedWithNoServiceFlag()
+    {
+        var input = new FetchInput()
+        {
+            Reconcile = true
+        };
+
+        await FetchHandler.FetchAsync(
+            m_Host.Object,
+            input,
+            m_Logger.Object,
+            (StatusContext)null!,
+            CancellationToken.None);
+
+        m_FetchService.Verify(
+            s => s.FetchAsync(
+                It.IsAny<FetchInput>(),
+                It.IsAny<StatusContext?>(),
+                It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    [Test]
+    public async Task FetchAsync_ReconcileExecuteWithServiceFlag()
+    {
+        var input = new FetchInput()
+        {
+            Reconcile = true,
+            Services = new[]
+            {
+                "mock_test"
+            }
+        };
+
+        await FetchHandler.FetchAsync(
+            m_Host.Object,
+            input,
+            m_Logger.Object,
+            (StatusContext)null!,
+            CancellationToken.None);
+
+        m_FetchService.Verify(
+            s => s.FetchAsync(
+                It.IsAny<FetchInput>(),
+                It.IsAny<StatusContext?>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task FetchAsync_ExecuteWithCorrectServiceFlag()
+    {
+        var input = new FetchInput()
+        {
+            Services = new[]
+            {
+                "mock_test"
+            }
+        };
+
+        await FetchHandler.FetchAsync(
+            m_Host.Object,
+            input,
+            m_Logger.Object,
+            (StatusContext)null!,
+            CancellationToken.None);
+
+        m_FetchService.Verify(
+            s => s.FetchAsync(
+                It.IsAny<FetchInput>(),
+                It.IsAny<StatusContext?>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task FetchAsync_NotExecuteWithIncorrectServiceFlag()
+    {
+        var input = new FetchInput()
+        {
+            Services = new[]
+            {
+                "non-test"
+            }
+        };
+
+        await FetchHandler.FetchAsync(
+            m_Host.Object,
+            input,
+            m_Logger.Object,
+            (StatusContext)null!,
+            CancellationToken.None);
+
+        m_FetchService.Verify(
+            s => s.FetchAsync(
+                It.IsAny<FetchInput>(),
+                It.IsAny<StatusContext?>(),
+                It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    class TestFetchUnhandleExceptionFetchService : IFetchService
+    {
+        string m_ServiceType = "Test";
+        string m_ServiceName = "test";
+        string m_DeployFileExtension = ".test";
+
+        string IFetchService.ServiceType => m_ServiceType;
+        string IFetchService.ServiceName => m_ServiceName;
+
+        string IFetchService.FileExtension => m_DeployFileExtension;
+
+        public Task<FetchResult> FetchAsync(FetchInput input, StatusContext? loadingContext, CancellationToken cancellationToken)
+        {
+            return Task.FromException<FetchResult>(new NullReferenceException());
+        }
+    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Import/BaseImportTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Import/BaseImportTests.cs
new file mode 100644
index 0000000..80ee93b
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Import/BaseImportTests.cs
@@ -0,0 +1,182 @@
+using System.Collections.Concurrent;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Import;
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.TestUtils;
+
+namespace Unity.Services.Cli.Authoring.UnitTest.Import;
+
+public class BaseImportTests
+{
+    readonly string m_FileName = "test.zip";
+    readonly string m_EntryName = "test";
+
+    class TestBaseImporter : BaseImporter<int>
+    {
+        readonly Mock<IZipArchiver>? m_MockZipArchiver;
+        readonly Mock<IUnityEnvironment>? m_MockUnityEnvironment;
+        public readonly Mock<ILogger>? MockLogger;
+        protected override string FileName { get; }
+        protected override string EntryName { get; }
+        public readonly List<int> RemoteConfigs;
+        public readonly List<int> LocalConfigs;
+        readonly ConcurrentBag<int> m_DeletedConfigs = new();
+        readonly ConcurrentBag<int> m_CreatedConfigs = new();
+        readonly ConcurrentBag<int> m_UpdatedConfigs = new();
+
+        public TestBaseImporter(
+            Mock<IZipArchiver> mockZipArchiver,
+            Mock<IUnityEnvironment> mockUnityEnvironment,
+            Mock<ILogger> mockLogger,
+            string fileName,
+            string entryName)
+            : base(mockZipArchiver.Object, mockUnityEnvironment.Object, mockLogger.Object)
+        {
+            FileName = fileName;
+            EntryName = entryName;
+
+            LocalConfigs = Enumerable.Range(1, 5).ToList();
+            RemoteConfigs = Enumerable.Range(10, 6).ToList();
+
+            m_MockZipArchiver = mockZipArchiver;
+            m_MockUnityEnvironment = mockUnityEnvironment;
+            MockLogger = mockLogger;
+
+            m_MockZipArchiver.Setup(
+                    e => e.UnzipAsync<int>(
+                        It.IsAny<string>(),
+                        It.IsAny<string>(),
+                        It.IsAny<CancellationToken>()))
+                .Returns(Task.FromResult(LocalConfigs.AsEnumerable()));
+        }
+
+        public ConcurrentBag<int> GetDeletedConfigs()
+        {
+            return m_DeletedConfigs;
+        }
+
+        public ConcurrentBag<int> GetCreatedConfigs()
+        {
+            return m_CreatedConfigs;
+        }
+
+        protected override Task DeleteConfigAsync(string projectId, string environmentId, int configToDelete, CancellationToken cancellationToken)
+        {
+            m_DeletedConfigs.Add(configToDelete);
+            return Task.CompletedTask;
+        }
+
+        protected override Task<IEnumerable<int>> ListConfigsAsync(string cloudProjectId, string environmentId, CancellationToken cancellationToken)
+        {
+            return Task.FromResult(RemoteConfigs.AsEnumerable());
+        }
+
+        protected override Task CreateConfigAsync(string projectId, string environmentId, int config, CancellationToken cancellationToken)
+        {
+            m_CreatedConfigs.Add(config);
+            return Task.CompletedTask;
+        }
+
+        protected override Task UpdateConfigAsync(string projectId, string environmentId, int config, CancellationToken cancellationToken)
+        {
+            m_UpdatedConfigs.Add(config);
+            return Task.CompletedTask;
+        }
+
+        protected override ImportExportEntry<int> ToImportExportEntry(int value)
+        {
+            return new ImportExportEntry<int>(value.GetHashCode(), value.ToString(), value);
+        }
+    }
+
+    [Test]
+    public async Task ImportAsync_DryRunCorrectOutput()
+    {
+        var testBaseImporter = new TestBaseImporter(
+            new(),
+           new(),
+            new(),
+            m_FileName,
+            m_EntryName);
+
+        var fileName = "other.zip";
+
+        var importInput = new ImportInput
+        {
+            FileName = fileName,
+            DryRun = true
+        };
+
+        var result = testBaseImporter.ImportAsync(importInput, CancellationToken.None);
+
+        await result;
+
+        TestsHelper.VerifyLoggerWasCalled(testBaseImporter.MockLogger!, LogLevel.Critical, expectedTimes: Times.Once);
+    }
+
+    [Test]
+    public async Task ImportAsync_ReconcileWillDeleteRemoteFiles()
+    {
+        var testBaseImporter = new TestBaseImporter(
+            new(),
+            new(),
+            new(),
+            m_FileName,
+            m_EntryName);
+
+        var fileName = "other.zip";
+
+        var importInput = new ImportInput
+        {
+            FileName = fileName,
+            Reconcile = true
+        };
+
+        var result = testBaseImporter.ImportAsync(importInput, CancellationToken.None);
+
+        await result;
+
+        var expectedDeletedItems = testBaseImporter.RemoteConfigs;
+        var actualDeletedItems = testBaseImporter.GetDeletedConfigs();
+
+        foreach (var deletedItem in expectedDeletedItems)
+        {
+            Assert.IsTrue(actualDeletedItems.Contains(deletedItem));
+        }
+    }
+
+    [Test]
+    public async Task ImportAsync_WillCreateRemoteFiles()
+    {
+        var testBaseImporter = new TestBaseImporter(
+            new(),
+            new(),
+            new(),
+            m_FileName,
+            m_EntryName);
+
+        var fileName = "other.zip";
+
+        var importInput = new ImportInput
+        {
+            FileName = fileName
+        };
+
+        var result = testBaseImporter.ImportAsync(importInput, CancellationToken.None);
+
+        await result;
+
+        var expectedCreatedItems = testBaseImporter.LocalConfigs;
+        var actualCreateItems = testBaseImporter.GetCreatedConfigs();
+
+        foreach (var deletedItem in expectedCreatedItems)
+        {
+            Assert.IsTrue(actualCreateItems.Contains(deletedItem));
+        }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Model/DeploymentResultTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Model/DeploymentResultTests.cs
index b62f56f..de6e467 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Model/DeploymentResultTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Model/DeploymentResultTests.cs
@@ -2,6 +2,7 @@
 using System.Linq;
 using NUnit.Framework;
 using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.DeploymentApi.Editor;
 
 namespace Unity.Services.Cli.Authoring.UnitTest.Model;
 
@@ -10,15 +11,15 @@ public class DeploymentResultTests
 {
     DeploymentResult? m_DeploymentResult;
 
-    static readonly IReadOnlyCollection<DeployContent> k_DeployedContents = new[]
+    static readonly IReadOnlyList<DeployContent> k_DeployedContents = new[]
     {
         new DeployContent("script.js", "Cloud Code", "path", 100, "Published"),
     };
 
-    static readonly IReadOnlyCollection<DeployContent> k_FailedContents = new[]
+    static readonly IReadOnlyList<DeployContent> k_FailedContents = new[]
     {
-        new DeployContent("invalid1.rc", "Remote Config", "path", 0, "Failed to Load"),
-        new DeployContent("invalid2.js", "Cloud Code", "path", 0, "Failed to Load"),
+        new DeployContent("invalid1.rc", "Remote Config", "path", 0, "Failed to Load", level: SeverityLevel.Error),
+        new DeployContent("invalid2.js", "Cloud Code", "path", 0, "Failed to Load", level: SeverityLevel.Error),
     };
 
     [Test]
@@ -32,12 +33,11 @@ public void ToStringFormatsDeployedAndFailedResults()
             k_FailedContents);
         var result = m_DeploymentResult.ToString();
 
-        Assert.IsTrue(result.Contains($"Deployed:{System.Environment.NewLine}    {k_DeployedContents.First().Name}"));
+        StringAssert.Contains($"Successfully deployed the following files:{System.Environment.NewLine}    '{k_DeployedContents.First().Path}'", result);
+        StringAssert.Contains($"Failed to deploy:{System.Environment.NewLine}", result);
         foreach (var content in k_FailedContents)
         {
-            StringAssert.Contains($"Failed to deploy:{System.Environment.NewLine}"+
-                                  $"    '{content.Name}' - Status: {content.Status}{System.Environment.NewLine}"+
-                                  $"    {content.Detail}", result);
+            StringAssert.Contains($"    '{content.Path}' - Status: {content.Status.Message} - {content.Detail}", result);
         }
     }
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Model/FetchResultTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Model/FetchResultTests.cs
index 3f5624b..24e37d8 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Model/FetchResultTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Model/FetchResultTests.cs
@@ -35,61 +35,48 @@ public class FetchResultTests
         "thing2"
     };
 
+    static readonly FetchResult k_FetchResultDummy = new FetchResult(Array.Empty<FetchResult>());
+
     static readonly List<TestCaseData> k_AppendResultTestData = new()
     {
-        new TestCaseData(k_Updated, FetchResult.UpdatedHeader),
-        new TestCaseData(k_Created, FetchResult.CreatedHeader),
-        new TestCaseData(k_Deleted, FetchResult.DeletedHeader),
-        new TestCaseData(k_Failed, FetchResult.FailedHeader),
-        new TestCaseData(k_Fetched, FetchResult.FetchedHeader),
+        new TestCaseData(StringsToDeployContent(k_Updated), AuthorResult.UpdatedHeader),
+        new TestCaseData(StringsToDeployContent(k_Created), AuthorResult.CreatedHeader),
+        new TestCaseData(StringsToDeployContent(k_Deleted), AuthorResult.DeletedHeader),
+        new TestCaseData(StringsToDeployContent(k_Failed), k_FetchResultDummy.AuthoredHeader),
+        new TestCaseData(StringsToDeployContent(k_Fetched), k_FetchResultDummy.FailedHeader),
     };
 
     [Test]
     public void ToStringFormatsFetchedAndFailedResults()
     {
         var fetchResult = new FetchResult(
-            k_Updated,
-            k_Deleted,
-            k_Created,
-            k_Fetched,
-            k_Failed);
+            StringsToDeployContent(k_Updated),
+            StringsToDeployContent(k_Deleted),
+            StringsToDeployContent(k_Created),
+            StringsToDeployContent(k_Fetched),
+            StringsToDeployContent(k_Failed),
+            true);
         var result = fetchResult.ToString();
 
         Assert.Multiple(
             () =>
             {
-                AssertStringifiedResult(result, k_Updated, FetchResult.UpdatedHeader);
-                AssertStringifiedResult(result, k_Created, FetchResult.CreatedHeader);
-                AssertStringifiedResult(result, k_Deleted, FetchResult.DeletedHeader);
-                AssertStringifiedResult(result, k_Failed, FetchResult.FailedHeader);
-                AssertStringifiedResult(result, k_Fetched, FetchResult.FetchedHeader);
+                AssertStringifiedResult(result, k_Updated, AuthorResult.DryUpdatedHeader);
+                AssertStringifiedResult(result, k_Created, AuthorResult.DryCreatedHeader);
+                AssertStringifiedResult(result, k_Deleted, AuthorResult.DryDeletedHeader);
+                AssertStringifiedResult(result, k_Failed, k_FetchResultDummy.DryFailedHeader);
+                AssertStringifiedResult(result, k_Fetched, k_FetchResultDummy.DryAuthoredHeader);
             });
     }
 
     [Test]
     public void ToStringFormatsNoContentFetched()
     {
-        var fetchResult = new FetchResult(
-            Array.Empty<string>(),
-            Array.Empty<string>(),
-            Array.Empty<string>(),
-            Array.Empty<string>(),
-            Array.Empty<string>());
+        var fetchResult = new FetchResult(Array.Empty<FetchResult>());
         var result = fetchResult.ToString();
 
-        Assert.IsFalse(result.Contains(FetchResult.FetchedHeader));
-        Assert.IsTrue(result.Contains(FetchResult.EmptyFetchMessage));
-    }
-
-    [TestCaseSource(nameof(k_AppendResultTestData))]
-    public void AppendResultBuildsResultAsExpected(ICollection<string> results, string header)
-    {
-        var builder = new StringBuilder();
-
-        FetchResult.AppendResult(builder, results, header);
-
-        var stringifiedResult = builder.ToString();
-        Assert.Multiple(() => AssertStringifiedResult(stringifiedResult, results, header));
+        Assert.IsFalse(result.Contains(fetchResult.AuthoredHeader));
+        Assert.IsTrue(result.Contains(fetchResult.NoActionMessage));
     }
 
     static void AssertStringifiedResult(string stringifiedResult, IEnumerable<string> results, string header)
@@ -97,7 +84,12 @@ static void AssertStringifiedResult(string stringifiedResult, IEnumerable<string
         Assert.That(stringifiedResult, Contains.Substring(header));
         foreach (var result in results)
         {
-            Assert.That(stringifiedResult, Contains.Substring($"    {result}"));
+            Assert.That(stringifiedResult, Contains.Substring($"    '{result}'"));
         }
     }
+
+    static IReadOnlyList<DeployContent> StringsToDeployContent(IEnumerable<string> strs)
+    {
+        return strs.Select(s => new DeployContent(s, string.Empty, s)).ToList();
+    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Unity.Services.Cli.Authoring.UnitTest.csproj b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Unity.Services.Cli.Authoring.UnitTest.csproj
index c3e6524..acedbc6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Unity.Services.Cli.Authoring.UnitTest.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring.UnitTest/Unity.Services.Cli.Authoring.UnitTest.csproj
@@ -2,6 +2,7 @@
   <PropertyGroup>
     <TargetFramework>net6.0</TargetFramework>
     <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Compression/IZipArchiver.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Compression/IZipArchiver.cs
index 6dd37ff..1b1be1b 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Compression/IZipArchiver.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Compression/IZipArchiver.cs
@@ -1,7 +1,27 @@
 namespace Unity.Services.Cli.Authoring.Compression;
 
-public interface IZipArchiver<T>
+/// <summary>
+/// An interface exposed to handlers to make zipping and unzipping archives simpler.
+/// </summary>
+public interface IZipArchiver
 {
-    void Zip(string archivePath, string directoryName, string entryName, string archiveExtension, IReadOnlyList<T> data);
-    IEnumerable<T> Unzip(string archivePath, string entryName, string archiveExtension);
+    /// <summary>
+    /// Create or update a zip file with an entry that contains a collection of data.
+    /// </summary>
+    /// <typeparam name="T">The type of the data to archive.</typeparam>
+    /// <param name="archivePath">The archive to create or update.</param>
+    /// <param name="entryName">The path of the file in the archive to update.</param>
+    /// <param name="data">A collection of data to archive.</param>
+    Task ZipAsync<T>(string archivePath, string entryName, IEnumerable<T> data, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Extract a collection of data from a zip file entry.
+    /// </summary>
+    /// <typeparam name="T">The type of the data to extract.</typeparam>
+    /// <param name="archivePath">The archive to read from.</param>
+    /// <param name="entryName">The path of the file in the archive to read.</param>
+    /// <returns>A collection of data objects contained in the entry or an empty list if the entry doesn't exist.</returns>
+    Task<IEnumerable<T>> UnzipAsync<T>(string archivePath, string entryName, CancellationToken cancellationToken = default);
+
+    ZipEntryStream? GetEntry(string path, string entryName);
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Compression/ZipArchiver.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Compression/ZipArchiver.cs
index f0a75b6..72af676 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Compression/ZipArchiver.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Compression/ZipArchiver.cs
@@ -1,72 +1,52 @@
 using System.IO.Compression;
 using Newtonsoft.Json;
 using Unity.Services.Cli.Common.Exceptions;
-using JsonSerializer = System.Text.Json.JsonSerializer;
 
 namespace Unity.Services.Cli.Authoring.Compression;
 
-public class ZipArchiver<T> : IZipArchiver<T>
+/// <inheritdoc />
+public class ZipArchiver : IZipArchiver
 {
-    string m_ArchiveExtension = "";
-
-    public void Zip(string archivePath, string directoryName, string entryName, string archiveExtension, IReadOnlyList<T> data)
+    /// <inheritdoc />
+    public async Task ZipAsync<T>(string archivePath, string entryName, IEnumerable<T> data, CancellationToken cancellationToken = default)
     {
-        try
-        {
-            var fileMode = File.Exists(archivePath) ? FileMode.Open : FileMode.Create;
-            m_ArchiveExtension = archiveExtension;
-            archivePath = m_ArchiveExtension.StartsWith(".")
-                ? $"{archivePath}{m_ArchiveExtension}"
-                : $"{archivePath}.{m_ArchiveExtension}";
-
-            using var zipToOpen = new FileStream(archivePath, fileMode);
-            using var zipArchive = new ZipArchive(zipToOpen, ZipArchiveMode.Update);
-
-            var directory = zipArchive.CreateEntry($"{directoryName}/");
-            var entryPath = Path.Join(directory.FullName, $"{entryName}");
-            var entry = zipArchive.CreateEntry(entryPath);
-            using var writer = new StreamWriter(entry.Open());
+        using var zipArchive = ZipFile.Open(archivePath, ZipArchiveMode.Create);
 
-            writer.Write(JsonSerializer.Serialize(data));
-        }
-        catch(Exception e)
-        {
-            throw new CliException(e.Message, e.InnerException, ExitCode.HandledError);
-        }
+        var entry = zipArchive.CreateEntry(entryName);
+        using var stream = entry.Open();
+        using (StreamWriter writer = new StreamWriter(stream))
+            await writer.WriteAsync(JsonConvert.SerializeObject(data));
     }
 
-    public IEnumerable<T> Unzip(string archivePath, string entryName, string archiveExtension)
+    /// <inheritdoc />
+    public async Task<IEnumerable<T>> UnzipAsync<T>(string archivePath, string entryName, CancellationToken cancellationToken = default)
     {
-        try
+        if (!File.Exists(archivePath))
         {
-            archivePath = archiveExtension.StartsWith(".")
-                ? $"{archivePath}{archiveExtension}"
-                : $"{archivePath}.{archiveExtension}";
-            var unzipped = new List<T>();
-            using var zipArchive = ZipFile.OpenRead(archivePath);
-
-            foreach (var entry in zipArchive.Entries)
-            {
-                if (Path.GetFileName(entry.FullName) != entryName)
-                {
-                    continue;
-                }
-
-                using var reader = new StreamReader(entry.Open());
-                var data = reader.ReadToEnd();
-                var settings = new JsonSerializerSettings
-                {
-                    NullValueHandling = NullValueHandling.Ignore,
-                    MissingMemberHandling = MissingMemberHandling.Ignore
-                };
-                unzipped.AddRange(JsonConvert.DeserializeObject<IReadOnlyList<T>>(data, settings) ?? Array.Empty<T>());
-            }
-
-            return unzipped;
+            throw new CliException($"The file at '{archivePath}' could not be found. Ensure the file exists and the specified path is correct", null, ExitCode.HandledError);
         }
-        catch (Exception e)
+        using var zipArchive = ZipFile.OpenRead(archivePath);
+
+        var entry = zipArchive.Entries.FirstOrDefault(e => e.FullName == entryName);
+        if(entry == null)
         {
-            throw new CliException(e.Message, e.InnerException, ExitCode.HandledError);
+            throw new CliException($"The zip '{archivePath}' appears to be malformed.", ExitCode.HandledError);
         }
+
+        using var entryStream = entry.Open();
+        using var sr = new StreamReader(entryStream);
+        var str = await sr.ReadToEndAsync();
+        IEnumerable<T>? data = JsonConvert.DeserializeObject<IEnumerable<T>>(str);
+        return data ?? Array.Empty<T>();
+    }
+
+    /// <inheritdoc />
+    public ZipEntryStream? GetEntry(string path, string entryName)
+    {
+        var zip = ZipFile.OpenRead(path);
+        var entry = zip.GetEntry(entryName);
+        if (entry == null)
+            return null;
+        return new ZipEntryStream(entry.Open(), zip);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Compression/ZipEntryStream.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Compression/ZipEntryStream.cs
new file mode 100644
index 0000000..9359c28
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Compression/ZipEntryStream.cs
@@ -0,0 +1,20 @@
+using System.IO.Compression;
+
+namespace Unity.Services.Cli.Authoring.Compression;
+
+public class ZipEntryStream : IDisposable
+{
+    readonly ZipArchive? m_Archive;
+    public Stream Stream { get; }
+
+    public ZipEntryStream(Stream stream, ZipArchive? archive = null)
+    {
+        m_Archive = archive;
+        Stream = stream;
+    }
+
+    public void Dispose()
+    {
+        m_Archive?.Dispose();
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/DeployModule.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/DeployModule.cs
index a75c4d8..f6f3791 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/DeployModule.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/DeployModule.cs
@@ -24,12 +24,12 @@ public DeployModule()
     {
         ModuleRootCommand = new Command(
             "deploy",
-            $"Deploy configuration files of supported services to the backend.{Environment.NewLine}"
-            + "Services currently supported are: remote-config, cloud-code.")
+            $"Deploy configuration files of supported services to the backend.")
         {
             DeployInput.PathsArgument,
             DeployInput.ReconcileOption,
             DeployInput.DryRunOption,
+            DeployInput.ServiceOptions,
             CommonInput.EnvironmentNameOption,
             CommonInput.CloudProjectIdOption
         };
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Export/BaseExporter.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Export/BaseExporter.cs
index a727a95..b6fd0bf 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Export/BaseExporter.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Export/BaseExporter.cs
@@ -1,7 +1,10 @@
+using System.IO.Abstractions;
 using Microsoft.Extensions.Logging;
 using Unity.Services.Cli.Authoring.Compression;
 using Unity.Services.Cli.Authoring.Export.Input;
 using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.Authoring.Utils;
+using Unity.Services.Cli.Common.Exceptions;
 using Unity.Services.Cli.Common.Logging;
 using Unity.Services.Cli.Common.Utils;
 
@@ -13,78 +16,75 @@ namespace Unity.Services.Cli.Authoring.Export;
 /// <typeparam name="T"></typeparam>
 public abstract class BaseExporter<T> : IExporter
 {
-    readonly IZipArchiver<T> m_ZipArchiver;
+    readonly IZipArchiver m_ZipArchiver;
     readonly IUnityEnvironment m_UnityEnvironment;
-    protected readonly ILogger Logger;
+    readonly IFileSystem m_FileSystem;
+    readonly ILogger m_Logger;
 
     /// <summary>
-    /// Path to the archive to be created
+    /// Name of the file to export to.
     /// </summary>
-    protected abstract string ArchivePath { get; }
-
-    /// <summary>
-    /// Archive name.
-    /// </summary>
-    protected abstract string DirectoryName { get; }
+    protected abstract string FileName { get; }
 
     /// <summary>
     /// A path relative to the root of the archive, indicating the name of the entry to be created.
     /// </summary>
     protected abstract string EntryName { get; }
 
-    /// <summary>
-    /// Archive extension.
-    /// </summary>
-    protected abstract string Extension { get; }
-
-    protected ExportInput ExportInput { get; set; } = null!;
-
     protected BaseExporter(
-        IZipArchiver<T> zipArchiver,
+        IZipArchiver zipArchiver,
         IUnityEnvironment unityEnvironment,
+        IFileSystem fileSystem,
         ILogger logger)
     {
         m_ZipArchiver = zipArchiver;
         m_UnityEnvironment = unityEnvironment;
-        Logger = logger;
+        m_FileSystem = fileSystem;
+        m_Logger = logger;
     }
 
     public async Task ExportAsync(ExportInput input, CancellationToken cancellationToken)
     {
-        ExportInput = input;
-        var projectId = ExportInput.CloudProjectId!;
+        var projectId = input.CloudProjectId!;
         var environmentId = await m_UnityEnvironment.FetchIdentifierAsync();
-        var configs = (await GetConfigsAsync(projectId, environmentId, cancellationToken)).ToList();
-        var archivePath = ArchivePath;
-        var extension = Extension;
+        var fileName = ImportExportUtils.ResolveFileName(input.FileName, FileName);
 
-        if (ExportInput.DryRun)
+        var configs = await ListConfigsAsync(projectId, environmentId, cancellationToken);
+        var state = new ExportState<T>(configs.Select(ToImportExportEntry).ToList());
+
+        if (!input.DryRun)
         {
-            var dryRunResult = OnDryRun(configs);
-            Logger.LogResultValue(dryRunResult);
-            return;
+            await ExportToZipAsync(input.OutputDirectory, fileName, state, cancellationToken);
         }
 
-        if (!string.IsNullOrEmpty(ExportInput.FileName))
+        m_Logger.LogResultValue(new ImportExportResult( state.ExportedItems().ToList())
         {
-            var fileName = Path.GetFileNameWithoutExtension(ExportInput.FileName);
-            var fileExtension = Path.GetExtension(ExportInput.FileName);
-            extension = string.IsNullOrEmpty(fileExtension) ? Extension : fileExtension;
+            Header = input.DryRun ? "The following items will be exported:" : "The following items were exported:",
+            DryRun = input.DryRun
+        });
+    }
 
-            archivePath = Path.Join(Path.GetDirectoryName(ArchivePath), fileName);
+    async Task ExportToZipAsync(string? outputDirectory, string fileName, ExportState<T> state, CancellationToken cancellationToken)
+    {
+        if (outputDirectory != null)
+        {
+            m_FileSystem.Directory.CreateDirectory(outputDirectory);
         }
 
-        if (!Directory.Exists(ArchivePath))
+        var archivePath = Path.Join(outputDirectory, fileName);
+
+        if (m_FileSystem.File.Exists(archivePath))
         {
-            Directory.CreateDirectory(ArchivePath);
+            throw new CliException($"The filename to export to already exists. Please create a new file", null, ExitCode.HandledError);
         }
 
-        OnBeforeZip(configs);
-        m_ZipArchiver.Zip(archivePath, DirectoryName, EntryName, extension, configs);
+        await m_ZipArchiver.ZipAsync(archivePath, EntryName, state.ToExport.Select(c => c.Value), cancellationToken);
+        await AfterZip(state.ToExport.Select(c => c.Value), archivePath, cancellationToken);
     }
 
-    protected virtual void OnBeforeZip(IEnumerable<T> configs)
+    protected virtual Task AfterZip(IEnumerable<T> configs, string archivePath, CancellationToken cancellationToken)
     {
+        return Task.CompletedTask;
     }
 
     /// <summary>
@@ -94,15 +94,15 @@ protected virtual void OnBeforeZip(IEnumerable<T> configs)
     /// <param name="environmentId">Environment Id</param>
     /// <param name="cancellationToken">Cancellation token</param>
     /// <returns></returns>
-    protected abstract Task<IEnumerable<T>> GetConfigsAsync(
+    protected abstract Task<IEnumerable<T>> ListConfigsAsync(
         string projectId,
         string environmentId,
         CancellationToken cancellationToken);
 
     /// <summary>
-    /// Method to perform dry run
+    /// Wrap value as ImportExportEntry
     /// </summary>
-    /// <param name="configs">Configs to perform operation</param>
-    /// <returns>Result of DryRun operation</returns>
-    protected abstract DryRunResult<T> OnDryRun(IReadOnlyList<T> configs);
+    /// <param name="value">value to wrap</param>
+    /// <returns></returns>
+    protected abstract ImportExportEntry<T> ToImportExportEntry(T value);
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Export/ExportState.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Export/ExportState.cs
new file mode 100644
index 0000000..b624879
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Export/ExportState.cs
@@ -0,0 +1,8 @@
+using Unity.Services.Cli.Authoring.Model;
+
+namespace Unity.Services.Cli.Authoring.Export;
+
+public record ExportState<T>(IReadOnlyCollection<ImportExportEntry<T>> ToExport)
+{
+    internal IEnumerable<ImportExportItem> ExportedItems() => ToExport.Select(e => e.ToImportExportItem(ImportExportAction.Export));
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/FetchModule.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/FetchModule.cs
index 5aa3d9e..2e6378c 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/FetchModule.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/FetchModule.cs
@@ -17,19 +17,17 @@ namespace Unity.Services.Cli.Authoring;
 /// </summary>
 public class FetchModule : ICommandModule
 {
-    readonly string[] m_SupportedServices = { "remote-confg" };
     public Command? ModuleRootCommand { get; }
 
     public FetchModule()
     {
-        var servicesStr = string.Join(", ", m_SupportedServices);
         ModuleRootCommand = new Command(
             "fetch",
-            $"Fetch configuration files of supported services from the backend.{Environment.NewLine}"
-            + $"Services currently supported are: {servicesStr}.")
+            $"Fetch configuration files of supported services from the backend.")
         {
             FetchInput.PathArgument,
             FetchInput.ReconcileOption,
+            FetchInput.ServiceOptions,
             FetchInput.DryRunOption,
             CommonInput.EnvironmentNameOption,
             CommonInput.CloudProjectIdOption
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Handlers/DeployHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Handlers/DeployHandler.cs
index 9777740..114fae0 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Handlers/DeployHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Handlers/DeployHandler.cs
@@ -22,9 +22,10 @@ public static async Task DeployAsync(
         ILogger logger,
         ILoadingIndicator loadingIndicator,
         CancellationToken cancellationToken
-        )
+    )
     {
-        await loadingIndicator.StartLoadingAsync($"Deploying files...",
+        await loadingIndicator.StartLoadingAsync(
+            $"Deploying files...",
             context => DeployAsync(
                 host,
                 input,
@@ -47,27 +48,51 @@ CancellationToken cancellationToken
     {
         var services = host.Services.GetServices<IDeploymentService>().ToList();
 
-        if (input.Paths.Count == 0)
+        var supportedServicesStr = string.Join(", ", services.Select(s => s.ServiceType));
+        var supportedServiceNamesStr = string.Join(", ", services.Select(s => s.ServiceName));
+
+        bool areAllServicesSupported = !AreAllServicesSupported(input, services, out var unsupportedServicesStr);
+        if (input.Paths.Count == 0 || areAllServicesSupported)
+        {
+            if (areAllServicesSupported)
+            {
+                logger.LogError($"These service options were not recognized: {unsupportedServicesStr}.");
+            }
+
+            logger.LogInformation($"Currently supported services are: {supportedServicesStr}." +
+                $"{Environment.NewLine}    You can filter your service(s) with the --services option: " +
+                $"{supportedServiceNamesStr}");
+        }
+
+        if (input.Reconcile && input.Services.Count == 0)
         {
-            var supportedServicesStr = string.Join(", ", services.Select(s => s.ServiceType));
-            logger.LogInformation("Currently supported services are: {SupportedServicesStr}", supportedServicesStr);
+            logger.LogError(
+                "Reconcile is a destructive operation. Specify your service(s) with the --services option: {SupportedServiceNamesStr}",
+                supportedServiceNamesStr);
+            return;
         }
 
         var environmentId = await unityEnvironment.FetchIdentifierAsync();
         var projectId = input.CloudProjectId!;
-        var tasks = services.Select(
-            m => m.Deploy(
-                input,
-                deployFileService.ListFilesToDeploy(input.Paths, m.DeployFileExtension),
-                projectId,
-                environmentId,
-                loadingContext,
-                cancellationToken)).ToArray();
+        var deploymentServices = services
+            .Where(s => CheckService(input, s))
+            .ToArray();
+
+        var tasks = deploymentServices.Select(
+                m => m.Deploy(
+                    input,
+                    deployFileService.ListFilesToDeploy(input.Paths, m.DeployFileExtension),
+                    projectId,
+                    environmentId,
+                    loadingContext,
+                    cancellationToken))
+            .ToArray();
+
         try
         {
             await Task.WhenAll(tasks);
         }
-        catch (Exception)
+        catch
         {
             // do nothing
             // this allows us to capture all the exceptions
@@ -81,9 +106,9 @@ CancellationToken cancellationToken
             .ToArray();
 
         var totalResult = new DeploymentResult(
-            deploymentResults.SelectMany(x => x.Created).ToList(),
             deploymentResults.SelectMany(x => x.Updated).ToList(),
             deploymentResults.SelectMany(x => x.Deleted).ToList(),
+            deploymentResults.SelectMany(x => x.Created).ToList(),
             deploymentResults.SelectMany(x => x.Deployed).ToList(),
             deploymentResults.SelectMany(x => x.Failed).ToList(),
             input.DryRun
@@ -107,4 +132,21 @@ CancellationToken cancellationToken
             throw new DeploymentFailureException();
         }
     }
+
+    static bool CheckService(DeployInput input, IDeploymentService service)
+    {
+        if (!input.Reconcile && input.Services.Count == 0)
+            return true;
+
+        return input.Services.Contains(service.ServiceName);
+    }
+
+    static bool AreAllServicesSupported(DeployInput input, IReadOnlyList<IDeploymentService> services, out string unsupportedServices)
+    {
+        var serviceNames = services.Select(s => s.ServiceName);
+
+        unsupportedServices = string.Join(", ", input.Services.Except(serviceNames));
+
+        return string.IsNullOrEmpty(unsupportedServices);
+    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Handlers/FetchHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Handlers/FetchHandler.cs
index 309dbcc..a43e285 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Handlers/FetchHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Handlers/FetchHandler.cs
@@ -39,63 +39,89 @@ internal static async Task FetchAsync(
     {
         var services = host.Services.GetServices<IFetchService>().ToList();
 
-        if (string.IsNullOrEmpty(input.Path))
+        var supportedServicesStr = string.Join(", ", services.Select(s => s.ServiceType));
+        var supportedServiceNamesStr = string.Join(", ", services.Select(s => s.ServiceName));
+
+        bool areAllServicesSupported = !AreAllServicesSupported(input, services, out var unsupportedServicesStr);
+        if (string.IsNullOrEmpty(input.Path) || areAllServicesSupported)
+        {
+            if (areAllServicesSupported)
+            {
+                logger.LogError($"These service options were not recognized: {unsupportedServicesStr}.");
+            }
+
+            logger.LogInformation($"Currently supported services are: {supportedServicesStr}." +
+                $"{Environment.NewLine}    You can filter your service(s) with the --services option: " +
+                $"{supportedServiceNamesStr}");
+        }
+
+        if (input.Reconcile && input.Services.Count == 0)
         {
-            var supportedServicesStr = string.Join(", ", services.Select(s => s.ServiceType));
-            logger.LogInformation("Currently supported services are: {supportedServicesStr}", supportedServicesStr);
+            logger.LogError(
+                "Reconcile is a destructive operation. Specify your service(s) with the --services option: {SupportedServiceNamesStr}",
+                supportedServiceNamesStr);
+            return;
         }
 
         var fetchResult = Array.Empty<FetchResult>();
-        Task<FetchResult[]>? fetchAll = null;
+
+        var fetchServices = services
+            .Where(s => CheckService(input, s))
+            .ToArray();
+
+        var tasks = fetchServices
+            .Select(
+                m => m.FetchAsync(
+                    input,
+                    loadingContext,
+                    cancellationToken))
+            .ToArray();
+
         try
         {
-            fetchAll = Task.WhenAll(
-                services.Select(
-                    m => m.FetchAsync(
-                        input,
-                        loadingContext,
-                        cancellationToken)));
-            fetchResult = await fetchAll;
+            fetchResult = await Task.WhenAll(tasks);
         }
         catch
         {
-            // will use fetchAll to find all errors
+            // do nothing
+            // this allows us to capture all the exceptions
+            // and handle them below
         }
 
-        var totalResult = new FetchResult(fetchResult);
+        var totalResult = new FetchResult(fetchResult, input.DryRun);
         logger.LogResultValue(totalResult);
 
-        if (fetchAll!.IsFaulted)
+        // Get Exceptions from faulted deployments
+        var exceptions = tasks
+            .Where(t => t.IsFaulted)
+            .Select(t => t.Exception!.InnerException)
+            .ToList();
+
+        if (exceptions.Any())
         {
-            HandleFailedFetch();
+            throw new AggregateException(exceptions!);
         }
 
         if (totalResult.Failed.Any())
         {
-            throw new CliException("One or more files failed to be fetched", ExitCode.HandledError);
+            throw new DeploymentFailureException();
         }
+    }
 
-        void HandleFailedFetch()
-        {
-            var exception = fetchAll.Exception!;
-            if (exception.InnerExceptions.Count == 1)
-            {
-                var innerException = exception.InnerException!;
-                var exitCode = innerException is CliException cliException
-                    ? cliException.ExitCode
-                    : ExitCode.UnhandledError;
-                throw new CliException(innerException.Message, innerException, exitCode);
-            }
+    static bool CheckService(FetchInput input, IFetchService service)
+    {
+        if (!input.Reconcile && input.Services.Count == 0)
+            return true;
 
-            var errorMessage = "Failed to fetch due to the following errors:"
-                + string.Join($"{Environment.NewLine}    - ", exception.InnerExceptions.Select(x => x.Message));
-            var cliExceptions = exception.InnerExceptions.OfType<CliException>().ToList();
-            if (cliExceptions.Count == exception.InnerExceptions.Count)
-            {
-                throw new CliException(errorMessage, fetchAll.Exception!, cliExceptions.Max(x => x.ExitCode));
-            }
+        return input.Services.Contains(service.ServiceName);
+    }
 
-            throw new CliException(errorMessage, exception, ExitCode.UnhandledError);
-        }
+    static bool AreAllServicesSupported(FetchInput input, IReadOnlyList<IFetchService> services, out string unsupportedServices)
+    {
+        var serviceNames = services.Select(s => s.ServiceName);
+
+        unsupportedServices = string.Join(", ", input.Services.Except(serviceNames));
+
+        return string.IsNullOrEmpty(unsupportedServices);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/BaseImporter.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/BaseImporter.cs
index 8b0e55c..6f08fc6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/BaseImporter.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/BaseImporter.cs
@@ -2,8 +2,11 @@
 using Unity.Services.Cli.Authoring.Compression;
 using Unity.Services.Cli.Authoring.Import.Input;
 using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.Authoring.Utils;
+using Unity.Services.Cli.Common.Exceptions;
 using Unity.Services.Cli.Common.Logging;
 using Unity.Services.Cli.Common.Utils;
+using Unity.Services.ModuleTemplate.Authoring.Core.Batching;
 
 namespace Unity.Services.Cli.Authoring.Import;
 /// <summary>
@@ -13,76 +16,78 @@ namespace Unity.Services.Cli.Authoring.Import;
 public abstract class BaseImporter<T> : IImporter
 {
     readonly IUnityEnvironment m_UnityEnvironment;
-    readonly IZipArchiver<T> m_ZipArchiver;
-    protected readonly ILogger Logger;
+    protected readonly IZipArchiver m_ZipArchiver;
+    protected readonly ILogger m_Logger;
 
     /// <summary>
     /// Path where the data to be imported exists
     /// </summary>
-    protected abstract string ArchivePath { get; }
+    protected abstract string FileName { get; }
 
     /// <summary>
     /// A path relative to the root of the archive, indicating the name of the entry to be imported
     /// </summary>
     protected abstract string EntryName { get; }
 
-    /// <summary>
-    /// Archive extension.
-    /// </summary>
-    protected abstract string Extension { get; }
-
-    protected ImportInput ImportInput { get; set; } = null!;
+    protected string? m_ArchivePath;
 
     protected BaseImporter(
-        IZipArchiver<T> zipArchiver,
+        IZipArchiver zipArchiver,
         IUnityEnvironment unityEnvironment,
         ILogger logger)
     {
         m_ZipArchiver = zipArchiver;
         m_UnityEnvironment = unityEnvironment;
-        Logger = logger;
+        m_Logger = logger;
     }
 
-    public async Task ImportAsync(ImportInput input, CancellationToken cancellationToken)
+    /// <summary>
+    /// Import configs in parallel tasks
+    /// </summary>
+    /// <param name="input"></param>
+    /// <param name="cancellationToken"></param>
+    /// <param name="maxParallelTaskLimit">Limit max parallel tasks to reduce 429 too many requests issue, various among services, work together with retry-after header handling, ex RetryAfterSleepDuration in LeaderboardsModule.cs</param>
+    /// <exception cref="CliException"></exception>
+    public async Task ImportAsync(ImportInput input, CancellationToken cancellationToken, int maxParallelTaskLimit = 10)
     {
-        ImportInput = input;
         var environmentId = await m_UnityEnvironment.FetchIdentifierAsync();
-        var projectId = ImportInput!.CloudProjectId!;
-        var archivePath = ArchivePath;
-        var extension = Extension;
+        var projectId = input!.CloudProjectId!;
+        var fileName = ImportExportUtils.ResolveFileName(input.FileName, FileName);
 
-        if (!string.IsNullOrEmpty(ImportInput.FileName))
-        {
-            var fileName = Path.GetFileNameWithoutExtension(ImportInput.FileName);
-            var fileExtension = Path.GetExtension(ImportInput.FileName);
-            extension = string.IsNullOrEmpty(fileExtension) ? Extension : fileExtension;
+        m_ArchivePath = Path.Join(input.InputDirectory, fileName);
+        var localConfigs = await m_ZipArchiver.UnzipAsync<T>(m_ArchivePath, EntryName, cancellationToken);
+        var remoteConfigs = await ListConfigsAsync(projectId, environmentId, cancellationToken);
 
-            archivePath = Path.Join(Path.GetDirectoryName(ArchivePath), fileName);
-        }
+        var state = CreateState(localConfigs, remoteConfigs);
 
-        var configs = m_ZipArchiver.Unzip(archivePath, EntryName, extension);
+        if (!input.DryRun)
+        {
+            await ImportConfigsAsync(
+                projectId,
+                environmentId,
+                input.Reconcile,
+                state,
+                maxParallelTaskLimit,
+                cancellationToken);
+        }
 
-        if (ImportInput.DryRun)
+        var items = state.CreatedItems().Concat(state.UpdatedItems());
+        if (input.Reconcile)
         {
-            var dryRunResult = OnDryRun(configs);
-            Logger.LogResultValue(dryRunResult);
-            return;
+            items = items.Concat(state.DeletedItems());
         }
 
-        var configsOnRemote = await ListConfigsAsync(projectId, environmentId, cancellationToken);
+        m_Logger.LogResultValue(new ImportExportResult(items.ToList())
+        {
+            Header = input.DryRun ? "The following items will be imported:" : "The following items were imported:",
+            DryRun = input.DryRun
+        });
 
-        if (ImportInput.Reconcile)
+        var importExceptions = state.ImportExceptions();
+        if (importExceptions != null)
         {
-            await DeleteNonMatchingConfigsAsync(
-                projectId,
-                environmentId,
-                configs,
-                configsOnRemote,
-                cancellationToken
-            );
+            throw importExceptions;
         }
-
-        await CreateOrUpdateConfigsAsync(projectId, environmentId, configs,  configsOnRemote, cancellationToken);
     }
 
     /// <summary>
@@ -111,18 +116,6 @@ protected abstract Task<IEnumerable<T>> ListConfigsAsync(
         string environmentId,
         CancellationToken cancellationToken);
 
-    /// <summary>
-    /// Method to check is config present
-    /// </summary>
-    /// <param name="config"></param>
-    /// <param name="configsOnRemote"></param>
-    /// <param name="cancellationToken"></param>
-    /// <returns></returns>
-    protected abstract bool IsConfigPresent(
-        T config,
-        IEnumerable<T> configsOnRemote,
-        CancellationToken cancellationToken);
-
     /// <summary>
     /// Method to create config async
     /// </summary>
@@ -130,8 +123,7 @@ protected abstract bool IsConfigPresent(
     /// <param name="environmentId">Environment Id</param>
     /// <param name="config">Config to check</param>
     /// <param name="cancellationToken">Cancellation token</param>
-    /// <returns>Return result of creating config</returns>
-    protected abstract Task<bool> TryCreateConfigAsync(
+    protected abstract Task CreateConfigAsync(
         string projectId,
         string environmentId,
         T config,
@@ -144,102 +136,91 @@ protected abstract Task<bool> TryCreateConfigAsync(
     /// <param name="environmentId">Environment Id</param>
     /// <param name="config">Config to check</param>
     /// <param name="cancellationToken">Cancellation token</param>
-    /// <returns>Return result of updating config</returns>
-    protected abstract Task<bool> TryUpdateConfigAsync(
+    protected abstract Task UpdateConfigAsync(
         string projectId,
         string environmentId,
         T config,
         CancellationToken cancellationToken);
 
     /// <summary>
-    /// Method to perform dry run
+    /// Wrap value as ImportExportEntry
     /// </summary>
-    /// <param name="configs">Configs to perform operation</param>
-    /// <returns>Result of DryRun operation</returns>
-    protected abstract DryRunResult<T> OnDryRun(IEnumerable<T> configs);
-
-    /// <summary>
-    /// Method will detect what configs need to be deleted from remote
-    /// </summary>
-    /// <param name="localConfigs">Local Configs</param>
-    /// <param name="remoteConfigs">Remote Configs</param>
-    /// <returns>Configs need to be deleted</returns>
-    protected abstract IEnumerable<T> GetConfigsToDelete(IEnumerable<T> localConfigs, IEnumerable<T> remoteConfigs);
-
-    /// <summary>
-    /// Method to log import information
-    /// </summary>
-    /// <param name="importResult">Results of import</param>
-    protected abstract void LogImportResult(ImportResult<T> importResult);
+    /// <param name="value">value to wrap</param>
+    /// <returns></returns>
+    protected abstract ImportExportEntry<T> ToImportExportEntry(T value);
 
-    async Task DeleteNonMatchingConfigsAsync(
+    protected virtual async Task ImportConfigsAsync(
         string projectId,
         string environmentId,
-        IEnumerable<T> configs,
-        IEnumerable<T> configsOnRemote,
+        bool reconcile,
+        ImportState<T> state,
+        int maxParallelTaskLimit,
         CancellationToken cancellationToken)
     {
-        var deleteTasks = new List<Task>();
-        var configsToDelete = GetNonMatchingConfigsAsync(projectId, environmentId, configs, configsOnRemote, cancellationToken);
+        var createEntryDelegates = CreateDelegatesFromImportExportEntries(
+            projectId, environmentId, state.ToCreate, CreateConfigAsync, cancellationToken);
 
-        foreach (var configToDelete in configsToDelete)
-        {
-            deleteTasks.Add(DeleteConfigAsync(projectId, environmentId, configToDelete, cancellationToken));
-        }
+        var updateEntryDelegates = CreateDelegatesFromImportExportEntries(
+            projectId, environmentId, state.ToUpdate, UpdateConfigAsync, cancellationToken);
 
-        await Task.WhenAll(deleteTasks);
-    }
+        List<Func<Task>> deleteEntryDelegates = new List<Func<Task>>();
 
-    async Task CreateOrUpdateConfigsAsync(
-        string projectId,
-        string environmentId,
-        IEnumerable<T> localConfigs,
-        IEnumerable<T> configsOnRemote,
-        CancellationToken cancellationToken)
-    {
-        var taskToConfig = new Dictionary<Task<bool>, T>();
-        foreach (var config in localConfigs)
+        if (reconcile)
         {
-            taskToConfig.Add(TryCreateOrUpdateConfigAsync(
-                projectId,
-                environmentId,
-                config,
-                configsOnRemote,
-                cancellationToken), config);
+            deleteEntryDelegates = CreateDelegatesFromImportExportEntries(
+                projectId, environmentId, state.ToDelete, DeleteConfigAsync, cancellationToken);
         }
 
-        await Task.WhenAll(taskToConfig.Keys);
+        var delegates = createEntryDelegates
+            .Concat(updateEntryDelegates)
+            .Concat(deleteEntryDelegates);
 
-        var failedTasks = taskToConfig.Keys.Where(t => !t.Result);
-        var successfulTasks = taskToConfig.Keys.Where(t => t.Result);
-        var failed = failedTasks.Select(failedTask => taskToConfig[failedTask]).ToList();
-        var imported = successfulTasks.Select(successfulTask => taskToConfig[successfulTask]).ToList();
-
-        LogImportResult(new ImportResult<T>(imported, failed));
+        await Batching.ExecuteInBatchesAsync(
+            delegates,
+            cancellationToken,
+            maxParallelTaskLimit);
     }
 
-    async Task<bool> TryCreateOrUpdateConfigAsync(
+    static List<Func<Task>> CreateDelegatesFromImportExportEntries(
         string projectId,
         string environmentId,
-        T config,
-        IEnumerable<T> configsOnRemote,
+        IReadOnlyCollection<ImportExportEntry<T>> entries,
+        Func<string, string, T, CancellationToken, Task> action,
         CancellationToken cancellationToken)
     {
-        if (IsConfigPresent(config, configsOnRemote, cancellationToken))
+        List<Func<Task>> delegates = new List<Func<Task>>();
+
+        foreach (var entry in entries)
         {
-            return await TryUpdateConfigAsync(projectId, environmentId, config, cancellationToken);
+            delegates.Add(async () =>
+            {
+                try
+                {
+                    await action(
+                        projectId,
+                        environmentId,
+                        entry.Value,
+                        cancellationToken);
+                }
+                catch (Exception e)
+                {
+                    entry.Fail(e);
+                }
+            });
         }
 
-        return await TryCreateConfigAsync(projectId, environmentId, config, cancellationToken);
+        return delegates;
     }
 
-    IEnumerable<T> GetNonMatchingConfigsAsync(
-        string projectId,
-        string environmentId,
-        IEnumerable<T> configs,
-        IEnumerable<T> configsOnRemote,
-        CancellationToken cancellationToken)
+    protected virtual ImportState<T> CreateState(IEnumerable<T> localConfigs, IEnumerable<T> remoteConfigs)
     {
-        return GetConfigsToDelete(configs, configsOnRemote);
+        var localEntries = localConfigs.Select(ToImportExportEntry).ToList();
+        var remoteEntries = remoteConfigs.Select(ToImportExportEntry).ToList();
+
+        var toCreate = localEntries.Except(remoteEntries).ToList();
+        var toUpdate = localEntries.Intersect(remoteEntries).ToList();
+        var toDelete = remoteEntries.Except(localEntries).ToList();
+
+        return new ImportState<T>(toCreate, toUpdate, toDelete);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/IImporter.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/IImporter.cs
index 5ae04c1..e9536f1 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/IImporter.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/IImporter.cs
@@ -4,5 +4,5 @@ namespace Unity.Services.Cli.Authoring.Import;
 
 public interface IImporter
 {
-    Task ImportAsync(ImportInput input, CancellationToken cancellationToken);
-}
+    Task ImportAsync(ImportInput input, CancellationToken cancellationToken, int maxParallelTaskLimit = 10);
+}
\ No newline at end of file
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/ImportResult.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/ImportResult.cs
deleted file mode 100644
index 7f056cc..0000000
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/ImportResult.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-namespace Unity.Services.Cli.Authoring.Import;
-
-public class ImportResult<T>
-{
-    public readonly IEnumerable<T> Imported;
-    public readonly IEnumerable<T> Failed;
-
-    public ImportResult(IEnumerable<T> imported, IEnumerable<T> failed)
-    {
-        Imported = imported;
-        Failed = failed;
-    }
-}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/ImportState.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/ImportState.cs
new file mode 100644
index 0000000..2fdc06d
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/ImportState.cs
@@ -0,0 +1,31 @@
+using Unity.Services.Cli.Authoring.Model;
+
+namespace Unity.Services.Cli.Authoring.Import;
+
+public record ImportState<T>(
+    IReadOnlyCollection<ImportExportEntry<T>> ToCreate,
+    IReadOnlyCollection<ImportExportEntry<T>> ToUpdate,
+    IReadOnlyCollection<ImportExportEntry<T>> ToDelete
+    )
+{
+    public AggregateException? ImportExceptions()
+    {
+        var exceptions = ToCreate.Select(c => c.Exception)
+            .Concat(ToUpdate.Select(c => c.Exception))
+            .Concat(ToDelete.Select(c => c.Exception))
+            .Where(e => e != null)
+            .Cast<Exception>()
+            .ToList();
+
+        if (exceptions.Any())
+        {
+            return new AggregateException(exceptions);
+        }
+
+        return null;
+    }
+
+    internal IEnumerable<ImportExportItem> CreatedItems() => ToCreate.Select(e => e.ToImportExportItem(ImportExportAction.Create));
+    internal IEnumerable<ImportExportItem> UpdatedItems() => ToUpdate.Select(e => e.ToImportExportItem(ImportExportAction.Update));
+    internal IEnumerable<ImportExportItem> DeletedItems() => ToDelete.Select(e => e.ToImportExportItem(ImportExportAction.Delete));
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/Input/ImportInput.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/Input/ImportInput.cs
index f570daa..1a5b16d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/Input/ImportInput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Import/Input/ImportInput.cs
@@ -17,9 +17,9 @@ static ImportInput()
     /* Input directory for the import command */
     public static readonly Argument<string> InputDirectoryArgument = new("in-dir", "The input directory for import command");
 
-    /* Input file name for export command */
+    /* Input file name for import command */
     public static readonly Argument<string> FileNameArgument =
-        new("file-name", "The output file name for export command")
+        new("file-name", "The input file name for import command")
         {
             Arity = ArgumentArity.ZeroOrOne
         };
@@ -28,7 +28,7 @@ static ImportInput()
     public string? InputDirectory { get; set; }
 
     /* Option for reconcile */
-    public static readonly Option<bool> ReconcileOption = new("--reconcile", "The command will do delete already present configs")
+    public static readonly Option<bool> ReconcileOption = new("--reconcile", "The command will delete existing configs before importing")
     {
         Arity = ArgumentArity.Zero
     };
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Input/DeployInput.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Input/DeployInput.cs
index a082423..0e9aaa6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Input/DeployInput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Input/DeployInput.cs
@@ -15,19 +15,34 @@ public class DeployInput : CommonInput
     [InputBinding(nameof(PathsArgument))]
     public IReadOnlyList<string> Paths { get; set; } = new List<string>();
 
-    public static readonly Option<bool> DryRunOption = new(new[]
-    {
-        "--dry-run"
-    }, "Perform a trial run with no changes made.");
+    public static readonly Option<bool> DryRunOption = new(
+        new[]
+        {
+            "--dry-run"
+        },
+        "Perform a trial run with no changes made.");
 
     [InputBinding(nameof(DryRunOption))]
     public bool DryRun { get; set; } = false;
 
-    public static readonly Option<bool> ReconcileOption = new(new[]
-    {
-        "--reconcile"
-    }, "Delete content not part of deploy.");
+    public static readonly Option<bool> ReconcileOption = new(
+        new[]
+        {
+            "--reconcile"
+        },
+        "Delete content not part of deploy.");
 
     [InputBinding(nameof(ReconcileOption))]
     public bool Reconcile { get; set; } = false;
+
+    public static readonly Option<ICollection<string>> ServiceOptions = new(
+        new[]
+        {
+            "--services",
+            "-s"
+        },
+        "The name(s) of the service(s) to perform the command on.");
+
+    [InputBinding(nameof(ServiceOptions))]
+    public IReadOnlyList<string> Services { get; set; } = new List<string>();
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Input/FetchInput.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Input/FetchInput.cs
index 2efc82e..d5b6deb 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Input/FetchInput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Input/FetchInput.cs
@@ -15,20 +15,34 @@ public class FetchInput : CommonInput
     [InputBinding(nameof(PathArgument))]
     public string Path { get; set; } = string.Empty;
 
-    public static readonly Option<bool> ReconcileOption = new(new[]
-    {
-        "--reconcile"
-    }, "Content that is not updated will be created at the root.");
+    public static readonly Option<bool> ReconcileOption = new(
+        new[]
+        {
+            "--reconcile"
+        },
+        "Content that is not updated will be created at the root.");
 
     [InputBinding(nameof(ReconcileOption))]
     public bool Reconcile { get; set; } = false;
 
-    public static readonly Option<bool> DryRunOption = new(new[]
-    {
-        "--dry-run"
-    }, "Perform a trial run with no changes made.");
+    public static readonly Option<ICollection<string>> ServiceOptions = new(
+        new[]
+        {
+            "--services",
+            "-s"
+        },
+        "The name(s) of the service(s) to perform the command on.");
+
+    [InputBinding(nameof(ServiceOptions))]
+    public IReadOnlyList<string> Services { get; set; } = new List<string>();
+
+    public static readonly Option<bool> DryRunOption = new(
+        new[]
+        {
+            "--dry-run"
+        },
+        "Perform a trial run with no changes made.");
 
     [InputBinding(nameof(DryRunOption))]
     public bool DryRun { get; set; } = false;
-
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/AuthorResult.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/AuthorResult.cs
new file mode 100644
index 0000000..52e3bf9
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/AuthorResult.cs
@@ -0,0 +1,174 @@
+using System.Text;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using Unity.Services.DeploymentApi.Editor;
+
+namespace Unity.Services.Cli.Authoring.Model;
+
+[Serializable]
+public abstract class AuthorResult
+{
+    internal const string UpdatedHeader = "Updated";
+    internal const string CreatedHeader = "Created";
+    internal const string DeletedHeader = "Deleted";
+    internal const string DryUpdatedHeader = "Will update";
+    internal const string DryCreatedHeader = "Will create";
+    internal const string DryDeletedHeader = "Will delete";
+
+    internal string AuthoredHeader => $"Successfully {Operation}ed the following files";
+    internal string DryAuthoredHeader => $"Will {Operation} following files";
+    internal string DryFailedHeader => $"Will fail to {Operation}";
+    internal string FailedHeader => $"Failed to {Operation}";
+    internal string NoActionMessage => $"No content {Operation}ed";
+
+    internal abstract string Operation { get; }
+
+    static AuthorResult()
+    {
+        JsonConvert.DefaultSettings = () =>
+        {
+            return new JsonSerializerSettings()
+            {
+                ContractResolver = new DeployContentContractResolver()
+            };
+        };
+    }
+
+    /// <summary>
+    /// All local resources modified by the fetch command (created, updated, and deleted).
+    /// </summary>
+    [JsonIgnore]
+    public IReadOnlyList<IDeploymentItem> Authored { get; protected set; }
+
+    /// <summary>
+    /// All resources (local or remote) that couldn't be handled by the fetch command.
+    /// </summary>
+    public IReadOnlyList<IDeploymentItem> Failed { get; protected set; }
+
+    /// <summary>
+    /// Whether this result constitutes a dry-run, or not.
+    /// A dry-run is a prediction on what will happen on the deploy/fetch execution
+    /// </summary>
+    public bool DryRun { get; }
+
+    /// <summary>
+    /// All local resources updated by the fetch command.
+    /// </summary>
+    public IReadOnlyList<IDeploymentItem> Updated { get; protected set; }
+
+    /// <summary>
+    /// All local resources created by the fetch command.
+    /// </summary>
+    public IReadOnlyList<IDeploymentItem> Created { get; protected set; }
+
+    /// <summary>
+    /// All local resources deleted by the fetch command.
+    /// </summary>
+    public IReadOnlyList<IDeploymentItem> Deleted { get; protected set; }
+
+    protected AuthorResult(IReadOnlyList<IDeploymentItem> results)
+    {
+        Authored = results.Where(r => r.Progress >= 100).ToList();
+        Failed = results.Where(r => r.Progress < 100).ToList();
+        Created = Array.Empty<IDeploymentItem>();
+        Updated = Array.Empty<IDeploymentItem>();
+        Deleted = Array.Empty<IDeploymentItem>();
+    }
+
+    protected AuthorResult(
+        IReadOnlyList<IDeploymentItem> updated,
+        IReadOnlyList<IDeploymentItem> deleted,
+        IReadOnlyList<IDeploymentItem> created,
+        IReadOnlyList<IDeploymentItem> authored,
+        IReadOnlyList<IDeploymentItem> failed,
+        bool dryRun)
+    {
+        Updated = updated;
+        Created = created;
+        Deleted = deleted;
+        Authored = authored;
+        Failed = failed;
+        DryRun = dryRun;
+    }
+
+    protected AuthorResult(IReadOnlyList<AuthorResult> results, bool dryRun = false)
+    {
+        Updated = results.SelectMany(r => r.Updated).ToList();
+        Created = results.SelectMany(r => r.Created).ToList();
+        Deleted = results.SelectMany(r => r.Deleted).ToList();
+        Authored = results.SelectMany(r => r.Authored).ToList();
+        Failed = results.SelectMany(r => r.Failed).ToList();
+        DryRun = dryRun;
+    }
+
+    public override string ToString()
+    {
+        var result = new StringBuilder();
+
+        if (DryRun)
+        {
+            result.AppendLine($"This is a Dry Run. The result below is the expected result for this operation.");
+        }
+
+        AppendFetched(result);
+        AppendResult(result, Failed, !DryRun ? FailedHeader : DryFailedHeader);
+        AppendResult(result, Updated, !DryRun ? UpdatedHeader : DryUpdatedHeader);
+        AppendResult(result, Deleted, !DryRun ? DeletedHeader : DryDeletedHeader);
+        AppendResult(result, Created, !DryRun ? CreatedHeader : DryCreatedHeader);
+
+        return result.ToString();
+    }
+
+    void AppendFetched(StringBuilder builder)
+    {
+        if (Authored.Any())
+        {
+            AppendResult(builder, Authored, !DryRun ? AuthoredHeader : DryAuthoredHeader);
+        }
+        else
+        {
+            builder.AppendLine(NoActionMessage);
+        }
+    }
+
+    internal static void AppendResult(StringBuilder builder, IEnumerable<IDeploymentItem> results, string resultHeader)
+    {
+        var resultList = results.Select(d =>
+        {
+            if (d.Status.MessageSeverity is SeverityLevel.Success or SeverityLevel.Info or SeverityLevel.None)
+                return $"{d}";
+            return $"{d} - Status: {d.Status.Message} - {d.Status.MessageDetail}";
+        }).ToList();
+
+        if (!resultList.Any())
+            return;
+
+        // Add empty entry at first to start at next line.
+        var joinedUpdated = string.Join($"{Environment.NewLine}    ", resultList.Prepend(""));
+        if (builder.Length > 0)
+        {
+            builder.AppendLine();
+        }
+
+        builder.AppendLine($"{resultHeader}:{joinedUpdated}");
+
+
+    }
+
+    public class DeployContentContractResolver : DefaultContractResolver
+    {
+        protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
+        {
+            if (!type.IsAssignableTo(typeof(IDeploymentItem)))
+                return base.CreateProperties(type, memberSerialization);
+
+            IList<JsonProperty> properties = base.CreateProperties(type, memberSerialization);
+            var propertiesToInclude = typeof(DeployContent).GetProperties().Select(p => p.Name).ToList();
+
+            properties =
+                properties.Where(p => propertiesToInclude.Contains( p.PropertyName!) ).ToList();
+
+            return properties;
+        }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/DeployContent.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/DeployContent.cs
index d52487d..656a62f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/DeployContent.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/DeployContent.cs
@@ -1,45 +1,111 @@
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using Newtonsoft.Json;
+using Unity.Services.DeploymentApi.Editor;
+
 namespace Unity.Services.Cli.Authoring.Model;
 
 [Serializable]
-public class DeployContent
+public class DeployContent : IDeploymentItem, ITypedItem
 {
     /// <summary>
     /// Name of the deploy content
     /// </summary>
-    public readonly string Name;
+    public string Name { get; }
 
     /// <summary>
     /// Type of the deploy content
     /// </summary>
-    public readonly string Type;
+    public string Type { get; }
 
     /// <summary>
-    /// Deploy progress of the content
+    /// Path of the deploy content
     /// </summary>
-    public float Progress { get; set; }
+    public string Path { get; set; }
 
     /// <summary>
-    /// Deploy status of the content
+    /// <inheritdoc/>
     /// </summary>
-    public string Status { get; set; }
+    public float Progress
+    {
+        get => m_Progress;
+        set => SetField(ref m_Progress, value);
+    }
 
-    /// <summary>
-    /// Path of the deploy content
-    /// </summary>
-    public readonly string Path;
+    public DeploymentStatus Status
+    {
+        get => m_Status;
+        set => SetField(ref m_Status, value);
+    }
+
+    [JsonIgnore]
+    public ObservableCollection<AssetState> States { get; }
+
+    DeploymentStatus m_Status;
+    float m_Progress;
 
     /// <summary>
     /// Detail message for the status
     /// </summary>
-    public string Detail { get; set; }
+    [JsonIgnore]
+    public string Detail => m_Status.MessageDetail;
 
-    public DeployContent(string name, string type, string path, float progress = 0, string status = "", string detail = "")
+    public DeployContent(string name, string type, string path, float progress = 0, DeploymentStatus? status= null)
     {
         Name = name;
         Type = type;
         Path = path;
+        States = new ObservableCollection<AssetState>();
         Progress = progress;
-        Status = status;
-        Detail = detail;
+        m_Status = status ?? DeploymentStatus.Empty;
+    }
+
+    public DeployContent(
+        string name,
+        string type,
+        string path,
+        float progress,
+        string status,
+        string? detail = null,
+        SeverityLevel level = SeverityLevel.None)
+        : this(name, type, path, progress, new DeploymentStatus(status, detail ?? string.Empty, level))
+    {
+    }
+
+    public override string ToString()
+    {
+        return $"'{Path}'";
+    }
+
+    /// <summary>
+    /// Event will be raised when a property of the instance is changed
+    /// </summary>
+    public event PropertyChangedEventHandler? PropertyChanged;
+
+    /// <summary>
+    /// Sets the field and raises an OnPropertyChanged event.
+    /// </summary>
+    /// <param name="field">The field to set.</param>
+    /// <param name="value">The value to set.</param>
+    /// <param name="onFieldChanged">The callback.</param>
+    /// <param name="propertyName">Name of the property to set.</param>
+    /// <typeparam name="T">Type of the parameter.</typeparam>
+    protected void SetField<T>(
+        ref T field,
+        T value,
+        Action<T>? onFieldChanged = null,
+        [CallerMemberName] string? propertyName = null)
+    {
+        if (EqualityComparer<T>.Default.Equals(field, value))
+            return;
+        field = value;
+        OnPropertyChanged(propertyName!);
+        onFieldChanged?.Invoke(field);
+    }
+
+    void OnPropertyChanged([CallerMemberName] string propertyName = "")
+    {
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/DeploymentResult.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/DeploymentResult.cs
index 44978b5..fda9fa8 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/DeploymentResult.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/DeploymentResult.cs
@@ -1,102 +1,26 @@
+using Unity.Services.DeploymentApi.Editor;
+
 namespace Unity.Services.Cli.Authoring.Model;
 
 [Serializable]
-public class DeploymentResult
+public class DeploymentResult : AuthorResult
 {
-
-    public bool DryRun;
-    public IReadOnlyCollection<DeployContent> Created;
-    public IReadOnlyCollection<DeployContent> Updated;
-    public IReadOnlyCollection<DeployContent> Deleted;
-    public readonly IReadOnlyCollection<DeployContent> Deployed;
-    public readonly IReadOnlyCollection<DeployContent> Failed;
+    public IReadOnlyList<IDeploymentItem> Deployed => Authored;
 
     public DeploymentResult(
-        IReadOnlyCollection<DeployContent> created,
-        IReadOnlyCollection<DeployContent> updated,
-        IReadOnlyCollection<DeployContent> deleted,
-        IReadOnlyCollection<DeployContent> deployed,
-        IReadOnlyCollection<DeployContent> failed,
-        bool dryRun = false
-        )
-    {
-        Created = created;
-        Updated = updated;
-        Deleted = deleted;
-        Deployed = deployed;
-        Failed = failed;
-
-        DryRun = dryRun;
-    }
-
-    public DeploymentResult(IReadOnlyCollection<DeployContent> contents)
+        IReadOnlyList<IDeploymentItem> updated,
+        IReadOnlyList<IDeploymentItem> deleted,
+        IReadOnlyList<IDeploymentItem> created,
+        IReadOnlyList<IDeploymentItem> authored,
+        IReadOnlyList<IDeploymentItem> failed,
+        bool dryRun = false)
+        : base(updated, deleted, created, authored, failed, dryRun)
     {
-        Created = new List<DeployContent>();
-        Updated = new List<DeployContent>();
-        Deleted = new List<DeployContent>();
-        Deployed = contents.Where(c => c.Progress >= 100).ToList();
-        Failed = contents.Where(c => c.Progress < 100f).ToList();
     }
 
-    public override string ToString()
-    {
-        var result = "";
-
-        if (DryRun)
-        {
-            result += $"This is a Dry Run. The result below is the expected result for this operation.";
-        }
-
-        result += Environment.NewLine;
-
-        if (Created.Any())
-        {
-            var createdListString = string.Join(Environment.NewLine + "    ", Created.Select(x => x.Name));
-            var info = DryRun ? "Will create:" : "Created:";
-            result += info + Environment.NewLine + "    " + createdListString;
-        }
+    public DeploymentResult(IReadOnlyList<AuthorResult> results) : base(results) { }
 
-        result += Environment.NewLine;
+    public DeploymentResult(IReadOnlyList<IDeploymentItem> results) : base(results) { }
 
-        if (Updated.Any())
-        {
-            var updatedListString = string.Join(Environment.NewLine + "    ", Updated.Select(x => x.Name));
-            var info = DryRun ? "Will update:" : "Updated:";
-            result += info + Environment.NewLine + "    " + updatedListString;
-        }
-
-        result += Environment.NewLine;
-
-        if (Deleted.Any())
-        {
-            var deletedListString = string.Join(Environment.NewLine + "    ", Deleted.Select(x => x.Name));
-            var info = DryRun ? "Will delete:" : "Deleted:";
-            result += info + Environment.NewLine + "    " + deletedListString;
-        }
-
-        result += Environment.NewLine;
-
-        if (Deployed.Any())
-        {
-            var deployedListString = string.Join(Environment.NewLine + "    ", Deployed.Select(x => x.Name));
-            var info = DryRun ? "Will deploy:" : "Deployed:";
-            result += info + Environment.NewLine + "    " + deployedListString;
-        }
-        else
-        {
-            result += "No content deployed";
-        }
-
-        // Log scripts that failed to deploy
-        if (!Failed.Any()) return result;
-
-        result += Environment.NewLine;
-
-        result = Failed.Aggregate(result, (current, content) =>
-            current + $"{Environment.NewLine}Failed to deploy:{Environment.NewLine}"+
-                      $"    '{Path.GetFileName(content.Name)}' - Status: {content.Status}{Environment.NewLine}"+
-                      $"    {content.Detail}");
-
-        return result;
-    }
+    internal override string Operation => "deploy";
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/DryRunResult.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/DryRunResult.cs
deleted file mode 100644
index 7dc31b3..0000000
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/DryRunResult.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-using System.Text;
-
-namespace Unity.Services.Cli.Authoring.Model;
-
-public class DryRunResult<T>
-{
-    readonly string m_Legend;
-    readonly IEnumerable<T> m_Results;
-    readonly Func<T, string> m_ToStringFunc;
-
-    public DryRunResult(string legend, IEnumerable<T> results, Func<T, string> toStringFunc)
-    {
-        m_Legend = legend;
-        m_Results = results;
-        m_ToStringFunc = toStringFunc;
-    }
-
-    public override string ToString()
-    {
-        var stringBuilder = new StringBuilder();
-
-        stringBuilder.Append($"{m_Legend}{Environment.NewLine}");
-
-        foreach (var result in m_Results)
-        {
-            stringBuilder.Append($"{m_ToStringFunc(result)}{Environment.NewLine}");
-        }
-
-        return stringBuilder.ToString();
-    }
-}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/FetchResult.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/FetchResult.cs
index 0f49220..93ffbaf 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/FetchResult.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/FetchResult.cs
@@ -1,105 +1,28 @@
-using System.Text;
-
+using Unity.Services.DeploymentApi.Editor;
 namespace Unity.Services.Cli.Authoring.Model;
 
 /// <summary>
 /// Contain the data summary of a fetch operation.
 /// </summary>
 [Serializable]
-public class FetchResult
+public class FetchResult : AuthorResult
 {
-    internal const string EmptyFetchMessage = "No content fetched";
-    internal const string FetchedHeader = "Successfully fetched into the following files";
-    internal const string FailedHeader = "Failed to fetch";
-    internal const string UpdatedHeader = "Updated";
-    internal const string CreatedHeader = "Created";
-    internal const string DeletedHeader = "Deleted";
-
-    /// <summary>
-    /// All local resources modified by the fetch command (created, updated, and deleted).
-    /// </summary>
-    public IReadOnlyList<string> Fetched { get; }
-
-    /// <summary>
-    /// All resources (local or remote) that couldn't be handled by the fetch command.
-    /// </summary>
-    public IReadOnlyList<string> Failed { get; }
-
-    /// <summary>
-    /// All local resources updated by the fetch command.
-    /// </summary>
-    public IReadOnlyList<string> Updated { get; }
-
-    /// <summary>
-    /// All local resources created by the fetch command.
-    /// </summary>
-    public IReadOnlyList<string> Created { get; }
-
-    /// <summary>
-    /// All local resources deleted by the fetch command.
-    /// </summary>
-    public IReadOnlyList<string> Deleted { get; }
+    public IReadOnlyList<IDeploymentItem> Fetched => Authored;
 
     public FetchResult(
-        IReadOnlyList<string> updated,
-        IReadOnlyList<string> deleted,
-        IReadOnlyList<string> created,
-        IReadOnlyList<string> fetched,
-        IReadOnlyList<string> failed)
+        IReadOnlyList<IDeploymentItem> updated,
+        IReadOnlyList<IDeploymentItem> deleted,
+        IReadOnlyList<IDeploymentItem> created,
+        IReadOnlyList<IDeploymentItem> authored,
+        IReadOnlyList<IDeploymentItem> failed,
+        bool dryRun = false)
+        : base(updated, deleted, created, authored, failed, dryRun)
     {
-        Updated = updated;
-        Created = created;
-        Deleted = deleted;
-        Fetched = fetched;
-        Failed = failed;
     }
 
-    public FetchResult(IReadOnlyList<FetchResult> results)
+    public FetchResult(IReadOnlyList<AuthorResult> results, bool dryRun = false) : base(results, dryRun)
     {
-        Updated = results.SelectMany(r => r.Updated).ToList();
-        Created = results.SelectMany(r => r.Created).ToList();
-        Deleted = results.SelectMany(r => r.Deleted).ToList();
-        Fetched = results.SelectMany(r => r.Fetched).ToList();
-        Failed = results.SelectMany(r => r.Failed).ToList();
     }
 
-    public override string ToString()
-    {
-        var result = new StringBuilder();
-        AppendFetched(result);
-        AppendResult(result, Failed, FailedHeader);
-        AppendResult(result, Updated, UpdatedHeader);
-        AppendResult(result, Deleted, DeletedHeader);
-        AppendResult(result, Created, CreatedHeader);
-
-        return result.ToString();
-    }
-
-    void AppendFetched(StringBuilder builder)
-    {
-        if (Fetched.Any())
-        {
-            AppendResult(builder, Fetched, FetchedHeader);
-        }
-        else
-        {
-            builder.AppendLine(EmptyFetchMessage);
-        }
-    }
-
-    internal static void AppendResult(StringBuilder builder, IEnumerable<string> results, string resultHeader)
-    {
-        var resultList = results.ToList();
-        if (!resultList.Any())
-            return;
-
-        // Add empty entry at first to start at next line.
-        var joinedUpdated = string.Join($"{Environment.NewLine}    ", resultList.Prepend(""));
-        if (builder.Length > 0)
-        {
-            builder.AppendLine();
-        }
-
-        builder.AppendLine($"{resultHeader}:{joinedUpdated}");
-    }
+    internal override string Operation => "fetch";
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/ImportExportEntry.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/ImportExportEntry.cs
new file mode 100644
index 0000000..84023ad
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/ImportExportEntry.cs
@@ -0,0 +1,52 @@
+using Newtonsoft.Json;
+
+namespace Unity.Services.Cli.Authoring.Model;
+
+public sealed class ImportExportEntry<T>
+{
+    public long Id { get; }
+    public string Name { get; }
+    public T Value { get; }
+    public Exception? Exception { get; private set; }
+
+    public ImportExportEntry(long id, string name, T value)
+    {
+        Id = id;
+        Name = name;
+        Value = value;
+    }
+
+    internal ImportExportItem ToImportExportItem(ImportExportAction action)
+    {
+        return new ImportExportItem(Name, action, Exception == null);
+    }
+
+    public void Fail(Exception e)
+    {
+        Exception = e;
+    }
+
+    public override string ToString()
+    {
+        return Name;
+    }
+
+    bool Equals(ImportExportEntry<T> other)
+    {
+        return Id == other.Id;
+    }
+
+    public override bool Equals(object? obj)
+    {
+        if (ReferenceEquals(null, obj)) return false;
+        if (ReferenceEquals(this, obj)) return true;
+        if (obj.GetType() != this.GetType()) return false;
+        return Equals((ImportExportEntry<T>)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        return Id.GetHashCode();
+    }
+}
+
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/ImportExportResult.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/ImportExportResult.cs
new file mode 100644
index 0000000..73019e2
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/ImportExportResult.cs
@@ -0,0 +1,50 @@
+using System.Text;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace Unity.Services.Cli.Authoring.Model;
+
+[Serializable]
+record ImportExportResult(IReadOnlyCollection<ImportExportItem> Items)
+{
+    [JsonIgnore]
+    public string? Header { get; set; }
+    public bool DryRun { get; set; }
+
+    public override string ToString()
+    {
+        var builder = new StringBuilder();
+
+        void PrintSection(string heading, ImportExportAction action)
+        {
+            var toPrint = Items.Where(i => i.Action == action).ToList();
+            if (toPrint.Any())
+            {
+                builder.AppendLine(heading);
+                foreach (var value in toPrint)
+                {
+                    builder.AppendLine($"    {value.Name}");
+                }
+            }
+        }
+
+        builder.AppendLine(Header);
+        PrintSection("Exported:", ImportExportAction.Export);
+        PrintSection("Created:", ImportExportAction.Create);
+        PrintSection("Updated:", ImportExportAction.Update);
+        PrintSection("Deleted:", ImportExportAction.Delete);
+
+        return builder.ToString();
+    }
+}
+
+[Serializable]
+record ImportExportItem(string Name,  [property: JsonConverter(typeof(StringEnumConverter))] ImportExportAction Action, bool Success);
+
+enum ImportExportAction
+{
+    Export,
+    Create,
+    Update,
+    Delete
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/Statuses.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/Statuses.cs
index a23fc6f..9c092df 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/Statuses.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Model/Statuses.cs
@@ -3,6 +3,11 @@ namespace Unity.Services.Cli.Authoring.Model;
 public static class Statuses
 {
     public const string FailedToRead = "Failed To Read";
+    public const string Created = "Created";
+    public const string Updated = "Updated";
+    public const string Deleted = "Deleted";
+    public const string Loading = "Loading";
     public const string Loaded = "Loaded";
     public const string Deployed = "Deployed";
+    public const string Fetched = "Fetched";
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Service/IDeploymentService.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Service/IDeploymentService.cs
index ebd185e..cea7171 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Service/IDeploymentService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Service/IDeploymentService.cs
@@ -7,6 +7,7 @@ namespace Unity.Services.Cli.Authoring.Service;
 public interface IDeploymentService
 {
     string ServiceType { get; }
+    string ServiceName { get; }
     public string DeployFileExtension { get; }
 
     Task<DeploymentResult> Deploy(
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Service/IFetchService.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Service/IFetchService.cs
index f15afa5..0e49fb4 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Service/IFetchService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Service/IFetchService.cs
@@ -7,6 +7,7 @@ namespace Unity.Services.Cli.Authoring.Service;
 public interface IFetchService
 {
     string ServiceType { get; }
+    string ServiceName { get; }
     protected string FileExtension { get; }
 
     Task<FetchResult> FetchAsync(
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Unity.Services.Cli.Authoring.csproj b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Unity.Services.Cli.Authoring.csproj
index 18743ed..cf52464 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Unity.Services.Cli.Authoring.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Unity.Services.Cli.Authoring.csproj
@@ -18,7 +18,8 @@
     <ProjectReference Include="..\Unity.Services.Cli.Common\Unity.Services.Cli.Common.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="System.IO.Abstractions" Version="19.2.9" />
+    <PackageReference Include="System.IO.Abstractions" Version="19.2.16" />
+    <PackageReference Include="Unity.Services.DeploymentApi" Version="1.0.0-beta.1" />
   </ItemGroup>
   <PropertyGroup>
     <DefineConstants Condition=" '$(ExtraDefineConstants)' != '' ">$(DefineConstants);$(ExtraDefineConstants)</DefineConstants>
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Authoring/Utils/ImportExportUtils.cs b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Utils/ImportExportUtils.cs
new file mode 100644
index 0000000..ba28af5
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Authoring/Utils/ImportExportUtils.cs
@@ -0,0 +1,33 @@
+using Unity.Services.Cli.Common.Exceptions;
+
+namespace Unity.Services.Cli.Authoring.Utils;
+
+public static class ImportExportUtils
+{
+    /// <summary>
+    /// Determines the file name that should be used for the import or export.
+    /// </summary>
+    /// <param name="fileName">The value of the filename argument.</param>
+    /// <param name="defaultFileName">The default filename as well as the definition of the expected extension.</param>
+    /// <returns>The user provided file name if available, or the default otherwise.</returns>
+    /// <exception cref="CliException">Thrown if the user provides an file name that does not match the extension of the default file name.</exception>
+    public static string ResolveFileName(string? fileName, string defaultFileName)
+    {
+        if (string.IsNullOrWhiteSpace(fileName))
+        {
+            return defaultFileName;
+        }
+
+        // Make sure the provided filename matches the default
+        string defaultExtension = Path.GetExtension(defaultFileName);
+        string inputExtension = Path.GetExtension(fileName);
+
+        if(inputExtension != defaultExtension)
+        {
+            throw new CliException($"The file-name argument must have the extension '{defaultExtension}'.", null, ExitCode.HandledError);
+        }
+
+        return fileName;
+    }
+
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Clients/CloudCodeScriptClientTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Clients/CloudCodeScriptClientTests.cs
index 201c098..c54fb58 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Clients/CloudCodeScriptClientTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Clients/CloudCodeScriptClientTests.cs
@@ -29,7 +29,7 @@ class CloudCodeScriptClientTests
 
     readonly Mock<ICloudCodeService> m_MockCcService = new();
     readonly Mock<ICloudCodeInputParser> m_MockCcInputParser = new();
-    private readonly Mock<ICloudCodeScriptParser> m_MockCLoudCodeScriptParser = new();
+    readonly Mock<ICloudCodeScriptParser> m_MockCLoudCodeScriptParser = new();
     readonly CloudCodeScriptClient m_CloudCodeScriptClient;
     readonly IScript m_Script = new CloudCodeScript(
         ScriptName.FromPath(k_File),
@@ -57,7 +57,9 @@ public void SetUp()
         m_MockCcInputParser.Reset();
         m_MockCcInputParser.Setup(c => c.LoadScriptCodeAsync(k_File, CancellationToken.None))
             .ReturnsAsync(k_Script);
-
+        m_MockCLoudCodeScriptParser.Setup(ex => ex
+                .ParseScriptParametersAsync(k_Script, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new ParseScriptParametersResult(false, new List<ScriptParameter>()));
         m_CloudCodeScriptClient.EnvironmentId = TestValues.ValidEnvironmentId;
         m_CloudCodeScriptClient.ProjectId = TestValues.ValidProjectId;
         m_CloudCodeScriptClient.CancellationToken = CancellationToken.None;
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Fetch/JavaScriptFetchHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Fetch/JavaScriptFetchHandlerTests.cs
index d52e6e0..37b4431 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Fetch/JavaScriptFetchHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Fetch/JavaScriptFetchHandlerTests.cs
@@ -13,6 +13,7 @@
 using Unity.Services.Cli.CloudCode.Authoring;
 using Unity.Services.Cli.CloudCode.Deploy;
 using Unity.Services.Cli.CloudCode.Exceptions;
+using Unity.Services.Cli.CloudCode.Model;
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.Cli.TestUtils;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
@@ -137,15 +138,10 @@ CloudCodeScript SetUpParameterLessBody(CloudCodeScript script)
         {
             script.Body = $"// {k_ParameterLessErrorMessage}";
             script.LastPublishedDate = DateTime.MinValue.ToString(CultureInfo.InvariantCulture);
-            script.Parameters = new List<CloudCodeParameter>
-            {
-                new()
-                {
-                    Name = "bar",
-                    ParameterType = ParameterType.JSON,
-                }
-            };
-            SetUpParsingFailure(script.Body, k_ParameterLessErrorMessage);
+
+            m_ScriptParser.Setup(x => x.ParseScriptParametersAsync(script.Body, CancellationToken.None))
+                .ReturnsAsync(new ParseScriptParametersResult(false, new List<ScriptParameter>()));
+
             return script;
         }
 
@@ -161,11 +157,10 @@ CloudCodeScript SetUpWithParameters(CloudCodeScript script)
                 }
             };
             m_ScriptParser.Setup(x => x.ParseScriptParametersAsync(script.Body, CancellationToken.None))
-                .ReturnsAsync(
-                    new[]
-                    {
-                        new ScriptParameter("foo")
-                    });
+                .ReturnsAsync(new ParseScriptParametersResult(false, new[]
+                {
+                    new ScriptParameter("foo")
+                }));
 
             return script;
         }
@@ -345,13 +340,8 @@ void AssertKnownMissingParametersHaveBeenInjected()
             Assert.That(failed, Does.Not.Contain(m_AnyParameterLessScript));
             Assert.That(failed, Does.Not.Contain(m_AnyScriptWithParameters));
             Assert.That(m_AnyParameterLessScript.Body, Is.Not.EqualTo(originalParameterLessBody));
-            Assert.That(m_AnyScriptWithParameters.Body, Is.EqualTo(originalBodyWithParameters));
+            Assert.That(m_AnyScriptWithParameters.Body, Is.Not.EqualTo(originalBodyWithParameters));
             TestsHelper.VerifyLoggerWasCalled(m_Logger, LogLevel.Warning, message: k_UnpublishedErrorMessage);
-            TestsHelper.VerifyLoggerWasCalled(m_Logger, LogLevel.Warning, message: k_ParameterLessErrorMessage);
-            TestsHelper.VerifyLoggerWasCalled(
-                m_Logger,
-                LogLevel.Warning,
-                message: $"\"{m_AnyUnpublishedScript.Path}\" parameters couldn't be determined.");
         }
     }
 
@@ -452,11 +442,11 @@ static void AssertResult(
             .Union(expectedDeleted)
             .Union(expectedUpdated)
             .ToList();
-        Assert.That(result.Created, Is.EquivalentTo(expectedCreated));
-        Assert.That(result.Deleted, Is.EquivalentTo(expectedDeleted));
-        Assert.That(result.Updated, Is.EquivalentTo(expectedUpdated));
-        Assert.That(result.Failed, Is.EquivalentTo(expectedFailures));
-        Assert.That(result.Fetched, Is.EquivalentTo(expectedFetched));
+        Assert.That(result.Created.Select(c => c.Name), Is.EquivalentTo(expectedCreated));
+        Assert.That(result.Deleted.Select(c => c.Name), Is.EquivalentTo(expectedDeleted));
+        Assert.That(result.Updated.Select(c => c.Name), Is.EquivalentTo(expectedUpdated));
+        Assert.That(result.Failed.Select(c => c.Name), Is.EquivalentTo(expectedFailures));
+        Assert.That(result.Fetched.Select(c => c.Name), Is.EquivalentTo(expectedFetched));
     }
 
     [Test]
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Fetch/JavaScriptFetchServiceTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Fetch/JavaScriptFetchServiceTests.cs
index 9a2d043..b67d044 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Fetch/JavaScriptFetchServiceTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Fetch/JavaScriptFetchServiceTests.cs
@@ -13,6 +13,7 @@
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.Cli.CloudCode.Service;
 using Unity.Services.Cli.CloudCode.UnitTest.Utils;
+using Unity.Services.Cli.CloudCode.Utils;
 using Unity.Services.Cli.Common.Utils;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
 
@@ -68,11 +69,11 @@ public async Task FetchAsyncInitializesClientAndGetsResultFromHandler(bool dryRu
         m_UnityEnvironment.Setup(x => x.FetchIdentifierAsync())
             .ReturnsAsync(TestValues.ValidEnvironmentId);
         var expectedResult = new FetchResult(
-            Array.Empty<string>(),
-            Array.Empty<string>(),
-            Array.Empty<string>(),
-            Array.Empty<string>(),
-            Array.Empty<string>());
+            Array.Empty<DeployContent>(),
+            Array.Empty<DeployContent>(),
+            Array.Empty<DeployContent>(),
+            Array.Empty<DeployContent>(),
+            Array.Empty<DeployContent>());
         m_FetchHandler.Setup(
                 x => x.FetchAsync(input.Path, scripts, input.DryRun, input.Reconcile, CancellationToken.None))
             .ReturnsAsync(expectedResult);
@@ -102,18 +103,17 @@ void SetupLocalResources(out FetchInput input, out List<IScript> scripts)
         m_DeployFileService.Setup(
                 x => x.ListFilesToDeploy(
                     It.IsAny<IReadOnlyList<string>>(),
-                    Constants.JavaScriptFileExtension))
+                    CloudCodeConstants.JavaScriptFileExtension))
             .Returns(files);
         m_ScriptsLoader.Setup(
                 x => x.LoadScriptsAsync(
                     files,
-                    Constants.ServiceType,
-                    Constants.JavaScriptFileExtension,
+                    CloudCodeConstants.ServiceType,
+                    CloudCodeConstants.JavaScriptFileExtension,
                     m_InputParser.Object,
                     m_ScriptParser.Object,
-                    It.IsAny<ICollection<DeployContent>>(),
                     CancellationToken.None))
-            .ReturnsAsync(new CloudCodeScriptLoadResult(scripts, new List<DeployContent>()));
+            .ReturnsAsync(new CloudCodeScriptLoadResult(scripts, new List<IScript>()));
     }
 
     [Test]
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Utils/CloudCodeScriptNameComparerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Utils/CloudCodeScriptNameComparerTests.cs
index ca99fb5..a3e9f9e 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Utils/CloudCodeScriptNameComparerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Utils/CloudCodeScriptNameComparerTests.cs
@@ -47,7 +47,7 @@ public void GetHashCodeReturnsScriptNameHashCode()
     {
         var script = new Mock<IScript>();
         var name = new ScriptName("foo.js");
-        script.Setup(x => x.Name)
+        script.SetupGet(x => x.Name)
             .Returns(name);
 
         var hashCode = m_Comparer.GetHashCode(script.Object);
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Utils/ScriptExtensionsTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Utils/ScriptExtensionsTests.cs
index efe8851..8f166ca 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Utils/ScriptExtensionsTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Authoring/Utils/ScriptExtensionsTests.cs
@@ -19,7 +19,6 @@ public void InjectParametersToBodyDoesAppendParametersToBody()
         };
         var builder = new StringBuilder();
         var expectedBody = script.Body
-            + System.Environment.NewLine
             + System.Environment.NewLine
             + $"module.exports.params = {TestValues.ValidParametersToJavaScript};"
             + $"{System.Environment.NewLine}";
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/CloudCodeModuleTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/CloudCodeModuleTests.cs
index 79a9c45..d1cc76f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/CloudCodeModuleTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/CloudCodeModuleTests.cs
@@ -33,12 +33,13 @@ class CloudCodeModuleTests
 
     static readonly IEnumerable<TestCaseData> k_CloudCodeCommandTestCases = new[]
     {
-        new TestCaseData(k_CloudCodeModule.ListCommand),
-        new TestCaseData(k_CloudCodeModule.DeleteCommand),
-        new TestCaseData(k_CloudCodeModule.UpdateCommand),
-        new TestCaseData(k_CloudCodeModule.GetCommand),
-        new TestCaseData(k_CloudCodeModule.PublishCommand),
-        new TestCaseData(k_CloudCodeModule.NewFileCommand)
+        new TestCaseData(k_CloudCodeModule.ModuleRootCommand, k_CloudCodeModule.ScriptsCommand),
+        new TestCaseData(k_CloudCodeModule.ScriptsCommand, k_CloudCodeModule.ListCommand),
+        new TestCaseData(k_CloudCodeModule.ScriptsCommand, k_CloudCodeModule.DeleteCommand),
+        new TestCaseData(k_CloudCodeModule.ScriptsCommand, k_CloudCodeModule.UpdateCommand),
+        new TestCaseData(k_CloudCodeModule.ScriptsCommand, k_CloudCodeModule.GetCommand),
+        new TestCaseData(k_CloudCodeModule.ScriptsCommand, k_CloudCodeModule.PublishCommand),
+        new TestCaseData(k_CloudCodeModule.ScriptsCommand, k_CloudCodeModule.NewFileCommand)
     };
 
     [Test]
@@ -61,12 +62,21 @@ public void BuildCommands_CreateAliases()
         Assert.IsTrue(k_CloudCodeModule.ModuleRootCommand.Aliases.Contains("cc"));
     }
 
+    [Test]
+    public void ScriptCommandsContainsAlias()
+    {
+        var commandLineBuilder = new CommandLineBuilder();
+        commandLineBuilder.AddModule(k_CloudCodeModule);
+
+        Assert.IsTrue(k_CloudCodeModule.ScriptsCommand.Aliases.Contains("s"));
+    }
+
     [TestCaseSource(nameof(k_CloudCodeCommandTestCases))]
-    public void CommandContainCommands(Command expectedCommand)
+    public void CommandContainsCommands(Command parentCommand, Command childCommand)
     {
         TestsHelper.AssertContainsCommand(
-            k_CloudCodeModule.ModuleRootCommand, expectedCommand.Name, out var resultCommand);
-        Assert.AreEqual(expectedCommand, resultCommand);
+            parentCommand, childCommand.Name, out var resultCommand);
+        Assert.AreEqual(childCommand, resultCommand);
     }
 
     [Test]
@@ -152,7 +162,7 @@ public void CreateJavaScriptDeployServiceCreatesInstanceWithReferencesToProvided
         var inputParser = new Mock<ICloudCodeInputParser>();
         var environmentProvider = new Mock<ICliEnvironmentProvider>();
         var client = new Mock<IJavaScriptClient>();
-        var deploymentHandlerWithOutput = new CliCloudCodeDeploymentHandler<IJavaScriptClient>(
+        var deploymentHandler = new CliCloudCodeDeploymentHandler<IJavaScriptClient>(
             null!, null!, null!, null!, null!);
         var provider = new Mock<IServiceProvider>();
         SetupProvider();
@@ -168,7 +178,7 @@ void SetupProvider()
             provider.Setup(x => x.GetService(typeof(ICloudCodeScriptParser)))
                 .Returns(scriptParser.Object);
             provider.Setup(x => x.GetService(typeof(CliCloudCodeDeploymentHandler<IJavaScriptClient>)))
-                .Returns(deploymentHandlerWithOutput);
+                .Returns(deploymentHandler);
             provider.Setup(x => x.GetService(typeof(ICloudCodeScriptsLoader)))
                 .Returns(scriptsLoader.Object);
             provider.Setup(x => x.GetService(typeof(ICliEnvironmentProvider)))
@@ -181,10 +191,6 @@ void AssertExpectedServicesAreWrapped()
         {
             Assert.That(deployService.CloudCodeInputParser, Is.SameAs(inputParser.Object));
             Assert.That(deployService.CloudCodeScriptParser, Is.SameAs(scriptParser.Object));
-            Assert.That(
-                deployService.CliDeploymentOutputHandler,
-                Is.SameAs(deployService.CloudCodeDeploymentHandler));
-            Assert.That(deployService.CliDeploymentOutputHandler, Is.SameAs(deploymentHandlerWithOutput));
             Assert.That(deployService.CloudCodeScriptsLoader, Is.SameAs(scriptsLoader.Object));
             Assert.That(deployService.EnvironmentProvider, Is.SameAs(environmentProvider.Object));
             Assert.That(deployService.CliCloudCodeClient, Is.SameAs(client.Object));
@@ -220,10 +226,6 @@ void SetupProvider()
 
         void AssertExpectedServicesAreWrapped()
         {
-            Assert.That(
-                deployService.CliDeploymentOutputHandler,
-                Is.SameAs(deployService.CloudCodeDeploymentHandler));
-            Assert.That(deployService.CliDeploymentOutputHandler, Is.SameAs(deploymentHandlerWithOutput));
             Assert.That(deployService.CloudCodeModulesLoader, Is.SameAs(csModuleLoader.Object));
             Assert.That(deployService.EnvironmentProvider, Is.SameAs(environmentProvider.Object));
             Assert.That(deployService.CliCloudCodeClient, Is.SameAs(client.Object));
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeModuleDownloaderTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeModuleDownloaderTests.cs
new file mode 100644
index 0000000..af78d35
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeModuleDownloaderTests.cs
@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Moq;
+using Moq.Protected;
+using NUnit.Framework;
+using Unity.Services.Cli.CloudCode.Deploy;
+using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
+using Module = Unity.Services.Cli.CloudCode.Deploy.CloudCodeModule;
+using Language = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
+
+namespace Unity.Services.Cli.CloudCode.UnitTest.Deploy;
+
+public class CloudCodeModuleDownloaderTests
+{
+
+    readonly Mock<HttpMessageHandler> m_MockHttpClientHandler = new();
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_MockHttpClientHandler.Reset();
+        m_MockHttpClientHandler.Protected()
+            .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
+            .ReturnsAsync(new HttpResponseMessage { StatusCode = HttpStatusCode.OK });
+    }
+
+    [Test]
+    [Ignore("This is not a unit test, either mock or turn into an integration test")]
+    public async Task DownloadModule_Success()
+    {
+        var testModule = new Unity.Services.Cli.CloudCode.Deploy.CloudCodeModule(
+            new ScriptName("test_a.zip"),
+            Language.JS,
+            Path.Join("project-id","env-id", "test_a" + ".ccm"));
+
+        var client = new HttpClient(m_MockHttpClientHandler.Object)
+        {
+            BaseAddress = new Uri("https://localhost:8080")
+        };
+
+        var cloudCodeModulesDownloader = new CloudCodeModulesDownloader(client);
+        var actual = await cloudCodeModulesDownloader.DownloadModule(
+            testModule,
+            new CancellationToken());
+
+        Assert.IsInstanceOf(typeof(Stream), actual);
+        m_MockHttpClientHandler.Protected().Verify(
+            "SendAsync",
+            Times.Once(),
+            ItExpr.Is<HttpRequestMessage>(req =>
+                req.Method == HttpMethod.Get
+            ),
+            ItExpr.IsAny<CancellationToken>()
+        );
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeModuleLoaderTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeModuleLoaderTests.cs
index dbc1cbd..3e1a024 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeModuleLoaderTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeModuleLoaderTests.cs
@@ -64,9 +64,7 @@ public async Task LoadPrecompiledModulesAsync_Deploys()
 
         var actual = await cloudCodeModulesLoader.LoadPrecompiledModulesAsync(
             k_ValidZipPaths,
-            "Cloud Code Modules",
-            ".zip",
-            m_Contents);
+            "Cloud Code Modules");
 
         CompareScripts(expected, actual);
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodePrecompiledModuleDeploymentServiceTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodePrecompiledModuleDeploymentServiceTests.cs
index 04f5ad7..7bc7585 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodePrecompiledModuleDeploymentServiceTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodePrecompiledModuleDeploymentServiceTests.cs
@@ -4,17 +4,18 @@
 using System.Threading.Tasks;
 using Moq;
 using NUnit.Framework;
-using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.CloudCode.Authoring;
 using Unity.Services.Cli.CloudCode.Deploy;
 using Unity.Services.Cli.CloudCode.Input;
-using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.Cli.CloudCode.Service;
 using Unity.Services.Cli.CloudCode.UnitTest.Utils;
+using Unity.Services.Cli.CloudCode.Utils;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Deployment;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Client;
 using AuthoringLanguage = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
+using CloudCodeModuleScript = Unity.Services.Cli.CloudCode.Deploy.CloudCodeModule;
 
 namespace Unity.Services.Cli.CloudCode.UnitTest.Deploy;
 
@@ -31,17 +32,29 @@ public class CloudCodePrecompiledModuleDeploymentServiceTests
     readonly Mock<ICliEnvironmentProvider> m_MockEnvironmentProvider = new();
     readonly Mock<ICloudCodeInputParser> m_MockCloudCodeInputParser = new();
     readonly Mock<ICloudCodeService> m_MockCloudCodeService = new();
-    readonly Mock<IDeploymentHandlerWithOutput> m_DeploymentHandlerWithOutput = new();
+    readonly Mock<ICloudCodeDeploymentHandler> m_DeploymentHandler = new();
     readonly Mock<ICloudCodeModulesLoader> m_MockCloudCodeModulesLoader = new();
-    static readonly IReadOnlyCollection<DeployContent> k_DeployedContents = new[]
+    static readonly IReadOnlyList<CloudCodeModuleScript> k_DeployedContents = new[]
     {
-        new DeployContent("module.ccm", "Cloud Code", "path", 100, "Published"),
+        new CloudCodeModuleScript(
+            "module.ccm",
+            "path",
+            100,
+            DeploymentStatus.UpToDate)
     };
 
-    static readonly IReadOnlyCollection<DeployContent> k_FailedContents = new[]
+    static readonly IReadOnlyList<CloudCodeModuleScript> k_FailedContents = new[]
     {
-        new DeployContent("invalid1.ccm", "Cloud Code", "path", 0, "Failed to Load"),
-        new DeployContent("invalid2.ccm", "Cloud Code", "path", 0, "Failed to Load"),
+        new CloudCodeModuleScript(
+            "invalid1.ccm",
+            "path",
+            0,
+            DeploymentStatus.Empty),
+        new CloudCodeModuleScript(
+            "invalid2.ccm",
+            "path",
+            0,
+            DeploymentStatus.Empty)
     };
 
     readonly List<ScriptInfo> m_RemoteContents = new()
@@ -49,7 +62,7 @@ public class CloudCodePrecompiledModuleDeploymentServiceTests
         new ScriptInfo("ToDelete", ".ccm")
     };
 
-    readonly List<DeployContent> m_Contents = k_DeployedContents.Concat(k_FailedContents).ToList();
+    readonly List<CloudCodeModuleScript> m_Contents = k_DeployedContents.Concat(k_FailedContents).ToList();
 
     CloudCodePrecompiledModuleDeploymentService? m_DeploymentService;
 
@@ -61,13 +74,24 @@ public void SetUp()
         m_MockCloudCodeInputParser.Reset();
         m_MockCloudCodeService.Reset();
         m_MockCloudCodeModulesLoader.Reset();
-        m_DeploymentHandlerWithOutput.Reset();
+        m_DeploymentHandler.Reset();
 
-        m_DeploymentHandlerWithOutput.SetupGet(c => c.Contents)
-            .Returns(m_Contents);
+        m_DeploymentHandler.Setup(
+                c => c.DeployAsync(
+                    It.IsAny<IEnumerable<IScript>>(),
+                    It.IsAny<bool>(),
+                    It.IsAny<bool>()))
+            .Returns(
+                Task.FromResult(
+                    new DeployResult(
+                        new List<IScript>(),
+                        new List<IScript>(),
+                        new List<IScript>(),
+                        k_DeployedContents,
+                        k_FailedContents)));
 
         m_DeploymentService = new CloudCodePrecompiledModuleDeploymentService(
-            m_DeploymentHandlerWithOutput.Object,
+            m_DeploymentHandler.Object,
             m_MockCloudCodeModulesLoader.Object,
             m_MockEnvironmentProvider.Object,
             m_MockCloudCodeClient.Object);
@@ -75,10 +99,8 @@ public void SetUp()
         m_MockCloudCodeModulesLoader.Setup(
                 c => c.LoadPrecompiledModulesAsync(
                     k_ValidFilePaths,
-                    "Cloud Code Modules",
-                    ".ccm",
-                    m_Contents))
-            .ReturnsAsync(new List<IScript>());
+                    CloudCodeConstants.ServiceTypeModules))
+            .ReturnsAsync(k_DeployedContents.OfType<IScript>().ToList());
     }
 
     [Test]
@@ -99,9 +121,7 @@ public async Task DeployAsync_CallsLoadFilePathsFromInputCorrectly()
         m_MockCloudCodeModulesLoader.Setup(
                 c => c.LoadPrecompiledModulesAsync(
                     k_ValidFilePaths,
-                    "Cloud Code",
-                    ".ccm",
-                    m_Contents))
+                    It.IsAny<string>()))
             .ReturnsAsync(
                 new List<IScript>
                 {
@@ -123,7 +143,7 @@ public async Task DeployAsync_CallsLoadFilePathsFromInputCorrectly()
                 CancellationToken.None),
             Times.Once);
         m_MockEnvironmentProvider.VerifySet(x => { x.Current = TestValues.ValidEnvironmentId; }, Times.Once);
-        m_DeploymentHandlerWithOutput.Verify(x => x.DeployAsync(It.IsAny<List<IScript>>(), false, false), Times.Once);
+        m_DeploymentHandler.Verify(x => x.DeployAsync(It.IsAny<List<IScript>>(), false, false), Times.Once);
         Assert.AreEqual(k_DeployedContents, result.Deployed);
         Assert.AreEqual(k_FailedContents, result.Failed);
     }
@@ -137,13 +157,13 @@ public async Task DeployReconcileAsync_WillCreateDeleteContent()
             CloudProjectId = TestValues.ValidProjectId,
         };
 
-        List<IScript> testModules = new List<IScript>
+        var testModules = new []
         {
-            new Unity.Services.Cli.CloudCode.Deploy.CloudCodeModule(
+            new CloudCodeModuleScript(
                 new ScriptName("module.ccm"),
                 Language.JS,
                 "modules"),
-            new Unity.Services.Cli.CloudCode.Deploy.CloudCodeModule(
+            new CloudCodeModuleScript(
                 new ScriptName("module2.ccm"),
                 Language.JS,
                 "modules")
@@ -153,12 +173,10 @@ public async Task DeployReconcileAsync_WillCreateDeleteContent()
         m_MockCloudCodeModulesLoader.Setup(
                 c => c.LoadPrecompiledModulesAsync(
                     k_ValidFilePaths,
-                    "Cloud Code",
-                    ".ccm",
-                    m_Contents))
-            .ReturnsAsync(testModules);
+                    CloudCodeConstants.ServiceType))
+            .ReturnsAsync(testModules.OfType<IScript>().ToList());
 
-        m_DeploymentHandlerWithOutput.Setup(
+        m_DeploymentHandler.Setup(
                 ex => ex.DeployAsync(It.IsAny<IEnumerable<IScript>>(), true, false))
             .Returns(
                 Task.FromResult(
@@ -190,7 +208,7 @@ public void DeployAsync_DoesNotThrowOnApiException()
             CloudProjectId = TestValues.ValidProjectId
         };
 
-        m_DeploymentHandlerWithOutput.Setup(
+        m_DeploymentHandler.Setup(
                 ex => ex.DeployAsync(It.IsAny<IEnumerable<IScript>>(), false, false))
             .ThrowsAsync(new ApiException());
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeScriptDeploymentServiceTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeScriptDeploymentServiceTests.cs
index 1638098..7c0b9bf 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeScriptDeploymentServiceTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeScriptDeploymentServiceTests.cs
@@ -5,16 +5,17 @@
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
+using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.CloudCode.Deploy;
 using Unity.Services.Cli.CloudCode.Exceptions;
 using Unity.Services.Cli.CloudCode.Input;
 using Unity.Services.Cli.CloudCode.Service;
 using Unity.Services.Cli.CloudCode.UnitTest.Utils;
-using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.CloudCode.Authoring;
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Deployment;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Client;
 using AuthoringLanguage = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
 
@@ -34,20 +35,32 @@ public class CloudCodeDeploymentServiceTests
     readonly Mock<IJavaScriptClient> m_MockCloudCodeClient = new();
     readonly Mock<ICliEnvironmentProvider> m_MockEnvironmentProvider = new();
     readonly Mock<ICloudCodeInputParser> m_MockCloudCodeInputParser = new();
-    readonly Mock<IDeploymentHandlerWithOutput> m_DeploymentHandlerWithOutput = new();
+    readonly Mock<ICloudCodeDeploymentHandler> m_DeploymentHandler = new();
     readonly Mock<ICloudCodeScriptsLoader> m_MockCloudCodeScriptsLoader = new();
     readonly Mock<ICloudCodeScriptParser> m_MockCloudCodeScriptParser = new();
     readonly Mock<ILogger> m_MockLogger = new();
 
-    static readonly IReadOnlyCollection<DeployContent> k_DeployedContents = new[]
+    static readonly IReadOnlyList<CloudCodeScript> k_DeployedContents = new[]
     {
-        new DeployContent("script.js", "Cloud Code", "path", 100, "Published"),
+        new CloudCodeScript(
+            "script.js",
+            "path",
+            100,
+            new DeploymentStatus(Statuses.Deployed))
     };
 
-    static readonly IReadOnlyCollection<DeployContent> k_FailedContents = new[]
+    static readonly IReadOnlyList<CloudCodeScript> k_FailedContents = new[]
     {
-        new DeployContent("invalid1.js", "Cloud Code", "path", 0, "Failed to Load"),
-        new DeployContent("invalid2.js", "Cloud Code", "path", 0, "Failed to Load"),
+        new CloudCodeScript(
+            "invalid1.js",
+            "path",
+            0,
+            new DeploymentStatus(Statuses.FailedToRead)),
+        new CloudCodeScript(
+            "invalid2.js",
+            "path",
+            0,
+            new DeploymentStatus(Statuses.FailedToRead))
     };
 
     readonly List<ScriptInfo> m_RemoteContents = new()
@@ -55,7 +68,7 @@ public class CloudCodeDeploymentServiceTests
         new ScriptInfo("ToDelete", ".js")
     };
 
-    readonly List<DeployContent> m_Contents = k_DeployedContents.Concat(k_FailedContents).ToList();
+    readonly List<CloudCodeScript> m_Contents = k_DeployedContents.Concat(k_FailedContents).ToList();
 
     CloudCodeScriptDeploymentService? m_DeploymentService;
 
@@ -65,7 +78,7 @@ public void SetUp()
         m_MockCloudCodeClient.Reset();
         m_MockEnvironmentProvider.Reset();
         m_MockCloudCodeInputParser.Reset();
-        m_DeploymentHandlerWithOutput.Reset();
+        m_DeploymentHandler.Reset();
         m_MockLogger.Reset();
         m_MockCloudCodeScriptsLoader.Reset();
         m_MockCloudCodeScriptParser.Reset();
@@ -76,8 +89,19 @@ public void SetUp()
                 .ReturnsAsync(TestValues.ValidCode);
         }
 
-        m_DeploymentHandlerWithOutput.SetupGet(c => c.Contents)
-            .Returns(m_Contents);
+        m_DeploymentHandler.Setup(
+                c => c.DeployAsync(
+                    It.IsAny<IEnumerable<IScript>>(),
+                    It.IsAny<bool>(),
+                    It.IsAny<bool>()))
+            .Returns(
+                Task.FromResult(
+                    new DeployResult(
+                        new List<IScript>(),
+                        new List<IScript>(),
+                        new List<IScript>(),
+                        k_DeployedContents,
+                        new List<IScript>())));
 
         m_MockCloudCodeInputParser.Setup(p => p.LoadScriptCodeAsync(k_InvalidScriptFile, CancellationToken.None))
             .Throws(new ScriptEvaluationException(""));
@@ -85,20 +109,20 @@ public void SetUp()
         m_DeploymentService = new CloudCodeScriptDeploymentService(
             m_MockCloudCodeInputParser.Object,
             m_MockCloudCodeScriptParser.Object,
-            m_DeploymentHandlerWithOutput.Object,
+            m_DeploymentHandler.Object,
             m_MockCloudCodeScriptsLoader.Object,
             m_MockEnvironmentProvider.Object,
             m_MockCloudCodeClient.Object);
 
         m_MockCloudCodeScriptsLoader.Setup(
-            c => c.LoadScriptsAsync(
-                k_ValidFilePaths,
-                "Cloud Code",
-                ".js",
-                m_MockCloudCodeInputParser.Object,
-                m_MockCloudCodeScriptParser.Object,
-                m_Contents,
-                CancellationToken.None)).ReturnsAsync(new CloudCodeScriptLoadResult(new List<IScript>(), new List<DeployContent>()));
+                c => c.LoadScriptsAsync(
+                    k_ValidFilePaths,
+                    It.IsAny<string>(),
+                    ".js",
+                    m_MockCloudCodeInputParser.Object,
+                    m_MockCloudCodeScriptParser.Object,
+                    CancellationToken.None))
+            .ReturnsAsync(new CloudCodeScriptLoadResult(k_DeployedContents, k_FailedContents));
     }
 
     [Test]
@@ -124,7 +148,7 @@ public async Task DeployAsync_CallsLoadFilePathsFromInputCorrectly()
                 CancellationToken.None),
             Times.Once);
         m_MockEnvironmentProvider.VerifySet(x => { x.Current = TestValues.ValidEnvironmentId; }, Times.Once);
-        m_DeploymentHandlerWithOutput.Verify(x => x.DeployAsync(It.IsAny<List<IScript>>(), false, false), Times.Once);
+        m_DeploymentHandler.Verify(x => x.DeployAsync(It.IsAny<IEnumerable<IScript>>(), false, false), Times.Once);
         Assert.AreEqual(k_DeployedContents, result.Deployed);
         Assert.AreEqual(k_FailedContents, result.Failed);
     }
@@ -138,7 +162,7 @@ public async Task DeployReconcileAsync_WillCreateDeleteContent()
             CloudProjectId = TestValues.ValidProjectId,
         };
 
-        m_DeploymentHandlerWithOutput.Setup(
+        m_DeploymentHandler.Setup(
                 ex => ex.DeployAsync(It.IsAny<IEnumerable<IScript>>(), true, false))
             .Returns(
                 Task.FromResult(
@@ -170,7 +194,7 @@ public void DeployAsync_DoesNotThrowOnApiException()
             CloudProjectId = TestValues.ValidProjectId
         };
 
-        m_DeploymentHandlerWithOutput.Setup(
+        m_DeploymentHandler.Setup(
                 ex => ex.DeployAsync(It.IsAny<IEnumerable<IScript>>(), false, false))
             .ThrowsAsync(new ApiException());
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeScriptsLoaderTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeScriptsLoaderTests.cs
index df2713c..fe7dece 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeScriptsLoaderTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CloudCodeScriptsLoaderTests.cs
@@ -6,8 +6,10 @@
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.CloudCode.Deploy;
 using Unity.Services.Cli.CloudCode.Exceptions;
+using Unity.Services.Cli.CloudCode.Model;
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.Cli.CloudCode.Utils;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
 
 namespace Unity.Services.Cli.CloudCode.UnitTest.Deploy;
@@ -44,9 +46,9 @@ public async Task LoadScriptAsyncReturnScriptList()
         m_MockCloudCodeInputParser.Setup(c => c.LoadScriptCodeAsync("script1.js", CancellationToken.None))
             .ReturnsAsync(scriptCode);
         m_MockCloudCodeScriptParser.Setup(c => c.ParseScriptParametersAsync(scriptCode, CancellationToken.None))
-            .ReturnsAsync(expectedParameters);
-        var loadResult = await m_CodeScriptsLoader.LoadScriptsAsync(paths, "Cloud Code", ".js",
-            m_MockCloudCodeInputParser.Object, m_MockCloudCodeScriptParser.Object, contents, CancellationToken.None);
+            .ReturnsAsync(new ParseScriptParametersResult(false, expectedParameters));
+        var loadResult = await m_CodeScriptsLoader.LoadScriptsAsync(paths, CloudCodeConstants.ServiceType, ".js",
+            m_MockCloudCodeInputParser.Object, m_MockCloudCodeScriptParser.Object, CancellationToken.None);
         Assert.That(loadResult.LoadedScripts.Count, Is.EqualTo(1));
         Assert.That(loadResult.LoadedScripts[0].Parameters.Count, Is.EqualTo(expectedParameters.Count));
         Assert.That(loadResult.LoadedScripts[0].Parameters[0].Name, Is.EqualTo(expectedParameters[0].Name));
@@ -68,8 +70,8 @@ public void LoadScriptAsyncCatchScriptEvaluationException()
         m_MockCloudCodeInputParser.Setup(c => c.LoadScriptCodeAsync("script1.js", CancellationToken.None))
             .ThrowsAsync(new ScriptEvaluationException("Fail to parse script"));
         Assert.DoesNotThrowAsync(async () =>
-            await m_CodeScriptsLoader.LoadScriptsAsync(paths, "Cloud Code", ".js",
-                m_MockCloudCodeInputParser.Object, m_MockCloudCodeScriptParser.Object, contents,
+            await m_CodeScriptsLoader.LoadScriptsAsync(paths, CloudCodeConstants.ServiceType, ".js",
+                m_MockCloudCodeInputParser.Object, m_MockCloudCodeScriptParser.Object,
                 CancellationToken.None));
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CustomCloudCodeDeploymentHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CustomCloudCodeDeploymentHandlerTests.cs
index 93430fc..d534aa6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CustomCloudCodeDeploymentHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Deploy/CustomCloudCodeDeploymentHandlerTests.cs
@@ -1,10 +1,12 @@
 using Moq;
 using NUnit.Framework;
 using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.CloudCode.Deploy;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Analytics;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Deployment;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Logging;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.DeploymentApi.Editor;
 using Assert = NUnit.Framework.Assert;
 
 namespace Unity.Services.Cli.CloudCode.UnitTest.Deploy;
@@ -17,9 +19,8 @@ class CustomCloudCodeDeploymentHandlerTests
     static readonly Mock<IScriptCache> k_ScriptCache = new();
     static readonly Mock<ILogger> k_Logger = new();
     static readonly Mock<IPreDeployValidator> k_PreDeployValidator = new();
-    static readonly Mock<IScript> k_MockScript = new();
 
-    readonly DeployContent m_ExpectedContent = new("name2", "Cloud Code", "test-path-2", 0, "Reading");
+    readonly CloudCodeScript m_ExpectedContent = new("name2", "test-path-2", 0, new DeploymentStatus(Statuses.Loading));
 
     readonly ExposeCliCloudCodeDeploymentHandler m_CliCloudCodeDeploymentHandler = new(
         k_MockICloudCodeClient.Object,
@@ -28,23 +29,11 @@ class CustomCloudCodeDeploymentHandlerTests
         k_Logger.Object,
         k_PreDeployValidator.Object);
 
-    [SetUp]
-    public void SetUp()
-    {
-        m_CliCloudCodeDeploymentHandler.Contents.Clear();
-        k_MockScript.Reset();
-
-        m_CliCloudCodeDeploymentHandler.Contents.Add(new DeployContent("name1", "Cloud Code", "test-path-1", 0, "Reading"));
-        m_CliCloudCodeDeploymentHandler.Contents.Add(m_ExpectedContent);
-
-        k_MockScript.SetupGet(s => s.Path).Returns(m_ExpectedContent.Path);
-    }
-
     [Test]
     public void UpdateScriptProgressContentProgressUpdated()
     {
         const float expectedProgress = 100;
-        m_CliCloudCodeDeploymentHandler.ExposeUpdateScriptProgress(k_MockScript.Object, expectedProgress);
+        m_CliCloudCodeDeploymentHandler.ExposeUpdateScriptProgress(m_ExpectedContent, expectedProgress);
         Assert.AreEqual(expectedProgress, m_ExpectedContent.Progress);
     }
 
@@ -53,8 +42,8 @@ public void UpdateScriptStatusContentStatusUpdated()
     {
         const string expectedStatus = "Failed to Read";
         const string expectedDetail = "Reason for failed to read";
-        m_CliCloudCodeDeploymentHandler.ExposeUpdateScriptStatus(k_MockScript.Object, expectedStatus, expectedDetail);
-        Assert.AreEqual(expectedStatus, m_ExpectedContent.Status);
+        m_CliCloudCodeDeploymentHandler.ExposeUpdateScriptStatus(m_ExpectedContent, expectedStatus, expectedDetail);
+        Assert.AreEqual(expectedStatus, m_ExpectedContent.Status.Message);
         Assert.AreEqual(expectedDetail, m_ExpectedContent.Detail);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/CreateHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/CreateHandlerTests.cs
index 69eadc4..e8d5daa 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/CreateHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/CreateHandlerTests.cs
@@ -8,6 +8,7 @@
 using Spectre.Console;
 using Unity.Services.Cli.CloudCode.Handlers;
 using Unity.Services.Cli.CloudCode.Input;
+using Unity.Services.Cli.CloudCode.Model;
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.Cli.CloudCode.Service;
 using Unity.Services.Cli.CloudCode.UnitTest.Utils;
@@ -74,7 +75,7 @@ public async Task CreateAsync_CallsCreateAsyncWhenInputIsValid()
         m_MockInputParseService.SetupGet(x => x.CloudCodeScriptParser)
             .Returns(m_MockCloudCodeScriptParser.Object);
         m_MockCloudCodeScriptParser.Setup(x => x.ParseScriptParametersAsync(TestValues.ValidCode, CancellationToken.None))
-            .ReturnsAsync(k_Parameters);
+            .ReturnsAsync(new ParseScriptParametersResult(false, k_Parameters));
         await CreateHandler.CreateAsync(
             input,
             m_MockUnityEnvironment.Object,
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ExportModulesHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ExportModulesHandlerTests.cs
new file mode 100644
index 0000000..b0c2596
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ExportModulesHandlerTests.cs
@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Abstractions;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Spectre.Console;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.CloudCode.Deploy;
+using Unity.Services.Cli.CloudCode.Handlers.ImportExport.Modules;
+using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.Cli.CloudCode.UnitTest.Utils;
+using Unity.Services.Cli.CloudCode.Utils;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
+using AuthoringLanguage = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
+using Language = Unity.Services.Gateway.CloudCodeApiV1.Generated.Model.Language;
+using Module = Unity.Services.Cli.CloudCode.Deploy.CloudCodeModule;
+
+namespace Unity.Services.Cli.CloudCode.UnitTest.Handlers;
+
+[TestFixture]
+class ExportModulesHandlerTests
+{
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<IFileSystem> m_MockFileSystem = new();
+    readonly Mock<ICloudCodeService> m_MockCloudCodeService = new();
+    readonly Mock<ICloudCodeModulesDownloader> m_MockCloudCodeModulesDownloader = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IZipArchiver> m_MockArchiver = new();
+    readonly Mock<ILoadingIndicator> m_MockLoadingIndicator = new();
+    readonly static DateTime DateNow = DateTime.Now;
+    readonly IEnumerable<ListModulesResponseResultsInner> m_ModulesListResponse = new List<ListModulesResponseResultsInner>()
+    {
+       new("test1",  Language.JS, new Dictionary<string, string>(), "url", DateNow),
+       new("test2", Language.JS, new Dictionary<string, string>(), "url", DateNow),
+       new("test3",  Language.JS, new Dictionary<string, string>(),"url", DateNow),
+    };
+
+    readonly IEnumerable<Module> m_Modules = new List<Module>()
+    {
+        new(new ScriptName("test1"), AuthoringLanguage.JS, "test1","{}", new List<CloudCodeParameter>(), DateNow.ToString()),
+        new(new ScriptName("test2"), AuthoringLanguage.JS, "test2","{}", new List<CloudCodeParameter>(), DateNow.ToString()),
+        new(new ScriptName("test3"), AuthoringLanguage.JS, "test3","{}", new List<CloudCodeParameter>(), DateNow.ToString()),
+    };
+
+    CloudCodeModulesExporter? m_CloudCodeModulesExporter;
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_MockUnityEnvironment.Reset();
+        m_MockCloudCodeService.Reset();
+        m_MockLogger.Reset();
+        m_MockCloudCodeModulesDownloader.Reset();
+        m_CloudCodeModulesExporter = new(m_MockCloudCodeService.Object,
+            m_MockCloudCodeModulesDownloader.Object,
+            m_MockArchiver.Object,
+            m_MockUnityEnvironment.Object,
+            m_MockFileSystem.Object,
+            m_MockLogger.Object);
+    }
+
+    [Test]
+    public async Task ExportAsync_CallsLoadingIndicator()
+    {
+        var exportInput = new ExportInput()
+        {
+            OutputDirectory = "mock_output_directory"
+        };
+
+        await ModuleExportHandler.ExportAsync
+        (
+            exportInput,
+            m_CloudCodeModulesExporter,
+            m_MockLoadingIndicator.Object,
+            CancellationToken.None
+        );
+
+        m_MockLoadingIndicator.Verify(li => li.StartLoadingAsync(ModuleExportHandler.k_LoadingIndicatorMessage,
+            It.IsAny<Func<StatusContext?, Task>>()));
+    }
+
+    [Test]
+    [Ignore("This is not a unit test and must be moved")]
+    public async Task ExportAsync_ExportsAndZips()
+    {
+        var exportInput = new ExportInput()
+        {
+            FileName = CloudCodeConstants.ModulesZipName,
+            OutputDirectory = "test_output_directory"
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        m_MockCloudCodeService.Setup(
+                cs => cs.ListModulesAsync(It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(m_ModulesListResponse));
+
+        m_MockCloudCodeModulesDownloader.Setup(
+            cs => cs.DownloadModule(
+                It.Is<Module>(m => m.Name.ToString() == "Module"),
+                It.IsAny<CancellationToken>()))
+             .ReturnsAsync(File.OpenRead("ModuleTestCases\\Module.ccm"));
+
+        m_MockFileSystem.Setup(s => s.Directory.CreateDirectory(exportInput.OutputDirectory));
+        m_MockFileSystem.Setup(s => s.Path.Join(exportInput.OutputDirectory, exportInput.FileName))
+            .Returns("test_output_directory\\ugs.ccmzip");
+        m_MockFileSystem.Setup(s => s.File.Exists("test_output_directory\\ugs.ccmzip"));
+
+        await m_CloudCodeModulesExporter!.ExportAsync(exportInput, CancellationToken.None);
+        m_MockCloudCodeService.Verify(
+            cs => cs.ListModulesAsync(It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+
+        var archivePath = Path.Join(exportInput.OutputDirectory, exportInput.FileName);
+        m_MockArchiver.Verify(za => za.ZipAsync(
+            archivePath,
+            CloudCodeConstants.ModulesEntryName,
+            It.Is<IEnumerable<Module>>(m => m.Count() == m_Modules.Count()),
+            It.IsAny<CancellationToken>()));
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ExportScriptsHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ExportScriptsHandlerTests.cs
new file mode 100644
index 0000000..4b549b3
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ExportScriptsHandlerTests.cs
@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Abstractions;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Spectre.Console;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Authoring.Service;
+using Unity.Services.Cli.CloudCode.Deploy;
+using Unity.Services.Cli.CloudCode.Handlers.ImportExport.Scripts;
+using Unity.Services.Cli.CloudCode.Model;
+using Unity.Services.Cli.CloudCode.Parameters;
+using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.Cli.CloudCode.UnitTest.Utils;
+using Unity.Services.Cli.CloudCode.Utils;
+using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
+using Language = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
+
+
+namespace Unity.Services.Cli.CloudCode.UnitTest.Handlers;
+
+[TestFixture]
+class ExportScriptsHandlerTests
+{
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<ICloudCodeService> m_MockCloudCodeService = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IZipArchiver> m_MockArchiver = new();
+    readonly Mock<IFileSystem> m_MockFileSystem = new();
+    readonly Mock<ILoadingIndicator> m_MockLoadingIndicator = new();
+    readonly static DateTime DateNow = DateTime.Now;
+    readonly IEnumerable<ListScriptsResponseResultsInner> m_ScriptsListResponse = new List<ListScriptsResponseResultsInner>()
+    {
+       new("test1", ScriptType.API, Gateway.CloudCodeApiV1.Generated.Model.Language.JS, true, DateNow, 1),
+       new("test2", ScriptType.API, Gateway.CloudCodeApiV1.Generated.Model.Language.JS, true, DateNow, 1),
+       new("test3", ScriptType.API, Gateway.CloudCodeApiV1.Generated.Model.Language.JS, true, DateNow, 1),
+       new("test4", ScriptType.API, Gateway.CloudCodeApiV1.Generated.Model.Language.JS, true, DateNow, 1),
+    };
+    readonly IEnumerable<CloudCodeScript> m_Scripts = new List<CloudCodeScript>()
+    {
+        new(new ScriptName("test1"), Language.JS, "", "{}", new List<CloudCodeParameter>(), DateNow.ToString()),
+        new(new ScriptName("test2"), Language.JS, "","{}", new List<CloudCodeParameter>(), DateNow.ToString()),
+        new(new ScriptName("test3"), Language.JS, "","{}", new List<CloudCodeParameter>(), DateNow.ToString()),
+        new(new ScriptName("test4"), Language.JS, "","{}", new List<CloudCodeParameter>(), DateNow.ToString()),
+    };
+    CloudCodeScriptsExporter? m_CloudCodeScriptsExporter;
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_MockUnityEnvironment.Reset();
+        m_MockCloudCodeService.Reset();
+        m_MockLogger.Reset();
+        m_MockFileSystem.Reset();
+        m_CloudCodeScriptsExporter = new(m_MockCloudCodeService.Object,
+            m_MockArchiver.Object,
+            m_MockUnityEnvironment.Object,
+            m_MockFileSystem.Object,
+            m_MockLogger.Object);
+    }
+
+    [Test]
+    public async Task ExportAsync_CallsLoadingIndicator()
+    {
+        var exportInput = new ExportInput()
+        {
+            OutputDirectory = "mock_output_directory"
+        };
+
+        await ScriptExportHandler.ExportAsync
+        (
+            exportInput,
+            m_CloudCodeScriptsExporter,
+            m_MockLoadingIndicator.Object,
+            CancellationToken.None
+        );
+
+        m_MockLoadingIndicator.Verify(li => li.StartLoadingAsync(ScriptExportHandler.k_LoadingIndicatorMessage,
+            It.IsAny<Func<StatusContext?, Task>>()));
+    }
+
+    [Test]
+    public async Task ExportAsync_ExportsAndZips()
+    {
+        var exportInput = new ExportInput()
+        {
+            OutputDirectory = "mock_output_directory"
+        };
+
+        var archivePath = Path.Join(exportInput.OutputDirectory, CloudCodeConstants.JavascriptZipName);
+
+        m_MockFileSystem
+            .Setup(x =>
+                x.Directory.CreateDirectory(It.IsAny<string>()));
+
+        m_MockFileSystem
+            .Setup(x =>
+                x.Path.Join(It.IsAny<string>(), It.IsAny<string>()))
+            .Returns(archivePath);
+
+        m_MockFileSystem
+            .Setup(x =>
+                x.File.Exists(It.IsAny<string>()))
+            .Returns(false);
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        m_MockCloudCodeService.Setup(
+                cs => cs.ListAsync(It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(m_ScriptsListResponse));
+
+
+        foreach (var script in m_Scripts)
+        {
+            m_MockCloudCodeService.Setup(
+                    cs => cs.GetAsync(It.IsAny<string>(), It.IsAny<string>(), script.Name.ToString(), It.IsAny<CancellationToken>()))
+                .Returns(Task.FromResult(
+                    new GetScriptResponse(script.Name.ToString(),
+                        ScriptType.API,
+                        Gateway.CloudCodeApiV1.Generated.Model.Language.JS,
+                        activeScript: new GetScriptResponseActiveScript(
+                            script.Body,
+                            1,
+                            DateNow,
+                            new List<ScriptParameter>()),
+                        new List<GetScriptResponseVersionsInner>(),
+                        new List<ScriptParameter>())));
+        }
+
+        m_MockFileSystem.Setup(s => s.Directory.CreateDirectory(exportInput.OutputDirectory));
+        m_MockFileSystem.Setup(s => s.Path.Join(exportInput.OutputDirectory, CloudCodeConstants.JavascriptZipName))
+            .Returns(archivePath);
+        m_MockFileSystem.Setup(s => s.File.Exists(archivePath));
+
+        var cancellation = CancellationToken.None;
+        await m_CloudCodeScriptsExporter!.ExportAsync(exportInput, cancellation);
+
+        m_MockCloudCodeService.Verify(
+            cs => cs.ListAsync(It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+
+        m_MockCloudCodeService.Verify(
+            cs => cs.GetAsync(It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            Times.Exactly(4));
+
+        m_MockArchiver.Verify(za => za.ZipAsync(
+            It.Is<string>(s => s == archivePath),
+            It.Is<string>(s => s == CloudCodeConstants.ScriptsEntryName),
+            It.Is<IEnumerable<CloudCodeScript>>(s => AssertAreEqual(s.ToList(), m_Scripts.ToList())),
+            It.IsAny<CancellationToken>()));
+    }
+
+    static bool AssertAreEqual(IList<CloudCodeScript> list1, IList<CloudCodeScript> list2)
+    {
+        Assert.AreEqual(list1.Count(), list2.Count());
+        for (var i = 0; i < list1.Count(); i++)
+        {
+            Assert.AreEqual(list2[i].Name, list1[i].Name);
+            Assert.AreEqual(list2[i].Body, list1[i].Body);
+        }
+
+        return true;
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/GetModuleHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/GetModuleHandlerTests.cs
index d05b7a9..5befd86 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/GetModuleHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/GetModuleHandlerTests.cs
@@ -40,6 +40,7 @@ public void SetUp()
                     "foo",
                     Language.CS,
                     null,
+                    "url",
                     dateTime,
                     dateTime));
     }
@@ -87,6 +88,7 @@ await GetModuleHandler.GetModuleAsync(
             cloudCodeInput.ModuleName,
             Language.CS,
             null,
+            "url",
             dateTime,
             dateTime));
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ImportModulesHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ImportModulesHandlerTests.cs
new file mode 100644
index 0000000..f231896
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ImportModulesHandlerTests.cs
@@ -0,0 +1,552 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Spectre.Console;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.CloudCode.Deploy;
+using Unity.Services.Cli.CloudCode.Handlers.ImportExport.Modules;
+using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.Cli.CloudCode.UnitTest.Utils;
+using Unity.Services.Cli.CloudCode.Utils;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Client;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
+using AuthoringLanguage = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
+using Language = Unity.Services.Gateway.CloudCodeApiV1.Generated.Model.Language;
+using Module = Unity.Services.Cli.CloudCode.Deploy.CloudCodeModule;
+
+namespace Unity.Services.Cli.CloudCode.UnitTest.Handlers;
+
+enum ModuleApiCallType
+{
+    CreateOrUpdate,
+    Delete,
+    Get,
+    List
+}
+
+[TestFixture]
+class ImportModuleHandlerTests
+{
+    const string k_ImportTestFileDirectory
+        = "ModuleTestCases";
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<ICloudCodeService> m_MockCloudCodeService = new();
+    readonly Mock<ICloudCodeModulesDownloader> m_MockCloudCodeModulesDownloader = new();
+    readonly Mock<ICloudCodeInputParser> m_MockCloudCodeInputParser = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IZipArchiver> m_MockArchiver = new();
+    readonly Mock<ILoadingIndicator> m_MockLoadingIndicator = new();
+
+    readonly static DateTime DateNow = DateTime.Now;
+
+    readonly IEnumerable<ListModulesResponseResultsInner> m_ModulesListSingleModuleResponse =
+        new List<ListModulesResponseResultsInner>()
+        {
+            new("test1", Language.JS, new Dictionary<string, string>(), "url", DateNow, DateNow),
+        };
+
+
+    readonly Module m_MockNonDuplicateModule = new(new ScriptName("test"), AuthoringLanguage.JS, "test_3.ccm", "{}",
+        new List<CloudCodeParameter>(), DateNow.ToString());
+
+    // This mock script updates the existing script in m_MockModules if used within tests
+    readonly Module m_MockModule = new(new ScriptName("test1"), AuthoringLanguage.JS, "test_3.ccm", "{}",
+        new List<CloudCodeParameter>(), DateNow.ToString());
+
+    readonly List<Module> m_MockModules = new()
+    {
+        new(new ScriptName("test1"), AuthoringLanguage.JS, "path", "{}", new List<CloudCodeParameter>(),
+            DateNow.ToString()),
+        new(new ScriptName("test2"), AuthoringLanguage.JS, "path", "{}", new List<CloudCodeParameter>(),
+            DateNow.ToString()),
+        new(new ScriptName("test3"), AuthoringLanguage.JS, "path", "{}", new List<CloudCodeParameter>(),
+            DateNow.ToString()),
+        new(new ScriptName("test4"), AuthoringLanguage.JS, "path", "{}", new List<CloudCodeParameter>(),
+            DateNow.ToString()),
+    };
+
+    CloudCodeModulesImporter? m_CloudCodeModulesImporter;
+
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_MockUnityEnvironment.Reset();
+        m_MockCloudCodeService.Reset();
+        m_MockCloudCodeInputParser.Reset();
+        m_MockLogger.Reset();
+        m_MockCloudCodeModulesDownloader.Reset();
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<Module>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .ReturnsAsync(m_MockModules);
+
+        m_CloudCodeModulesImporter = new CloudCodeModulesImporter(
+            m_MockCloudCodeService.Object,
+            m_MockArchiver.Object,
+            m_MockUnityEnvironment.Object,
+            m_MockLogger.Object);
+
+        var mockStream = new MemoryStream(new byte[] { 0x42 });
+        m_MockArchiver.Setup(
+                za => za.GetEntry(
+                    It.IsAny<string>(),
+                    It.IsAny<string>()))
+            .Returns( new ZipEntryStream(mockStream) );
+    }
+
+    [Test]
+    public async Task ImportAsync_CallsLoadingIndicator()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory"
+        };
+
+        await ModulesImportHandler.ImportAsync(
+            importInput,
+            m_CloudCodeModulesImporter,
+            m_MockLoadingIndicator.Object,
+            CancellationToken.None
+        );
+
+        m_MockLoadingIndicator.Verify(li => li.StartLoadingAsync(ModulesImportHandler.k_LoadingIndicatorMessage,
+            It.IsAny<Func<StatusContext?, Task>>()));
+    }
+
+    [Test]
+    public async Task ImportAsync_Unzips()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            DryRun = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        await ImportInternalAsync(importInput);
+
+        var archivePath = Path.Join(importInput.InputDirectory, CloudCodeConstants.ModulesZipName);
+
+        m_MockArchiver.Verify(za => za.UnzipAsync<Module>(
+            archivePath,
+            CloudCodeConstants.ModulesEntryName,
+            It.IsAny<CancellationToken>()));
+    }
+
+    [Test]
+    public async Task ImportAsync_DryRunDoesNotImport()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            DryRun = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ModuleApiCallType>
+        {
+            ModuleApiCallType.List
+        });
+    }
+
+    [Test]
+    public void ThrowsWhenModulePathIsEmpty()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        SetupList(m_ModulesListSingleModuleResponse, new List<Module>(){m_MockModule});
+        SetupCreateOrUpdate();
+
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<Module>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<Module>()
+            {
+                new(new ScriptName("test1"), AuthoringLanguage.JS, "", "{}",
+                    new List<CloudCodeParameter>(), DateNow.ToString())
+            });
+
+
+        Assert.ThrowsAsync<AggregateException>(async () => await ImportInternalAsync(importInput));
+
+        VerifyApiCalls(new List<ModuleApiCallType>()
+        {
+            ModuleApiCallType.List,
+        });
+    }
+
+    [Test]
+    public async Task ModuleExists_Updates()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "ModuleTestCases",
+            FileName = "test.ccmzip"
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        SetupList(m_ModulesListSingleModuleResponse, new List<Module>(){m_MockModule});
+        SetupCreateOrUpdate();
+
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<Module>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<Module>()
+            {
+                m_MockModule
+            });
+
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ModuleApiCallType>()
+        {
+            ModuleApiCallType.List,
+            ModuleApiCallType.CreateOrUpdate
+        });
+    }
+
+    [Test]
+    public void ModuleUpdate_Fails()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "ModuleTestCases",
+            FileName = "test.ccmzip"
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        SetupList(m_ModulesListSingleModuleResponse, new List<Module>(){m_MockModule});
+        SetupCreateOrUpdate(true);
+
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<Module>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<Module>()
+            {
+                m_MockModule
+            });
+
+        Assert.ThrowsAsync<AggregateException>(async () => await ImportInternalAsync(importInput));
+
+        VerifyApiCalls(new List<ModuleApiCallType>()
+        {
+            ModuleApiCallType.List,
+            ModuleApiCallType.CreateOrUpdate
+        });
+    }
+
+    [Test]
+    public async Task ConfigDoesNotExist_Creates()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "ModuleTestCases",
+            FileName = "test.ccmzip",
+        };
+
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<Module>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<Module>()
+            {
+                m_MockModule
+            });
+
+        var mockStream = new MemoryStream(new byte[] { 0x42 });
+
+        m_MockArchiver.Setup(
+                za => za.GetEntry(
+                    It.IsAny<string>(),
+                    It.IsAny<string>()))
+            .Returns( new ZipEntryStream(mockStream) );
+
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        SetupGet(null!, true);
+        SetupList(new List<ListModulesResponseResultsInner>(), new List<Module>());
+        SetupCreateOrUpdate();
+
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ModuleApiCallType>()
+        {
+            ModuleApiCallType.CreateOrUpdate,
+            ModuleApiCallType.List
+        });
+    }
+
+    [Test]
+    public void ConfigDoesNotExist_CreateFails()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = k_ImportTestFileDirectory,
+            FileName = "test.ccmzip"
+        };
+
+        var dir = Directory.GetCurrentDirectory();
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<Module>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<Module>()
+            {
+                m_MockModule
+            });
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        SetupGet(null!, true);
+        SetupList(new List<ListModulesResponseResultsInner>(), new List<Module>());
+        SetupCreateOrUpdate(true);
+
+        Assert.ThrowsAsync<AggregateException>(async () => await ImportInternalAsync(importInput));
+
+        VerifyApiCalls(new List<ModuleApiCallType>()
+        {
+            ModuleApiCallType.CreateOrUpdate,
+            ModuleApiCallType.List
+        });
+    }
+
+    [Test]
+    public async Task Reconcile_Deletes()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "ModuleTestCases",
+            FileName = "test.ccmzip",
+            Reconcile = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<Module>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<Module>()
+            {
+                m_MockNonDuplicateModule
+            });
+
+        SetupList(new List<ListModulesResponseResultsInner>()
+        {
+            new(m_MockNonDuplicateModule.Name.ToString(), Language.JS, new Dictionary<string, string>(), "url", DateNow, DateNow)
+        }, new List<Module>(){m_MockNonDuplicateModule});
+
+        SetupDelete();
+
+        SetupList(m_ModulesListSingleModuleResponse, new List<Module>(){m_MockModule});
+
+        SetupCreateOrUpdate();
+
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ModuleApiCallType>()
+        {
+            ModuleApiCallType.List,
+            ModuleApiCallType.Delete,
+            ModuleApiCallType.CreateOrUpdate
+        });
+    }
+
+    [Test]
+    public void Reconcile_Delete_Throws()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            Reconcile = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<Module>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<Module>()
+            {
+                m_MockNonDuplicateModule
+            });
+
+        SetupList(new List<ListModulesResponseResultsInner>()
+        {
+            new(m_MockNonDuplicateModule.Name.ToString(), Language.JS, new Dictionary<string, string>(), "url", DateNow, DateNow)
+        }, new List<Module>(){m_MockNonDuplicateModule});
+
+        SetupDelete(true);
+
+        SetupList(m_ModulesListSingleModuleResponse, new List<Module>(){m_MockModule});
+
+        SetupCreateOrUpdate();
+
+        Assert.ThrowsAsync<AggregateException>(async () => await ImportInternalAsync(importInput));
+
+        VerifyApiCalls(new List<ModuleApiCallType>()
+        {
+            ModuleApiCallType.List,
+            ModuleApiCallType.Delete,
+            ModuleApiCallType.CreateOrUpdate
+        });
+    }
+
+    async Task ImportInternalAsync(ImportInput importInput)
+    {
+        await m_CloudCodeModulesImporter!.ImportAsync(importInput, CancellationToken.None);
+    }
+
+    void SetupCreateOrUpdate(bool throws = false)
+    {
+        var setup = m_MockCloudCodeService.Setup(
+            cs => cs.UpdateModuleAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<Stream>(),
+                It.IsAny<CancellationToken>()));
+        if (throws)
+        {
+            setup.Throws(new Exception("mock exception"));
+            return;
+        }
+
+        setup.Returns(Task.FromResult(new ApiResponse<object>(HttpStatusCode.NoContent, new object())));
+    }
+
+    void SetupGet(Module module, bool throws = false)
+    {
+        var setup = m_MockCloudCodeService.Setup(cs => cs.GetModuleAsync(
+            It.IsAny<string>(),
+            It.IsAny<string>(),
+            It.IsAny<string>(),
+            It.IsAny<CancellationToken>()));
+
+        if (throws)
+        {
+            setup.Throws(new Exception("mock exception"));
+            return;
+        }
+
+        var getModuleResponse = new GetModuleResponse(module.Name.ToString(),
+            Language.JS);
+
+        setup.ReturnsAsync(getModuleResponse);
+    }
+
+    void SetupList(IEnumerable<ListModulesResponseResultsInner> result, List<Module> modules)
+    {
+        m_MockCloudCodeService.Setup(
+                cs => cs.ListModulesAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(result));
+
+        /* todo
+        m_MockCloudCodeModulesDownloader.Setup(
+                cs => cs.DownloadModulesForEnvironment(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    result.ToList(),
+                    It.IsAny<CancellationToken>()))
+            .ReturnsAsync(modules);*/
+    }
+
+    void SetupDelete(bool throws = false)
+    {
+        var setup = m_MockCloudCodeService.Setup(
+            cs => cs.DeleteModuleAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()));
+
+        if (throws)
+        {
+            setup.Throws(new Exception("mock exception"));
+            return;
+        }
+
+        setup.Returns(Task.FromResult(new ApiResponse<object>(HttpStatusCode.NoContent, new object())));
+    }
+
+    void VerifyApiCalls(List<ModuleApiCallType> apiCallTypes)
+    {
+        var getTimes = apiCallTypes.Contains(ModuleApiCallType.Get) ? Times.Once() : Times.Never();
+        m_MockCloudCodeService.Verify(
+            cs => cs.GetModuleAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            getTimes);
+
+        var listTimes = apiCallTypes.Contains(ModuleApiCallType.List) ? Times.Once() : Times.Never();
+        m_MockCloudCodeService.Verify(
+            cs => cs.ListModulesAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            listTimes);
+
+        var createOrUpdateTimes = apiCallTypes.Contains(ModuleApiCallType.CreateOrUpdate) ? Times.Once() : Times.Never();
+        m_MockCloudCodeService.Verify(
+            cs => cs.UpdateModuleAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<Stream>(),
+                It.IsAny<CancellationToken>()),
+            createOrUpdateTimes);
+
+        var deleteTimes = apiCallTypes.Contains(ModuleApiCallType.Delete) ? Times.Once() : Times.Never();
+        m_MockCloudCodeService.Verify(
+            cs => cs.DeleteModuleAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            deleteTimes);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ImportScriptsHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ImportScriptsHandlerTests.cs
new file mode 100644
index 0000000..5a4d6ba
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/ImportScriptsHandlerTests.cs
@@ -0,0 +1,479 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using Spectre.Console;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.CloudCode.Deploy;
+using Unity.Services.Cli.CloudCode.Handlers.ImportExport.Scripts;
+using Unity.Services.Cli.CloudCode.Model;
+using Unity.Services.Cli.CloudCode.Parameters;
+using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.Cli.CloudCode.UnitTest.Utils;
+using Unity.Services.Cli.CloudCode.Utils;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Client;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
+using Language = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
+
+namespace Unity.Services.Cli.CloudCode.UnitTest.Handlers;
+
+enum ApiCallType
+{
+    Create,
+    Update,
+    Delete,
+    Get,
+    List,
+    Publish
+}
+
+[TestFixture]
+class ImportScriptsHandlerTests
+{
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<ICloudCodeService> m_MockCloudCodeService = new();
+    readonly Mock<ICloudCodeScriptParser> m_MockCloudCodeScriptParser = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IZipArchiver> m_MockArchiver = new();
+    readonly Mock<ILoadingIndicator> m_MockLoadingIndicator = new();
+
+    readonly static DateTime DateNow = DateTime.Now;
+
+    readonly IEnumerable<ListScriptsResponseResultsInner> m_ScriptsListSingleScriptResponse =
+        new List<ListScriptsResponseResultsInner>()
+        {
+            new("test1", ScriptType.API, Gateway.CloudCodeApiV1.Generated.Model.Language.JS, true, DateNow, 1),
+
+        };
+
+
+    readonly CloudCodeScript m_MockNonDuplicateScript =  new (new ScriptName("test"), Language.JS, "", "{}", new List<CloudCodeParameter>(), DateNow.ToString());
+    // This mock script updates the existing script in m_MockScripts if used within tests
+    readonly CloudCodeScript m_MockScript =  new (new ScriptName("test1"), Language.JS, "", "{}", new List<CloudCodeParameter>(), DateNow.ToString());
+
+    readonly List<CloudCodeScript> m_MockScripts = new()
+    {
+        new(new ScriptName("test1"), Language.JS, "", "{}", new List<CloudCodeParameter>(), DateNow.ToString()),
+        new(new ScriptName("test2"), Language.JS, "","{}", new List<CloudCodeParameter>(), DateNow.ToString()),
+        new(new ScriptName("test3"), Language.JS, "","{}", new List<CloudCodeParameter>(), DateNow.ToString()),
+        new(new ScriptName("test4"), Language.JS, "","{}", new List<CloudCodeParameter>(), DateNow.ToString()),
+    };
+
+    CloudCodeScriptsImporter? m_CloudCodeScriptsImporter;
+
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_MockUnityEnvironment.Reset();
+        m_MockCloudCodeService.Reset();
+        m_MockLogger.Reset();
+        m_MockCloudCodeScriptParser.Reset();
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<CloudCodeScript>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult((IEnumerable<CloudCodeScript>)m_MockScripts));
+
+        m_CloudCodeScriptsImporter = new CloudCodeScriptsImporter(
+            m_MockCloudCodeService.Object,
+            m_MockArchiver.Object,
+            m_MockUnityEnvironment.Object,
+            m_MockLogger.Object);
+    }
+
+    [Test]
+    public async Task ImportAsync_CallsLoadingIndicator()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory"
+        };
+
+        await ImportHandler.ImportAsync(
+            importInput,
+            m_CloudCodeScriptsImporter,
+            m_MockLoadingIndicator.Object,
+            CancellationToken.None
+        );
+
+        m_MockLoadingIndicator.Verify(li => li.StartLoadingAsync(ImportHandler.k_LoadingIndicatorMessage,
+            It.IsAny<Func<StatusContext?, Task>>()));
+    }
+
+    [Test]
+    public async Task ImportAsync_Unzips()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            DryRun = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        await ImportInternalAsync(importInput);
+
+        var archivePath = Path.Join(importInput.InputDirectory, CloudCodeConstants.JavascriptZipName);
+
+        m_MockArchiver.Verify(za => za.UnzipAsync<CloudCodeScript>(
+            archivePath,
+            CloudCodeConstants.ScriptsEntryName, CancellationToken.None));
+    }
+
+    [Test]
+    public async Task ImportAsync_DryRunDoesNotImport()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            DryRun = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ApiCallType>
+        {
+            ApiCallType.List
+        });
+    }
+
+    [Test]
+    public async Task ScriptExists_Updates()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        SetupList(m_ScriptsListSingleScriptResponse);
+        SetupGet(new List<CloudCodeScript>(){m_MockScript});
+        SetupUpdate();
+
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<CloudCodeScript>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult<IEnumerable<CloudCodeScript>>(new List<CloudCodeScript>(){m_MockScript}));
+        m_MockCloudCodeScriptParser.Setup(p => p.ParseScriptParametersAsync(
+                It.Is<string>(s => s == m_MockNonDuplicateScript.Body),
+                It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(new ParseScriptParametersResult(m_MockNonDuplicateScript.Parameters.Any(),
+                new ScriptParameter[0])));
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ApiCallType>()
+        {
+            ApiCallType.List,
+            ApiCallType.Get,
+            ApiCallType.Update,
+            ApiCallType.Publish
+        });
+    }
+
+    [Test]
+    public async Task ConfigDoesNotExist_Creates()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+        };
+
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<CloudCodeScript>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult<IEnumerable<CloudCodeScript>>(new List<CloudCodeScript>(){m_MockScript}));
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        SetupGet(null!, true);
+        SetupCreate();
+        m_MockCloudCodeScriptParser.Setup(p =>
+            p.ParseScriptParametersAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(new ParseScriptParametersResult(m_MockScript.Parameters.Any(), new ScriptParameter[0])));
+
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ApiCallType>()
+        {
+            ApiCallType.Create,
+            ApiCallType.List,
+            ApiCallType.Publish
+        });
+    }
+
+    [Test]
+    public async Task Reconcile_Deletes()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            Reconcile = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<CloudCodeScript>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult<IEnumerable<CloudCodeScript>>(new List<CloudCodeScript>(){m_MockNonDuplicateScript}));
+        m_MockCloudCodeScriptParser.Setup(p => p.ParseScriptParametersAsync(
+                It.Is<string>(s => s == m_MockNonDuplicateScript.Body),
+                It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(new ParseScriptParametersResult(m_MockNonDuplicateScript.Parameters.Any(),
+                Array.Empty<ScriptParameter>())));
+
+
+        SetupList(new List<ListScriptsResponseResultsInner>(){new(m_MockNonDuplicateScript.Name.ToString(), ScriptType.API, Gateway.CloudCodeApiV1.Generated.Model.Language.JS, true, DateNow, 1),});
+        SetupGet(new List<CloudCodeScript>(){m_MockNonDuplicateScript});
+
+        SetupDelete();
+
+        SetupList(m_ScriptsListSingleScriptResponse);
+        SetupGet(new List<CloudCodeScript>(){m_MockScript});
+
+        SetupCreate();
+
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ApiCallType>()
+        {
+            ApiCallType.List,
+            ApiCallType.Get,
+            ApiCallType.Delete,
+            ApiCallType.Create,
+            ApiCallType.Publish
+        });
+    }
+
+    [Test]
+    public void SucceedsOnRepublish()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            Reconcile = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<CloudCodeScript>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult<IEnumerable<CloudCodeScript>>(new List<CloudCodeScript>(){m_MockNonDuplicateScript}));
+        m_MockCloudCodeScriptParser
+            .Setup(p => p.ParseScriptParametersAsync(
+                It.Is<string>(s => s == m_MockNonDuplicateScript.Body),
+                It.IsAny<CancellationToken>()))
+            .Returns(
+                Task.FromResult(new ParseScriptParametersResult(m_MockNonDuplicateScript.Parameters.Any(),
+                Array.Empty<ScriptParameter>())));
+        var error = JsonConvert.SerializeObject(
+            new {
+                code = CloudCodeScriptsImporter.ScriptAlreadyActive
+            });
+
+        var exception = new ApiException(
+            (int)HttpStatusCode.BadRequest,
+            string.Empty,
+            error);
+
+        m_MockCloudCodeService
+            .Setup(
+                c => c.PublishAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    0,
+                    It.IsAny<CancellationToken>()))
+            .Throws(exception);
+
+        SetupDelete();
+        SetupList(m_ScriptsListSingleScriptResponse);
+        SetupGet(new List<CloudCodeScript>(){m_MockScript});
+        SetupCreate();
+
+        Assert.DoesNotThrowAsync(async () => await ImportInternalAsync(importInput));
+    }
+
+    async Task ImportInternalAsync(ImportInput importInput)
+    {
+        await m_CloudCodeScriptsImporter!.ImportAsync(importInput, CancellationToken.None);
+    }
+
+    void SetupCreate(int creations = 1)
+    {
+
+        var setup = m_MockCloudCodeService.SetupSequence(
+            cs => cs.CreateAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                ScriptType.API,
+                Gateway.CloudCodeApiV1.Generated.Model.Language.JS,
+                It.IsAny<string>(),
+                It.IsAny<IReadOnlyList<ScriptParameter>>(),
+                It.IsAny<CancellationToken>()));
+
+        for (int i = 0; i < creations; i++)
+        {
+            setup.Returns(Task.FromResult(new ApiResponse<object>(HttpStatusCode.Created, new object())));
+        }
+    }
+
+    void SetupUpdate()
+    {
+        m_MockCloudCodeService.Setup(
+                cs => cs.UpdateAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<IReadOnlyList<ScriptParameter>>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(new ApiResponse<object>(HttpStatusCode.NoContent, new object())));
+    }
+
+    void SetupGet(List<CloudCodeScript> scripts, bool throws = false)
+    {
+        var setup = m_MockCloudCodeService.SetupSequence(cs => cs.GetAsync(
+            It.IsAny<string>(),
+            It.IsAny<string>(),
+            It.IsAny<string>(),
+            It.IsAny<CancellationToken>()));
+
+
+        if (throws)
+        {
+            setup.Throws(new Exception("mock exception"));
+            return;
+        }
+
+
+        foreach (var script in scripts)
+        {
+            var getScriptResponse = new GetScriptResponse(script.Name.ToString(),
+                ScriptType.API,
+                Gateway.CloudCodeApiV1.Generated.Model.Language.JS,
+                activeScript: new GetScriptResponseActiveScript(
+                    script.Body,
+                    1,
+                    DateNow,
+                    new List<ScriptParameter>()),
+                new List<GetScriptResponseVersionsInner>(),
+                new List<ScriptParameter>());
+
+            setup.ReturnsAsync(getScriptResponse);
+        }
+
+    }
+
+    void SetupList(IEnumerable<ListScriptsResponseResultsInner> result)
+    {
+        m_MockCloudCodeService.Setup(
+                cs => cs.ListAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(result));
+    }
+
+    void SetupDelete()
+    {
+        m_MockCloudCodeService.Setup(
+                cs => cs.DeleteAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(new ApiResponse<object>(HttpStatusCode.NoContent, new object())));
+    }
+
+    void VerifyApiCalls(List<ApiCallType> apiCallTypes)
+    {
+        var getTimes = apiCallTypes.Contains(ApiCallType.Get) ? Times.Once() : Times.Never();
+        m_MockCloudCodeService.Verify(
+            cs => cs.GetAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            getTimes);
+
+        var listTimes = apiCallTypes.Contains(ApiCallType.List) ? Times.Once() : Times.Never();
+        m_MockCloudCodeService.Verify(
+            cs => cs.ListAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            listTimes);
+
+        var createTimes = apiCallTypes.Contains(ApiCallType.Create) ? Times.Once() : Times.Never();
+        m_MockCloudCodeService.Verify(
+            cs => cs.CreateAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                ScriptType.API,
+                Gateway.CloudCodeApiV1.Generated.Model.Language.JS,
+                It.IsAny<string>(),
+                It.IsAny<IReadOnlyList<ScriptParameter>>(),
+                It.IsAny<CancellationToken>()),
+            createTimes);
+
+        var updateTimes = apiCallTypes.Contains(ApiCallType.Update) ? Times.Once() : Times.Never();
+        m_MockCloudCodeService.Verify(
+            cs => cs.UpdateAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<IReadOnlyList<ScriptParameter>>(),
+                It.IsAny<CancellationToken>()),
+            updateTimes);
+
+        var publishTimes = apiCallTypes.Contains(ApiCallType.Publish) ? Times.Once() : Times.Never();
+        m_MockCloudCodeService.Verify(
+            cs => cs.PublishAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<int>(),
+                It.IsAny<CancellationToken>()),
+            publishTimes);
+
+        var deleteTimes = apiCallTypes.Contains(ApiCallType.Delete) ? Times.Once() : Times.Never();
+        m_MockCloudCodeService.Verify(
+            cs => cs.DeleteAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            deleteTimes);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/UpdateHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/UpdateHandlerTests.cs
index e2da2c9..d83f17e 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/UpdateHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Handlers/UpdateHandlerTests.cs
@@ -8,6 +8,7 @@
 using Spectre.Console;
 using Unity.Services.Cli.CloudCode.Handlers;
 using Unity.Services.Cli.CloudCode.Input;
+using Unity.Services.Cli.CloudCode.Model;
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.Cli.CloudCode.Service;
 using Unity.Services.Cli.CloudCode.UnitTest.Utils;
@@ -65,7 +66,7 @@ public async Task UpdateAsync_CallsUpdateAsyncWhenInputIsValid()
         m_MockInputParseService.Setup(x => x.LoadScriptCodeAsync(input, CancellationToken.None))
             .ReturnsAsync(TestValues.ValidCode);
         m_MockCloudCodeScriptParser.Setup(x => x.ParseScriptParametersAsync(TestValues.ValidCode, CancellationToken.None))
-            .ReturnsAsync(k_Parameters);
+            .ReturnsAsync(new ParseScriptParametersResult(false, k_Parameters));
         m_MockInputParseService.SetupGet(x => x.CloudCodeScriptParser)
             .Returns(m_MockCloudCodeScriptParser.Object);
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Mock/MockCloudCodeDeploymentHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Mock/MockCloudCodeDeploymentHandler.cs
index 36216e1..7314551 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Mock/MockCloudCodeDeploymentHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Mock/MockCloudCodeDeploymentHandler.cs
@@ -7,7 +7,7 @@
 
 namespace Unity.Services.Cli.CloudCode.UnitTest.Mock;
 
-internal class MockCloudCodeDeploymentHandler : CloudCodeDeploymentHandler, ICliDeploymentOutputHandler
+class MockCloudCodeDeploymentHandler : CloudCodeDeploymentHandler, ICliDeploymentOutputHandler
 {
     public MockCloudCodeDeploymentHandler(
         ICloudCodeClient client,
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Model/OutputScriptTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Model/OutputScriptTests.cs
index f1ac283..352683b 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Model/OutputScriptTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Model/OutputScriptTests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using NUnit.Framework;
 using Unity.Services.Cli.CloudCode.Model;
@@ -43,7 +44,7 @@ public void ConstructOutputScriptWithValidResponse()
         Assert.AreEqual(m_GetScriptResponse.ActiveScript.Code, outputScript.ActiveScript.Code);
         Assert.AreEqual(m_GetScriptResponse.ActiveScript.Params, outputScript.ActiveScript.Params);
         Assert.AreEqual(m_GetScriptResponse.ActiveScript._Version, outputScript.ActiveScript.Version);
-        Assert.AreEqual(m_GetScriptResponse.ActiveScript.DatePublished, outputScript.ActiveScript.DatePublished);
+        Assert.AreEqual(m_GetScriptResponse.ActiveScript.DatePublished.ToString("s", CultureInfo.InvariantCulture), outputScript.ActiveScript.DatePublished);
         Assert.AreEqual(m_GetScriptResponse.Versions, outputScript.Versions);
     }
 
@@ -81,7 +82,7 @@ public void OutputScriptToStringReturnFormattedString()
             "versions: []",
             "activeScript:",
             "  version: 0",
-            "  datePublished: 0001-01-01T00:00:00.0000000",
+            "  datePublished: 0001-01-01T00:00:00",
             "  params: []",
             $"  code: ''{System.Environment.NewLine}"
         };
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ModuleTestCases/Module.ccm b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ModuleTestCases/Module.ccm
new file mode 100644
index 0000000..a4108c7
Binary files /dev/null and b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ModuleTestCases/Module.ccm differ
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ModuleTestCases/test.ccmzip b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ModuleTestCases/test.ccmzip
new file mode 100644
index 0000000..387442e
Binary files /dev/null and b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ModuleTestCases/test.ccmzip differ
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ScriptTestCases/Import/test.jszip b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ScriptTestCases/Import/test.jszip
new file mode 100644
index 0000000..3f34399
Binary files /dev/null and b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ScriptTestCases/Import/test.jszip differ
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Service/CloudCodeInputParserTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Service/CloudCodeInputParserTests.cs
index 76e89ee..a2ac7e7 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Service/CloudCodeInputParserTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Service/CloudCodeInputParserTests.cs
@@ -21,7 +21,7 @@ class CloudCodeInputParserTests
     const string k_ValidFilepath = @".\createhandlertemp.js";
     const string k_ExpectedCode = "Dummy text";
 
-    private static readonly Mock<ICloudCodeScriptParser> k_MockCloudCodeScriptParser = new();
+    static readonly Mock<ICloudCodeScriptParser> k_MockCloudCodeScriptParser = new();
 
     readonly CloudCodeInputParser m_CloudCodeInputParser = new(k_MockCloudCodeScriptParser.Object);
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Service/CloudCodeServiceTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Service/CloudCodeServiceTests.cs
index ba4f91b..075daee 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Service/CloudCodeServiceTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Service/CloudCodeServiceTests.cs
@@ -25,7 +25,7 @@ namespace Unity.Services.Cli.CloudCode.UnitTest.Service;
 class CloudCodeServiceTests
 {
     const string k_TestScriptName = "test-script";
-    private const string k_TestModuleName = "test_module";
+    const string k_TestModuleName = "test_module";
     const string k_TestAccessToken = "test-token";
     const string k_InvalidProjectId = "invalidProject";
     const string k_InvalidEnvironmentId = "foo";
@@ -67,6 +67,7 @@ public void SetUp()
                 k_TestModuleName,
                 Language.CS,
                 null,
+                "url",
                 DateTime.Now,
                 DateTime.Now)
         };
@@ -90,6 +91,7 @@ public void SetUp()
             "bar",
             Language.CS,
             null,
+            "url",
             DateTime.Now,
             DateTime.Now);
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Unity.Services.Cli.CloudCode.UnitTest.csproj b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Unity.Services.Cli.CloudCode.UnitTest.csproj
index f644475..60d7a71 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Unity.Services.Cli.CloudCode.UnitTest.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Unity.Services.Cli.CloudCode.UnitTest.csproj
@@ -21,7 +21,7 @@
     <PackageReference Include="NUnit3TestAdapter" Version="4.4.2" />
     <PackageReference Include="coverlet.collector" Version="3.2.0" />
     <PackageReference Include="System.CommandLine.Hosting" Version="0.4.0-alpha.22272.1" />
-    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.1.0" />
+    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.2.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Unity.Services.Cli.CloudCode\Unity.Services.Cli.CloudCode.csproj" />
@@ -31,4 +31,12 @@
     <EmbeddedResource Include="ScriptTestCases\JS\*.js" />
     <EmbeddedResource Include="ScriptTestCases\JS\*.json" />
   </ItemGroup>
+  <ItemGroup>
+    <None Update="ModuleTestCases\Module.ccm">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="ModuleTestCases\test.ccmzip">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Utils/CloudCodeScriptParserExtensionsTests.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Utils/CloudCodeScriptParserExtensionsTests.cs
index 556eabd..52107ac 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Utils/CloudCodeScriptParserExtensionsTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/Utils/CloudCodeScriptParserExtensionsTests.cs
@@ -4,6 +4,7 @@
 using Moq;
 using NUnit.Framework;
 using Unity.Services.Cli.CloudCode.Exceptions;
+using Unity.Services.Cli.CloudCode.Model;
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
@@ -35,11 +36,10 @@ public void SetUp()
     public async Task TryParseScriptParametersAsyncReturnsTrueWhenParsingSucceeds()
     {
         m_Parser.Setup(x => x.ParseScriptParametersAsync(k_ScriptBody, CancellationToken.None))
-            .ReturnsAsync(
-                new[]
-                {
-                    new ScriptParameter("foo")
-                });
+            .ReturnsAsync(new ParseScriptParametersResult(true, new[]
+            {
+                new ScriptParameter("foo")
+            }));
 
         var (hasParameters, errorMessage) = await m_Parser.Object.TryParseScriptParametersAsync(
             m_Script.Object, CancellationToken.None);
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Clients/CloudCodeScriptClient.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Clients/CloudCodeScriptClient.cs
index 00357d6..b00e6f5 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Clients/CloudCodeScriptClient.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Clients/CloudCodeScriptClient.cs
@@ -54,7 +54,7 @@ public async Task<ScriptName> UploadFromFile(IScript script)
     {
         var scriptNameWithoutExt = script.Name.GetNameWithoutExtension();
         var code = await m_CloudCodeInputInputParser.LoadScriptCodeAsync(script.Path, CancellationToken);
-        var parameters = await m_CloudCodeScriptParser.ParseScriptParametersAsync(code, CancellationToken);
+        var parametersParsingResult = await m_CloudCodeScriptParser.ParseScriptParametersAsync(code, CancellationToken);
         try
         {
             await m_CloudCodeService.UpdateAsync(
@@ -62,7 +62,7 @@ await m_CloudCodeService.UpdateAsync(
                 EnvironmentId,
                 scriptNameWithoutExt,
                 code,
-                parameters,
+                parametersParsingResult.Parameters,
                 CancellationToken);
         }
         catch (ApiException ex)
@@ -75,7 +75,7 @@ await m_CloudCodeService.CreateAsync(
                 ScriptType.API,
                 Language.JS,
                 code,
-                parameters,
+                parametersParsingResult.Parameters,
                 CancellationToken);
         }
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Fetch/JavaScriptFetchHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Fetch/JavaScriptFetchHandler.cs
index 42f90f5..3518d00 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Fetch/JavaScriptFetchHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Fetch/JavaScriptFetchHandler.cs
@@ -5,6 +5,7 @@
 using Unity.Services.Cli.CloudCode.Deploy;
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.DeploymentApi.Editor;
 
 namespace Unity.Services.Cli.CloudCode.Authoring;
 
@@ -62,23 +63,30 @@ public async Task<FetchResult> FetchAsync(
         await EnforceScriptParametersInBodyAsync(updated, failed, token);
 
         if (dryRun)
-            return CreateResult();
+            return CreateResult(dryRun);
+
+        FilterFailedScripts();
 
         await ApplyFetchAsync(updated, created, deleted, failed, token);
 
-        return CreateResult();
+        return CreateResult(dryRun);
 
-        FetchResult CreateResult()
+        FetchResult CreateResult(bool dryRun)
         {
             FilterFailedScripts();
-            var fetched = created.Union(updated, m_ScriptComparer)
-                .Union(deleted, m_ScriptComparer);
+            var updatedContent = updated.Select(j => GetDeployContent(j, "Updated")).ToList();
+            var deletedContent = deleted.Select(j => GetDeployContent(j, "Deleted")).ToList();
+            var createdContent = created.Select(j => GetDeployContent(j, "Created")).ToList();
+            var fetched = updatedContent
+                .Union(deletedContent)
+                .Union(createdContent);
             return new FetchResult(
-                updated.Select(GetScriptRelativePathOrName).ToList(),
-                deleted.Select(GetScriptRelativePathOrName).ToList(),
-                created.Select(GetScriptRelativePathOrName).ToList(),
-                fetched.Select(GetScriptRelativePathOrName).ToList(),
-                failed.Distinct(m_ScriptComparer).Select(x => x.Name.ToString()).ToList());
+                updatedContent,
+                deletedContent,
+                createdContent,
+                fetched.ToList(),
+                failed.Distinct(m_ScriptComparer).Select(j => GetDeployContent(j, "Failed")).ToList(),
+                dryRun);
         }
 
         void FilterFailedScripts()
@@ -88,13 +96,14 @@ void FilterFailedScripts()
             created = created.Except(failed, m_ScriptComparer).ToList();
         }
 
-        string GetScriptRelativePathOrName(IScript script)
+        DeployContent GetDeployContent(IScript script, string status)
         {
-            if (script.Path is null)
-                return script.Name.ToString();
-
-            var path = Path.GetRelativePath(rootDirectory, script.Path);
-            return IoUtils.NormalizePath(path);
+            return new DeployContent(
+                script.Name.ToString(),
+                "Cloud Code Scripts",
+                script.Path,
+                100,
+                new DeploymentStatus(status, string.Empty));
         }
     }
 
@@ -169,7 +178,9 @@ internal async Task EnforceScriptParametersInBodyAsync(
         var builder = new StringBuilder();
         foreach (var script in scripts)
         {
-            var (hasParameters, errorMessage) = await m_ScriptParser.TryParseScriptParametersAsync(script, token);
+            var (hasParameters, errorMessage) = await m_ScriptParser
+                .TryParseScriptParametersAsync(script, token);
+
             if (hasParameters)
             {
                 continue;
@@ -179,10 +190,12 @@ internal async Task EnforceScriptParametersInBodyAsync(
             if (errorMessage is not null)
             {
                 m_Logger.LogWarning(errorMessage);
+                failed.Add(script);
+                continue;
             }
 
             // We can't determine parameters for scripts that haven't been published.
-            if (string.IsNullOrEmpty(script.LastPublishedDate))
+            if (!script.Parameters.Any() && string.IsNullOrEmpty(script.LastPublishedDate))
             {
                 // TODO: Include this log in the result as a failure.
                 m_Logger.LogWarning(
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Fetch/JavaScriptFetchService.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Fetch/JavaScriptFetchService.cs
index 69c4866..9e713a4 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Fetch/JavaScriptFetchService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Fetch/JavaScriptFetchService.cs
@@ -5,8 +5,8 @@
 using Unity.Services.Cli.CloudCode.Deploy;
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.Cli.CloudCode.Utils;
 using Unity.Services.Cli.Common.Utils;
-using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
 
 namespace Unity.Services.Cli.CloudCode.Authoring;
 
@@ -44,9 +44,10 @@ public JavaScriptFetchService(
         m_FetchHandler = fetchHandler;
     }
 
-    public string ServiceType => Constants.ServiceType;
+    public string ServiceType => CloudCodeConstants.ServiceType;
+    public string ServiceName => CloudCodeConstants.ServiceName;
 
-    string IFetchService.FileExtension => Constants.JavaScriptFileExtension;
+    string IFetchService.FileExtension => CloudCodeConstants.JavaScriptFileExtension;
 
     public async Task<FetchResult> FetchAsync(
         FetchInput input, StatusContext? loadingContext, CancellationToken cancellationToken)
@@ -76,16 +77,15 @@ internal async Task<CloudCodeScriptLoadResult> GetResourcesFromFilesAsync(
             {
                 input.Path
             },
-            Constants.JavaScriptFileExtension);
-        var contents = new List<DeployContent>();
+            CloudCodeConstants.JavaScriptFileExtension);
+
         var loadResult = await m_ScriptsLoader
             .LoadScriptsAsync(
                 files,
                 ServiceType,
-                Constants.JavaScriptFileExtension,
+                CloudCodeConstants.JavaScriptFileExtension,
                 m_InputParser,
                 m_ScriptParser,
-                contents,
                 cancellationToken);
         return loadResult;
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Utils/ScriptExtensions.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Utils/ScriptExtensions.cs
index 3ba44bf..39fc7b2 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Utils/ScriptExtensions.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Authoring/Utils/ScriptExtensions.cs
@@ -10,7 +10,6 @@ public static void InjectJavaScriptParametersToBody(this IScript script, StringB
         var javaScriptParams = script.Parameters.ToJavaScript();
         builder.Clear()
             .AppendLine(script.Body)
-            .AppendLine()
             .AppendLine($"module.exports.params = {javaScriptParams};");
         script.Body = builder.ToString();
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/CloudCodeModule.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/CloudCodeModule.cs
index f7147e7..b491ebc 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/CloudCodeModule.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/CloudCodeModule.cs
@@ -1,6 +1,8 @@
 using System.CommandLine;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export.Input;
 using Unity.Services.Cli.CloudCode.Authoring;
 using Unity.Services.Cli.CloudCode.Deploy;
 using Unity.Services.Cli.CloudCode.Handlers;
@@ -21,13 +23,19 @@
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Api;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Client;
 using Unity.Services.Cli.Authoring.Handlers;
+using Unity.Services.Cli.CloudCode.Handlers.ImportExport.Scripts;
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.CloudCode.Handlers.ImportExport.Modules;
 using Unity.Services.Cli.CloudCode.Templates;
+using Unity.Services.Cli.CloudCode.Utils;
 using ILogger = Microsoft.Extensions.Logging.ILogger;
 
 namespace Unity.Services.Cli.CloudCode;
 
 public class CloudCodeModule : ICommandModule
 {
+    internal Command ExportScriptsCommand { get; }
+    internal Command ImportScriptsCommand { get; }
     internal Command ListCommand { get; }
     internal Command DeleteCommand { get; }
     internal Command PublishCommand { get; }
@@ -35,10 +43,39 @@ public class CloudCodeModule : ICommandModule
     internal Command CreateCommand { get; }
     internal Command UpdateCommand { get; }
     internal Command NewFileCommand { get; }
+    internal Command ScriptsCommand { get; }
     public Command ModuleRootCommand { get; }
 
     public CloudCodeModule()
     {
+        ExportScriptsCommand = new Command("export", "Export Cloud Code scripts.")
+        {
+            CommonInput.CloudProjectIdOption,
+            CommonInput.EnvironmentNameOption,
+            ExportInput.OutputDirectoryArgument,
+            ExportInput.DryRunOption,
+            ExportInput.FileNameArgument
+        };
+        ExportScriptsCommand.SetHandler<
+            ExportInput,
+            CloudCodeScriptsExporter,
+            ILoadingIndicator,
+            CancellationToken>(ScriptExportHandler.ExportAsync);
+        ImportScriptsCommand = new Command("import", "Import Cloude Code scripts.")
+        {
+            CommonInput.CloudProjectIdOption,
+            CommonInput.EnvironmentNameOption,
+            ImportInput.InputDirectoryArgument,
+            ImportInput.DryRunOption,
+            ImportInput.ReconcileOption,
+            ImportInput.FileNameArgument
+        };
+        ImportScriptsCommand.SetHandler<
+            ImportInput,
+            CloudCodeScriptsImporter,
+            ILoadingIndicator,
+            CancellationToken>(
+            ImportHandler.ImportAsync);
         ListCommand = new Command("list", "List Cloud-Code scripts.")
         {
             CommonInput.CloudProjectIdOption,
@@ -135,10 +172,10 @@ public CloudCodeModule()
             CancellationToken>(
             UpdateHandler.UpdateAsync);
 
-        NewFileCommand = ModuleRootCommand.AddNewFileCommand<CloudCodeTemplate>("Cloud Code");
+        NewFileCommand = ModuleRootCommand.AddNewFileCommand<CloudCodeTemplate>(CloudCodeConstants.ServiceType);
 
-        ModuleRootCommand = new Command(
-            "cloud-code",
+        ScriptsCommand = new Command(
+            "scripts",
             "Manage Cloud-Code scripts.")
         {
             ListCommand,
@@ -147,7 +184,18 @@ public CloudCodeModule()
             GetCommand,
             CreateCommand,
             UpdateCommand,
-            NewFileCommand
+            NewFileCommand,
+            ExportScriptsCommand,
+            ImportScriptsCommand
+        };
+
+        ScriptsCommand.AddAlias("s");
+
+        ModuleRootCommand = new Command(
+            "cloud-code",
+            "Manage Cloud-Code scripts and modules.")
+        {
+            ScriptsCommand
         };
 
         ModuleRootCommand.AddAlias("cc");
@@ -195,13 +243,45 @@ static void RegisterModulesCommands(Command root)
         listModuleCommand.SetHandler<CommonInput, IUnityEnvironment, ICloudCodeService, ILogger, ILoadingIndicator,
             CancellationToken>(ListModulesHandler.ListModulesAsync);
 
+        var exportModulesCommand = new Command("export", "Export Cloud Code modules.")
+        {
+            CommonInput.CloudProjectIdOption,
+            CommonInput.EnvironmentNameOption,
+            ExportInput.OutputDirectoryArgument,
+            ExportInput.DryRunOption,
+            ExportInput.FileNameArgument
+        };
+        exportModulesCommand.SetHandler<
+            ExportInput,
+            CloudCodeModulesExporter,
+            ILoadingIndicator,
+            CancellationToken>(ModuleExportHandler.ExportAsync);
+
+        var importModulesCommand = new Command("import", "Import Cloud Code modules.")
+        {
+            CommonInput.CloudProjectIdOption,
+            CommonInput.EnvironmentNameOption,
+            ImportInput.InputDirectoryArgument,
+            ImportInput.DryRunOption,
+            ImportInput.ReconcileOption,
+            ImportInput.FileNameArgument
+        };
+        importModulesCommand.SetHandler<
+            ImportInput,
+            CloudCodeModulesImporter,
+            ILoadingIndicator,
+            CancellationToken>(
+            ModulesImportHandler.ImportAsync);
+
         var modulesHandlerCommand = new Command(
             "modules",
             "Manage Cloud-Code modules.")
         {
             getModuleCommand,
             listModuleCommand,
-            deleteModuleCommand
+            deleteModuleCommand,
+            exportModulesCommand,
+            importModulesCommand
         };
 
         modulesHandlerCommand.AddAlias("m");
@@ -229,6 +309,8 @@ public static void RegisterServices(HostBuilderContext hostBuilderContext, IServ
         serviceCollection.AddSingleton<IScriptCache, JsScriptCache>();
         serviceCollection.AddSingleton<IPreDeployValidator, PreDeployValidator>();
         serviceCollection.AddSingleton<ICloudCodeModulesLoader, CloudCodeModulesLoader>();
+        serviceCollection.AddSingleton<HttpClient>();
+        serviceCollection.AddSingleton<ICloudCodeModulesDownloader, CloudCodeModulesDownloader>();
         serviceCollection.AddSingleton<ICloudCodeScriptsLoader, CloudCodeScriptsLoader>();
         serviceCollection.AddSingleton<ICloudCodeService, CloudCodeService>();
         serviceCollection.AddSingleton<ICloudCodeInputParser, CloudCodeInputParser>();
@@ -243,6 +325,13 @@ public static void RegisterServices(HostBuilderContext hostBuilderContext, IServ
         serviceCollection.AddTransient<IDeploymentService, CloudCodeScriptDeploymentService>(CreateJavaScriptDeployService);
         serviceCollection.AddTransient<IDeploymentService, CloudCodePrecompiledModuleDeploymentService>(CreateCSharpDeployService);
         serviceCollection.AddTransient<IFetchService, JavaScriptFetchService>();
+
+        serviceCollection.AddTransient<CloudCodeScriptsExporter, CloudCodeScriptsExporter>();
+        serviceCollection.AddTransient<CloudCodeScriptsImporter, CloudCodeScriptsImporter>();
+        serviceCollection.AddTransient<CloudCodeModulesExporter, CloudCodeModulesExporter>();
+        serviceCollection.AddTransient<CloudCodeModulesImporter, CloudCodeModulesImporter>();
+
+        serviceCollection.AddTransient<IZipArchiver, ZipArchiver>();
     }
 
     internal static CloudCodeScriptDeploymentService CreateJavaScriptDeployService(IServiceProvider provider)
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CliCloudCodeDeploymentHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CliCloudCodeDeploymentHandler.cs
index 5745586..3d45559 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CliCloudCodeDeploymentHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CliCloudCodeDeploymentHandler.cs
@@ -3,14 +3,13 @@
 using Unity.Services.CloudCode.Authoring.Editor.Core.Deployment;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Logging;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.DeploymentApi.Editor;
 
 namespace Unity.Services.Cli.CloudCode.Deploy;
 
-class CliCloudCodeDeploymentHandler<TClient> : CloudCodeDeploymentHandler, IDeploymentHandlerWithOutput
+class CliCloudCodeDeploymentHandler<TClient> : CloudCodeDeploymentHandler
     where TClient : ICloudCodeClient
 {
-    public ICollection<DeployContent> Contents { get; } = new List<DeployContent>();
-
     public CliCloudCodeDeploymentHandler(
         TClient client,
         IDeploymentAnalytics deploymentAnalytics,
@@ -24,14 +23,20 @@ public CliCloudCodeDeploymentHandler(
     protected override void UpdateScriptStatus(
         IScript script, string message, string detail, StatusSeverityLevel level = StatusSeverityLevel.None)
     {
-        var content = Contents.First(c => string.Equals(script.Path, c.Path));
-        content.Status = message;
-        content.Detail = detail;
+        if(script is DeployContent deployContent)
+        {
+            deployContent.Status = new DeploymentStatus(
+                message,
+                detail,
+                (SeverityLevel)Enum.Parse(typeof(SeverityLevel), level.ToString()));
+        }
     }
 
     protected override void UpdateScriptProgress(IScript script, float progress)
     {
-        var deployContent = Contents.First(c => string.Equals(script.Path, c.Path.ToString()));
-        deployContent.Progress = progress;
+        if(script is DeployContent deployContent)
+        {
+            deployContent.Progress = progress;
+        }
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeModule.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeModule.cs
index 2e9b82f..f852fb6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeModule.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeModule.cs
@@ -1,23 +1,81 @@
 using System.Globalization;
+using Newtonsoft.Json;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.CloudCode.Utils;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
-using Language = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
+using LanguageType = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
 
 namespace Unity.Services.Cli.CloudCode.Deploy;
 
-class CloudCodeModule : IScript
+class CloudCodeModule : DeployContent, IScript
 {
-    public ScriptName Name { get; set; }
-    public Language? Language { get; set; }
-    public string? Path { get; set; }
+    [JsonConverter(typeof(ScriptNameJsonConverter))]
+    // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global used for deserialization
+    public new ScriptName Name { get; set; }
+    public LanguageType? Language { get; set; }
     public string Body { get; set; }
     public List<CloudCodeParameter> Parameters { get; }
     public string LastPublishedDate { get; set; }
+    [JsonIgnore]
+    public string SignedUrl { get; set; }
+    public CloudCodeModule()
+        : this(
+            default,
+            default,
+            "",
+            "",
+            new List<CloudCodeParameter>(),
+            "")
+    { }
 
     public CloudCodeModule(
         ScriptName name,
-        Language language,
-        string path)
+        LanguageType? language,
+        string path,
+        string body,
+        List<CloudCodeParameter> parameters,
+        string lastPublishedDate)
+        : base(
+            name.GetNameWithoutExtension(),
+            CloudCodeConstants.ServiceTypeModules,
+            path,
+            0f,
+            DeploymentStatus.Empty)
+    {
+        Name = name;
+        Language = language;
+        Path = path;
+        Body = body;
+        Parameters = parameters;
+        LastPublishedDate = lastPublishedDate;
+        SignedUrl = "";
+    }
+
+    public CloudCodeModule(string name, string path, float progress, DeploymentStatus? status, string signedUrl = "")
+        : base(name, CloudCodeConstants.ServiceTypeModules, path, progress, status)
+    {
+        Name = ScriptName.FromPath(path);
+        Language = LanguageType.JS;
+        Path = path;
+        Body = string.Empty;
+        Parameters = new List<CloudCodeParameter>();
+        LastPublishedDate = string.Empty;
+        SignedUrl = signedUrl;
+    }
+
+    public CloudCodeModule(
+        ScriptName name,
+        LanguageType language,
+        string path,
+        string signedUrl = "")
+        : base(
+            name.GetNameWithoutExtension(),
+            "",
+            path,
+            0f,
+            DeploymentStatus.Empty)
     {
         Name = name;
         Language = language;
@@ -25,14 +83,22 @@ public CloudCodeModule(
         Body = "";
         Parameters = new List<CloudCodeParameter>();
         LastPublishedDate = "";
+        SignedUrl = signedUrl;
     }
 
     public CloudCodeModule(GetModuleResponse response)
+        : base(
+            response.Name,
+            CloudCodeConstants.ServiceTypeModules,
+            "",
+            0F,
+            DeploymentStatus.Empty)
     {
         Name = new ScriptName(response.Name);
-        Language = (Language)Enum.Parse(typeof(Language), response.Language.ToString());
+        Language = (LanguageType)Enum.Parse(typeof(LanguageType), response.Language.ToString());
         Body = "";
         Parameters = new List<CloudCodeParameter>();
         LastPublishedDate = response.DateModified.ToString(CultureInfo.InvariantCulture);
+        SignedUrl = "";
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeModulesDownloader.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeModulesDownloader.cs
new file mode 100644
index 0000000..be7cd30
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeModulesDownloader.cs
@@ -0,0 +1,14 @@
+namespace Unity.Services.Cli.CloudCode.Deploy;
+
+class CloudCodeModulesDownloader : ICloudCodeModulesDownloader
+{
+    readonly HttpClient _httpClient;
+    public CloudCodeModulesDownloader(HttpClient client) => _httpClient = client;
+
+    public Task<Stream> DownloadModule(
+        CloudCodeModule module,
+        CancellationToken cancellationToken)
+    {
+            return _httpClient.GetStreamAsync(module.SignedUrl, cancellationToken);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeModulesLoader.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeModulesLoader.cs
index 6eb4860..e23da13 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeModulesLoader.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeModulesLoader.cs
@@ -1,5 +1,7 @@
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Language = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
+using Unity.Services.DeploymentApi.Editor;
 
 namespace Unity.Services.Cli.CloudCode.Deploy;
 
@@ -7,24 +9,18 @@ class CloudCodeModulesLoader : ICloudCodeModulesLoader
 {
     public Task<List<IScript>> LoadPrecompiledModulesAsync(
         IReadOnlyList<string> paths,
-        string serviceType,
-        string extension,
-        ICollection<DeployContent> deployContents)
+        string serviceType)
     {
         var modules = new List<IScript>();
 
         foreach (var path in paths)
         {
-            var zipNameWithExtension = Path.GetFileName(path);
-
-            modules.Add(new CloudCodeModule(
-                new ScriptName(zipNameWithExtension),
-                Language.JS,
-                path
-            ));
-
-            deployContents.Add(new DeployContent(
-                ScriptName.FromPath(path).ToString(), serviceType, path, 0, "Loaded"));
+            modules.Add(
+                new CloudCodeModule(
+                    ScriptName.FromPath(path).ToString(),
+                    path,
+                    0,
+                    new DeploymentStatus(Statuses.Loaded)));
         }
 
         return Task.FromResult(modules);
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodePrecompiledModuleDeploymentService.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodePrecompiledModuleDeploymentService.cs
index 2c70ade..aad7dd6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodePrecompiledModuleDeploymentService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodePrecompiledModuleDeploymentService.cs
@@ -3,40 +3,45 @@
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.Authoring.Service;
 using Unity.Services.Cli.CloudCode.Authoring;
+using Unity.Services.Cli.CloudCode.Model;
+using Unity.Services.Cli.CloudCode.Utils;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Deployment;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Client;
 
 namespace Unity.Services.Cli.CloudCode.Deploy;
 
 class CloudCodePrecompiledModuleDeploymentService : IDeploymentService
 {
-    internal ICliDeploymentOutputHandler CliDeploymentOutputHandler { get; }
     internal ICloudCodeModulesLoader CloudCodeModulesLoader { get; }
     internal ICliEnvironmentProvider EnvironmentProvider { get; }
     internal ICSharpClient CliCloudCodeClient { get; }
-    internal ICloudCodeDeploymentHandler CloudCodeDeploymentHandler { get; }
+    ICloudCodeDeploymentHandler CloudCodeDeploymentHandler { get; }
 
     readonly string m_ServiceType;
+    readonly string m_ServiceName;
     readonly string m_DeployPrecompiledFileExtension;
 
     public CloudCodePrecompiledModuleDeploymentService(
-        IDeploymentHandlerWithOutput deployHandlerWithOutput,
+        ICloudCodeDeploymentHandler deployHandler,
         ICloudCodeModulesLoader cloudCodeModulesLoader,
         ICliEnvironmentProvider environmentProvider,
         ICSharpClient client)
     {
-        CliDeploymentOutputHandler = deployHandlerWithOutput;
         CloudCodeModulesLoader = cloudCodeModulesLoader;
         EnvironmentProvider = environmentProvider;
         CliCloudCodeClient = client;
-        CloudCodeDeploymentHandler = deployHandlerWithOutput;
-        m_ServiceType = "Cloud Code";
+        CloudCodeDeploymentHandler = deployHandler;
+        m_ServiceType = CloudCodeConstants.ServiceTypeModules;
+        m_ServiceName = CloudCodeConstants.ServiceNameModule;
         m_DeployPrecompiledFileExtension = ".ccm";
     }
 
     string IDeploymentService.ServiceType => m_ServiceType;
 
+    string IDeploymentService.ServiceName => m_ServiceName;
+
     string IDeploymentService.DeployFileExtension => m_DeployPrecompiledFileExtension;
 
     public async Task<DeploymentResult> Deploy(
@@ -50,15 +55,14 @@ public async Task<DeploymentResult> Deploy(
         CliCloudCodeClient.Initialize(environmentId, projectId, cancellationToken);
         EnvironmentProvider.Current = environmentId;
 
-        loadingContext?.Status($"Reading {m_ServiceType} Modules ...");
+        loadingContext?.Status($"Reading {m_ServiceType}...");
 
-        var modules = await CloudCodeModulesLoader.LoadPrecompiledModulesAsync(
+        var loadResult = await CloudCodeModulesLoader.LoadPrecompiledModulesAsync(
             filePaths,
-            m_ServiceType,
-            m_DeployPrecompiledFileExtension,
-            CliDeploymentOutputHandler.Contents);
+            m_ServiceType);
+
 
-        loadingContext?.Status($"Deploying {m_ServiceType} Modules...");
+        loadingContext?.Status($"Deploying {m_ServiceType}...");
 
         var dryrun = deployInput.DryRun;
         var reconcile = deployInput.Reconcile;
@@ -66,7 +70,7 @@ public async Task<DeploymentResult> Deploy(
 
         try
         {
-            result = await CloudCodeDeploymentHandler.DeployAsync(modules, reconcile, dryrun);
+            result = await CloudCodeDeploymentHandler.DeployAsync(loadResult, reconcile, dryrun);
         }
         catch (ApiException)
         {
@@ -80,40 +84,33 @@ public async Task<DeploymentResult> Deploy(
             result = ex.Result;
         }
 
-        if (result == null || modules == null)
+        if (result == null)
         {
-            return new DeploymentResult(CliDeploymentOutputHandler.Contents.ToList());
+            return new DeploymentResult(loadResult.OfType<IDeploymentItem>().ToList());
         }
 
         return new DeploymentResult(
-            ToDeployContents(result.Created),
-            ToDeployContents(result.Updated),
-            ToDeleteContents(result.Deleted),
-            ToDeployContents(result.Deployed),
-            ToDeployContents(result.Failed),
-            dryrun
-        );
-    }
-
-    IReadOnlyCollection<DeployContent> ToDeployContents(IReadOnlyList<IScript> modules)
-    {
-        var contents = new List<DeployContent>();
-
-        foreach (var module in modules)
-        {
-            contents.AddRange(CliDeploymentOutputHandler.Contents.Where(deployContent => module.Path == deployContent.Path));
-        }
-
-        return contents;
+            result.Updated.Select(item => item as IDeploymentItem).ToList() as IReadOnlyList<IDeploymentItem>,
+            ToDeleteDeploymentItems(result.Deleted, deployInput.DryRun),
+            result.Created.Select(item => item as IDeploymentItem).ToList() as IReadOnlyList<IDeploymentItem>,
+            result.Deployed.Select(item => item as IDeploymentItem).ToList() as IReadOnlyList<IDeploymentItem>,
+            result.Failed.Select(item => item as IDeploymentItem).ToList() as IReadOnlyList<IDeploymentItem>,
+            dryrun);
     }
 
-    static IReadOnlyCollection<DeployContent> ToDeleteContents(IReadOnlyList<IScript> modules)
+    static IReadOnlyList<IDeploymentItem> ToDeleteDeploymentItems(IReadOnlyList<IScript> modules, bool dryRun)
     {
-        var contents = new List<DeployContent>();
+        var contents = new List<IDeploymentItem>();
 
         foreach (var module in modules)
         {
-            contents.Add(new DeployContent(module.Name.ToString(), module.Language.ToString()!, module.Path));
+            var deletedCloudCode = new DeletedCloudCode(module.Name.ToString(), module.Language.ToString()!, module.Path);
+            contents.Add(deletedCloudCode);
+            if (!dryRun)
+            {
+                deletedCloudCode.Status = new DeploymentStatus("Deployed", "Deleted remotely", SeverityLevel.Success);
+                deletedCloudCode.Progress = 100f;
+            }
         }
 
         return contents;
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScript.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScript.cs
index 3423bb8..ee785aa 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScript.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScript.cs
@@ -1,15 +1,19 @@
 using System.Globalization;
+using Unity.Services.Cli.Authoring.Model;
+using Newtonsoft.Json;
+using Unity.Services.Cli.CloudCode.Utils;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
-using Language = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
+using LanguageType = Unity.Services.CloudCode.Authoring.Editor.Core.Model.Language;
 
 namespace Unity.Services.Cli.CloudCode.Deploy;
 
-class CloudCodeScript : IScript
+class CloudCodeScript : DeployContent, IScript
 {
-    public ScriptName Name { get; set; }
-    public Language? Language { get; set; }
-    public string Path { get; set; }
+    [JsonConverter(typeof(ScriptNameJsonConverter))]
+    public new ScriptName Name { get; init; }
+    public LanguageType? Language { get; set; }
     public string Body { get; set; }
     public List<CloudCodeParameter> Parameters { get; set; }
     public string LastPublishedDate { get; set; }
@@ -24,13 +28,25 @@ public CloudCodeScript()
             "")
     { }
 
+    public CloudCodeScript(string name, string path, float progress, DeploymentStatus? status)
+        : base(name, CloudCodeConstants.ServiceType, path, progress, status)
+    {
+        Name = ScriptName.FromPath(path);
+        Language = LanguageType.JS;
+        Path = path;
+        Body = string.Empty;
+        Parameters = new List<CloudCodeParameter>();
+        LastPublishedDate = string.Empty;
+    }
+
     public CloudCodeScript(
         ScriptName name,
-        Language? language,
+        LanguageType? language,
         string path,
         string body,
         List<CloudCodeParameter> parameters,
         string lastPublishedDate)
+    : base(name.GetNameWithoutExtension(), CloudCodeConstants.ServiceType, path, 0F, DeploymentStatus.Empty)
     {
         Name = name;
         Language = language;
@@ -41,10 +57,11 @@ public CloudCodeScript(
     }
 
     public CloudCodeScript(GetScriptResponse response)
+    : base(response.Name, CloudCodeConstants.ServiceType, "", 0F, DeploymentStatus.Empty)
     {
         Path = "";
         Name = new ScriptName(response.Name);
-        Language = (Language)Enum.Parse(typeof(Language), response.Language.ToString());
+        Language = (LanguageType)Enum.Parse(typeof(LanguageType), response.Language.ToString());
         if (response.ActiveScript is not null)
         {
             Body = response.ActiveScript.Code;
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptDeploymentService.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptDeploymentService.cs
index db51ee6..6dea725 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptDeploymentService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptDeploymentService.cs
@@ -3,10 +3,13 @@
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.Authoring.Service;
 using Unity.Services.Cli.CloudCode.Authoring;
+using Unity.Services.Cli.CloudCode.Model;
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.Cli.CloudCode.Utils;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Deployment;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Client;
 
 namespace Unity.Services.Cli.CloudCode.Deploy;
@@ -15,35 +18,36 @@ class CloudCodeScriptDeploymentService : IDeploymentService
 {
     internal ICloudCodeInputParser CloudCodeInputParser { get; }
     internal ICloudCodeScriptParser CloudCodeScriptParser { get; }
-    internal ICliDeploymentOutputHandler CliDeploymentOutputHandler { get; }
     internal ICloudCodeScriptsLoader CloudCodeScriptsLoader { get; }
     internal ICliEnvironmentProvider EnvironmentProvider { get; }
     internal IJavaScriptClient CliCloudCodeClient { get; }
     internal ICloudCodeDeploymentHandler CloudCodeDeploymentHandler { get; }
 
     readonly string m_ServiceType;
+    readonly string m_ServiceName;
 
     public CloudCodeScriptDeploymentService(
         ICloudCodeInputParser cloudCodeInputParser,
         ICloudCodeScriptParser cloudCodeScriptParser,
-        IDeploymentHandlerWithOutput deployHandlerWithOutput,
+        ICloudCodeDeploymentHandler deployHandlerWithOutput,
         ICloudCodeScriptsLoader cloudCodeScriptsLoader,
         ICliEnvironmentProvider cliEnvironmentProvider,
         IJavaScriptClient cliCloudCodeClient)
     {
         CloudCodeInputParser = cloudCodeInputParser;
         CloudCodeScriptParser = cloudCodeScriptParser;
-        CliDeploymentOutputHandler = deployHandlerWithOutput;
         CloudCodeScriptsLoader = cloudCodeScriptsLoader;
         EnvironmentProvider = cliEnvironmentProvider;
         CliCloudCodeClient = cliCloudCodeClient;
         CloudCodeDeploymentHandler = deployHandlerWithOutput;
 
-        m_ServiceType = Constants.ServiceType;
-        DeployFileExtension = Constants.JavaScriptFileExtension;
+        m_ServiceType = CloudCodeConstants.ServiceType;
+        m_ServiceName = CloudCodeConstants.ServiceName;
+        DeployFileExtension = CloudCodeConstants.JavaScriptFileExtension;
     }
 
     string IDeploymentService.ServiceType => m_ServiceType;
+    string IDeploymentService.ServiceName => m_ServiceName;
     public string DeployFileExtension { get; }
 
     public async Task<DeploymentResult> Deploy(
@@ -65,7 +69,6 @@ public async Task<DeploymentResult> Deploy(
             DeployFileExtension,
             CloudCodeInputParser,
             CloudCodeScriptParser,
-            CliDeploymentOutputHandler.Contents,
             cancellationToken);
 
         loadingContext?.Status($"Deploying {m_ServiceType} Scripts...");
@@ -89,38 +92,40 @@ public async Task<DeploymentResult> Deploy(
 
         if (result == null)
         {
-            return new DeploymentResult(CliDeploymentOutputHandler.Contents.ToList());
-        }
+            var deployContent = new List<IDeploymentItem>();
 
-        return new DeploymentResult(
-            ToDeployContents(result.Created),
-            ToDeployContents(result.Updated),
-            ToDeleteContents(result.Deleted),
-            ToDeployContents(result.Deployed),
-            ToDeployContents(result.Failed).Concat(loadResult.FailedContents).ToList(),
-            deployInput.DryRun
-        );
-    }
-
-    IReadOnlyCollection<DeployContent> ToDeployContents(IReadOnlyList<IScript> scripts)
-    {
-        var contents = new List<DeployContent>();
+            deployContent.AddRange(loadResult.LoadedScripts.OfType<IDeploymentItem>().ToList());
+            deployContent.AddRange(loadResult.FailedContents.OfType<IDeploymentItem>().ToList());
 
-        foreach (var script in scripts)
-        {
-            contents.AddRange(CliDeploymentOutputHandler.Contents.Where(deployContent => script.Path == deployContent.Path));
+            return new DeploymentResult(deployContent);
         }
 
-        return contents;
+        var failedScripts = result.Failed.Select(item => item as IDeploymentItem)
+                .Concat(loadResult.FailedContents.Select(item => item as IDeploymentItem))
+                .ToList() as IReadOnlyList<IDeploymentItem>;
+
+        return new DeploymentResult(
+            result.Updated.Select(item => item as IDeploymentItem).ToList() as IReadOnlyList<IDeploymentItem>,
+            ToDeleteContents(result.Deleted, deployInput.DryRun),
+            result.Created.Select(item => item as IDeploymentItem).ToList() as IReadOnlyList<IDeploymentItem>,
+            result.Deployed.Select(item => item as IDeploymentItem).ToList() as IReadOnlyList<IDeploymentItem>,
+            failedScripts,
+            deployInput.DryRun);
     }
 
-    static IReadOnlyCollection<DeployContent> ToDeleteContents(IReadOnlyList<IScript> scripts)
+    IReadOnlyList<IDeploymentItem> ToDeleteContents(IReadOnlyList<IScript> scripts, bool dryRun)
     {
-        var contents = new List<DeployContent>();
+        var contents = new List<IDeploymentItem>();
 
         foreach (var script in scripts)
         {
-            contents.Add(new DeployContent(script.Name.ToString(), script.Language.ToString()!, script.Path));
+            var deletedCloudCode = new DeletedCloudCode(script.Name.ToString(), m_ServiceType, script.Path);
+            contents.Add(deletedCloudCode);
+            if (!dryRun)
+            {
+                deletedCloudCode.Status = new DeploymentStatus("Deployed", "Deleted remotely", SeverityLevel.Success);
+                deletedCloudCode.Progress = 100f;
+            }
         }
 
         return contents;
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptLoadResult.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptLoadResult.cs
index abe1263..7fa6aa1 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptLoadResult.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptLoadResult.cs
@@ -1,4 +1,3 @@
-using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
 
 namespace Unity.Services.Cli.CloudCode.Deploy;
@@ -6,9 +5,9 @@ namespace Unity.Services.Cli.CloudCode.Deploy;
 class CloudCodeScriptLoadResult
 {
     public IReadOnlyList<IScript> LoadedScripts { get; }
-    public IReadOnlyList<DeployContent> FailedContents { get; }
+    public IReadOnlyList<IScript> FailedContents { get; }
 
-    public CloudCodeScriptLoadResult(IReadOnlyList<IScript> loadedScripts, IReadOnlyList<DeployContent> failedContents)
+    public CloudCodeScriptLoadResult(IReadOnlyList<IScript> loadedScripts, IReadOnlyList<IScript> failedContents)
     {
         LoadedScripts = loadedScripts;
         FailedContents = failedContents;
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptsLoader.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptsLoader.cs
index 85d7081..e42b050 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptsLoader.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/CloudCodeScriptsLoader.cs
@@ -1,12 +1,13 @@
+using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.CloudCode.Exceptions;
 using Unity.Services.Cli.CloudCode.Service;
-using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.DeploymentApi.Editor;
 
 namespace Unity.Services.Cli.CloudCode.Deploy;
 
-internal class CloudCodeScriptsLoader : ICloudCodeScriptsLoader
+class CloudCodeScriptsLoader : ICloudCodeScriptsLoader
 {
     public async Task<CloudCodeScriptLoadResult> LoadScriptsAsync(
         IReadOnlyCollection<string> paths,
@@ -14,43 +15,51 @@ public async Task<CloudCodeScriptLoadResult> LoadScriptsAsync(
         string extension,
         ICloudCodeInputParser cloudCodeInputParser,
         ICloudCodeScriptParser cloudCodeScriptParser,
-        ICollection<DeployContent> deployContents,
         CancellationToken cancellationToken)
     {
-        var scriptList = new List<IScript>();
-        var failedContents = new List<DeployContent>();
+        var succeedScripts = new List<IScript>();
+        var filedScripts = new List<IScript>();
+
         foreach (var path in paths)
         {
+            var script = new CloudCodeScript(
+                ScriptName.FromPath(path).ToString(),
+                path,
+                0,
+                new DeploymentStatus(Statuses.Loading));
+
             try
             {
-                var script = await LoadCloudCodeScriptFromFilePathAsync(
-                    path, cloudCodeInputParser, cloudCodeScriptParser, cancellationToken);
-                scriptList.Add(script);
-                deployContents.Add(new DeployContent(
-                    ScriptName.FromPath(path).ToString(), serviceType, path, 0, "Loaded"));
+                await LoadCloudCodeScriptAsync(
+                        script,
+                        cloudCodeInputParser,
+                        cloudCodeScriptParser,
+                        cancellationToken);
+                script.Status = new DeploymentStatus(Statuses.Loaded, string.Empty);
+
+                succeedScripts.Add(script);
             }
             catch (ScriptEvaluationException ex)
             {
-                failedContents.Add(new DeployContent(
-                    ScriptName.FromPath(path).ToString(),
-                    serviceType, path, 0, "Failed To Read", ex.Message));
+                script.Status = new DeploymentStatus(Statuses.FailedToRead, ex.Message, SeverityLevel.Error);
+
+                filedScripts.Add(script);
             }
         }
 
-        return new CloudCodeScriptLoadResult(scriptList, failedContents);
+        return new CloudCodeScriptLoadResult(succeedScripts, filedScripts);
     }
 
-    internal static async Task<CloudCodeScript> LoadCloudCodeScriptFromFilePathAsync(
-        string filePath,
+    static async Task LoadCloudCodeScriptAsync(
+        CloudCodeScript script,
         ICloudCodeInputParser cloudCodeInputParser,
         ICloudCodeScriptParser cloudCodeScriptParser,
         CancellationToken cancellationToken)
     {
-        var code = await cloudCodeInputParser.LoadScriptCodeAsync(filePath, cancellationToken);
-        var scriptParameters = await cloudCodeScriptParser.ParseScriptParametersAsync(code, cancellationToken);
-        var cloudCodeParameters = new List<CloudCodeParameter>();
-        cloudCodeParameters.AddRange(scriptParameters.Select(p => p.ToCloudCodeParameter()));
-        return new CloudCodeScript(
-            ScriptName.FromPath(filePath), Language.JS, filePath, code, cloudCodeParameters, "");
+        var code = await cloudCodeInputParser.LoadScriptCodeAsync(script.Path, cancellationToken);
+        var parametersParsingResult = await cloudCodeScriptParser.ParseScriptParametersAsync(code, cancellationToken);
+
+        script.Body = code;
+        script.Parameters.AddRange(parametersParsingResult.Parameters.Select(p => p.ToCloudCodeParameter()));
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ICloudCodeModulesDownloader.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ICloudCodeModulesDownloader.cs
new file mode 100644
index 0000000..6900fcd
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ICloudCodeModulesDownloader.cs
@@ -0,0 +1,8 @@
+namespace Unity.Services.Cli.CloudCode.Deploy;
+
+interface ICloudCodeModulesDownloader
+{
+    Task<Stream> DownloadModule(
+        CloudCodeModule module,
+        CancellationToken cancellationToken);
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ICloudCodeModulesLoader.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ICloudCodeModulesLoader.cs
index 004796c..a08a2b3 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ICloudCodeModulesLoader.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ICloudCodeModulesLoader.cs
@@ -1,5 +1,5 @@
-using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
 
 namespace Unity.Services.Cli.CloudCode.Deploy;
 
@@ -7,7 +7,5 @@ interface ICloudCodeModulesLoader
 {
     Task<List<IScript>> LoadPrecompiledModulesAsync(
         IReadOnlyList<string> paths,
-        string serviceType,
-        string extension,
-        ICollection<DeployContent> deployContents);
+        string serviceType);
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ICloudCodeScriptsLoader.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ICloudCodeScriptsLoader.cs
index 2dd2f78..190263e 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ICloudCodeScriptsLoader.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ICloudCodeScriptsLoader.cs
@@ -1,7 +1,5 @@
 using Unity.Services.Cli.CloudCode.Service;
-using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.CloudCode.Parameters;
-using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
 
 namespace Unity.Services.Cli.CloudCode.Deploy;
 
@@ -13,6 +11,5 @@ Task<CloudCodeScriptLoadResult> LoadScriptsAsync(
         string extension,
         ICloudCodeInputParser cloudCodeInputParser,
         ICloudCodeScriptParser cloudCodeScriptParser,
-        ICollection<DeployContent> deployContents,
         CancellationToken cancellationToken);
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/IDeploymentHandlerWithOutput.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/IDeploymentHandlerWithOutput.cs
deleted file mode 100644
index d3844c2..0000000
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/IDeploymentHandlerWithOutput.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-using Unity.Services.Cli.Authoring.Service;
-using Unity.Services.CloudCode.Authoring.Editor.Core.Deployment;
-
-namespace Unity.Services.Cli.CloudCode.Deploy;
-
-interface IDeploymentHandlerWithOutput : ICliDeploymentOutputHandler, ICloudCodeDeploymentHandler { }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ScriptNameJsonConverter.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ScriptNameJsonConverter.cs
new file mode 100644
index 0000000..53d0bad
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ScriptNameJsonConverter.cs
@@ -0,0 +1,23 @@
+using Newtonsoft.Json;
+using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+
+namespace Unity.Services.Cli.CloudCode.Deploy;
+
+// This is needed as the ScriptName only has private fields
+class ScriptNameJsonConverter : JsonConverter<ScriptName>
+{
+    public override ScriptName ReadJson(
+        JsonReader reader,
+        Type objectType,
+        ScriptName existingValue,
+        bool hasExistingValue,
+        JsonSerializer serializer)
+    {
+        return new ScriptName(reader.Value!.ToString());
+    }
+    public override void WriteJson(JsonWriter writer, ScriptName value, JsonSerializer serializer)
+    {
+        writer.WriteValue(value.ToString());
+    }
+
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ScriptParameterExtension.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ScriptParameterExtension.cs
index bc27bfd..4465c23 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ScriptParameterExtension.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Deploy/ScriptParameterExtension.cs
@@ -3,7 +3,7 @@
 
 namespace Unity.Services.Cli.CloudCode.Deploy;
 
-internal static class ScriptParameterExtension
+static class ScriptParameterExtension
 {
     public static CloudCodeParameter ToCloudCodeParameter(this ScriptParameter scriptParameter)
     {
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/CreateHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/CreateHandler.cs
index af82ec9..28cbbd4 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/CreateHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/CreateHandler.cs
@@ -42,13 +42,14 @@ internal static async Task CreateAsync(
         var scriptType = cloudCodeInputParser.ParseScriptType(input);
         var scriptLanguage = cloudCodeInputParser.ParseLanguage(input);
         var code = await cloudCodeInputParser.LoadScriptCodeAsync(input, cancellationToken);
-        var parameters = await cloudCodeInputParser.CloudCodeScriptParser.ParseScriptParametersAsync(code, cancellationToken);
+        var parametersParsingResult = await cloudCodeInputParser.CloudCodeScriptParser
+            .ParseScriptParametersAsync(code, cancellationToken);
         loadingContext?.Status("Uploading script...");
 
         await cloudCodeService.CreateAsync(
             projectId, environmentId,
             input.ScriptName, scriptType, scriptLanguage,
-            code, parameters, cancellationToken);
+            code, parametersParsingResult.Parameters, cancellationToken);
 
         logger.LogInformation("Script '{scriptName}' created.", input.ScriptName);
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/CloudCodeModulesExporter.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/CloudCodeModulesExporter.cs
new file mode 100644
index 0000000..c7bb386
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/CloudCodeModulesExporter.cs
@@ -0,0 +1,69 @@
+using System.IO.Abstractions;
+using System.IO.Compression;
+using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.CloudCode.Deploy;
+using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.Cli.CloudCode.Utils;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Module = Unity.Services.Cli.CloudCode.Deploy.CloudCodeModule;
+
+namespace Unity.Services.Cli.CloudCode.Handlers.ImportExport.Modules;
+
+class CloudCodeModulesExporter : BaseExporter<Module>
+{
+    readonly ICloudCodeService m_CloudCodeService;
+    readonly ICloudCodeModulesDownloader m_ModulesDownloader;
+
+    public CloudCodeModulesExporter(
+        ICloudCodeService cloudCodeService,
+        ICloudCodeModulesDownloader cloudCodeModulesDownloader,
+        IZipArchiver zipArchiver,
+        IUnityEnvironment unityEnvironment,
+        IFileSystem fileSystem,
+        ILogger logger)
+        : base(
+            zipArchiver,
+            unityEnvironment,
+            fileSystem,
+            logger)
+    {
+        m_CloudCodeService = cloudCodeService;
+        m_ModulesDownloader = cloudCodeModulesDownloader;
+    }
+
+    protected override string FileName => CloudCodeConstants.ModulesZipName;
+    protected override string EntryName => CloudCodeConstants.ModulesEntryName;
+
+    protected override async Task<IEnumerable<Module>> ListConfigsAsync(string projectId, string environmentId, CancellationToken cancellationToken)
+    {
+        var moduleResults = await m_CloudCodeService.ListModulesAsync(
+            projectId, environmentId, cancellationToken);
+
+        var modules = moduleResults.Select(r =>
+            new Module(new ScriptName(r.Name), Language.JS, $"{r.Name}{CloudCodeConstants.SingleModuleFileExtension}", r.SignedDownloadURL));
+
+        return modules;
+    }
+
+    protected override ImportExportEntry<Module> ToImportExportEntry(Module value)
+    {
+        return new ImportExportEntry<Module>(value.Name.GetHashCode(), value.Name.ToString(), value);
+    }
+
+    protected override async Task AfterZip(IEnumerable<Module> configs, string archivePath, CancellationToken cancellationToken)
+    {
+        using var zipArchive = ZipFile.Open(archivePath, ZipArchiveMode.Update);
+
+        foreach (var module in configs)
+        {
+            var entry = zipArchive.CreateEntry(module.Name.ToString());
+            var stream = entry.Open();
+            var stream2 = await m_ModulesDownloader.DownloadModule(module, cancellationToken);
+            await stream2.CopyToAsync(stream, cancellationToken);
+        }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/CloudCodeModulesImporter.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/CloudCodeModulesImporter.cs
new file mode 100644
index 0000000..9e8482c
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/CloudCodeModulesImporter.cs
@@ -0,0 +1,136 @@
+using System.IO.Compression;
+using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Import;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.Cli.CloudCode.Utils;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Client;
+using Module = Unity.Services.Cli.CloudCode.Deploy.CloudCodeModule;
+namespace Unity.Services.Cli.CloudCode.Handlers.ImportExport.Modules;
+
+class CloudCodeModulesImporter : BaseImporter<Module>
+{
+    readonly ICloudCodeService m_CloudCodeService;
+
+    public CloudCodeModulesImporter(
+        ICloudCodeService cloudCodeService,
+        IZipArchiver zipArchiver,
+        IUnityEnvironment unityEnvironment,
+        ILogger logger)
+        : base(
+            zipArchiver,
+            unityEnvironment,
+            logger)
+    {
+        m_CloudCodeService = cloudCodeService;
+    }
+
+    protected override string EntryName => CloudCodeConstants.ModulesEntryName;
+    protected override string FileName => CloudCodeConstants.ModulesZipName;
+
+    protected override async Task DeleteConfigAsync(
+        string projectId,
+        string environmentId,
+        Module moduleToDelete,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            await m_CloudCodeService.DeleteModuleAsync(
+                projectId,
+                environmentId,
+                moduleToDelete.Name.ToString(),
+                cancellationToken);
+        }
+        catch (ApiException e)
+        {
+            m_Logger.LogError("Failed to delete {Name}. Error: {ErrorMsg}", moduleToDelete.Name, e.ErrorContent);
+        }
+
+
+        m_Logger.LogInformation("{Name} successfully deleted", moduleToDelete.Name);
+    }
+
+    protected override async Task<IEnumerable<Module>> ListConfigsAsync(
+        string cloudProjectId,
+        string environmentId,
+        CancellationToken cancellationToken)
+    {
+        var moduleResults = await m_CloudCodeService.ListModulesAsync(
+            cloudProjectId, environmentId, cancellationToken);
+
+        var modules = moduleResults.Select(
+            r => new Module(new ScriptName(r.Name), Language.JS, $"{r.Name}{CloudCodeConstants.SingleModuleFileExtension}", r.SignedDownloadURL));
+
+        return modules;
+    }
+
+    protected override async Task CreateConfigAsync(string projectId, string environmentId, Module module, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await CreateOrUpdateModule(projectId, environmentId, module, cancellationToken);
+        }
+        catch (ApiException e)
+        {
+            m_Logger.LogError("Failed to create [{ConfigName}]. Error: {ErrorMsg}", module.Name, e.ErrorContent);
+            throw;
+        }
+
+        m_Logger.LogInformation("Module [{ConfigName}] successfully created", module.Name);
+    }
+
+    protected override async Task UpdateConfigAsync(string projectId, string environmentId, Module module, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await CreateOrUpdateModule(projectId, environmentId, module, cancellationToken);
+        }
+        catch (ApiException e)
+        {
+            m_Logger.LogError("Failed to update [{ConfigName}]. Error: {ErrorMsg}", module.Name, e.ErrorContent);
+            throw;
+        }
+
+        m_Logger.LogInformation("Script [{ConfigName}] successfully updated", module.Name);
+    }
+
+    protected override ImportExportEntry<Module> ToImportExportEntry(Module value)
+    {
+        return new ImportExportEntry<Module>(value.Name.GetHashCode(), value.Name.ToString(), value);
+    }
+
+    async Task CreateOrUpdateModule(
+        string projectId,
+        string environmentId,
+        Module module,
+        CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(module.Path))
+        {
+            throw new CliException("The module path provided is null or empty.", ExitCode.HandledError);
+        }
+
+        using var entry = m_ZipArchiver.GetEntry(m_ArchivePath!, module.Name.ToString());
+
+        if (entry == null)
+        {
+            throw new CliException($"Expected entry '{module.Name}' was not found in zip file.", ExitCode.UnhandledError);
+        }
+
+        using var stream = new MemoryStream();
+        await entry.Stream.CopyToAsync(stream, cancellationToken);
+        //after finishing the copy, reset the head of the stream so it can be sent
+        stream.Position = 0;
+        await m_CloudCodeService.UpdateModuleAsync(
+            projectId,
+            environmentId,
+            module.Name.ToString(),
+            stream,
+            cancellationToken);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/ModuleExportHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/ModuleExportHandler.cs
new file mode 100644
index 0000000..61f6232
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/ModuleExportHandler.cs
@@ -0,0 +1,20 @@
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Common.Console;
+
+namespace Unity.Services.Cli.CloudCode.Handlers.ImportExport.Modules;
+
+static class ModuleExportHandler
+{
+    internal const string k_LoadingIndicatorMessage = "Exporting your environment...";
+
+    public static async Task ExportAsync(
+        ExportInput exportInput,
+        CloudCodeModulesExporter? cloudCodeModulesExporter,
+        ILoadingIndicator loadingIndicator,
+        CancellationToken cancellationToken)
+    {
+        await loadingIndicator.StartLoadingAsync(
+            k_LoadingIndicatorMessage,
+            _ => cloudCodeModulesExporter!.ExportAsync(exportInput, cancellationToken));
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/ModulesImportHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/ModulesImportHandler.cs
new file mode 100644
index 0000000..874d37e
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Modules/ModulesImportHandler.cs
@@ -0,0 +1,20 @@
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.Common.Console;
+
+namespace Unity.Services.Cli.CloudCode.Handlers.ImportExport.Modules;
+static class ModulesImportHandler
+{
+    internal const string k_LoadingIndicatorMessage = "Importing Cloud Code modules...";
+
+    public static async Task ImportAsync(
+        ImportInput importInput,
+        CloudCodeModulesImporter? modulesImporter,
+        ILoadingIndicator loadingIndicator,
+        CancellationToken cancellationToken
+    )
+    {
+        await loadingIndicator.StartLoadingAsync(
+            k_LoadingIndicatorMessage,
+            _ => modulesImporter!.ImportAsync(importInput, cancellationToken));
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/CloudCodeScriptsExporter.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/CloudCodeScriptsExporter.cs
new file mode 100644
index 0000000..f2b9703
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/CloudCodeScriptsExporter.cs
@@ -0,0 +1,50 @@
+using System.IO.Abstractions;
+using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.CloudCode.Deploy;
+using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.Cli.CloudCode.Utils;
+using Unity.Services.Cli.Common.Utils;
+
+namespace Unity.Services.Cli.CloudCode.Handlers.ImportExport.Scripts;
+
+class CloudCodeScriptsExporter : BaseExporter<CloudCodeScript>
+{
+    readonly ICloudCodeService m_CloudCodeService;
+
+    public CloudCodeScriptsExporter(
+        ICloudCodeService cloudCodeService,
+        IZipArchiver zipArchiver,
+        IUnityEnvironment unityEnvironment,
+        IFileSystem fileSystem,
+        ILogger logger)
+        : base(
+            zipArchiver,
+            unityEnvironment,
+            fileSystem,
+            logger)
+    {
+        m_CloudCodeService = cloudCodeService;
+    }
+
+    protected override string FileName => CloudCodeConstants.JavascriptZipName;
+    protected override string EntryName => CloudCodeConstants.ScriptsEntryName;
+    protected override async Task<IEnumerable<CloudCodeScript>> ListConfigsAsync(string projectId, string environmentId, CancellationToken cancellationToken)
+    {
+        var scriptResults = await m_CloudCodeService.ListAsync(
+            projectId, environmentId, cancellationToken);
+
+        var scriptNames = scriptResults.Select(s => s.Name);
+        var scriptsWithData = await ImportExportUtils.GetScriptDetails(projectId, environmentId, scriptNames, m_CloudCodeService, cancellationToken);
+        var scriptsWithDataArray = scriptsWithData as CloudCodeScript[] ?? scriptsWithData.ToArray();
+
+        return scriptsWithDataArray;
+    }
+
+    protected override ImportExportEntry<CloudCodeScript> ToImportExportEntry(CloudCodeScript value)
+    {
+        return new ImportExportEntry<CloudCodeScript>(value.Name.GetHashCode(), value.Name.ToString(), value);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/CloudCodeScriptsImporter.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/CloudCodeScriptsImporter.cs
new file mode 100644
index 0000000..fde0304
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/CloudCodeScriptsImporter.cs
@@ -0,0 +1,152 @@
+using System.Net.Http.Json;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Import;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.CloudCode.Deploy;
+using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.Cli.CloudCode.Utils;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Client;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
+using Language = Unity.Services.Gateway.CloudCodeApiV1.Generated.Model.Language;
+
+namespace Unity.Services.Cli.CloudCode.Handlers.ImportExport.Scripts;
+
+class CloudCodeScriptsImporter : BaseImporter<CloudCodeScript>
+{
+    internal const long ScriptAlreadyActive = 9018;
+    readonly ICloudCodeService m_CloudCodeService;
+
+    public CloudCodeScriptsImporter(
+        ICloudCodeService cloudCodeService,
+        IZipArchiver zipArchiver,
+        IUnityEnvironment unityEnvironment,
+        ILogger logger)
+        : base(
+        zipArchiver,
+        unityEnvironment,
+        logger)
+    {
+        m_CloudCodeService = cloudCodeService;
+    }
+
+    protected override string FileName => CloudCodeConstants.JavascriptZipName;
+    protected override string EntryName => CloudCodeConstants.ScriptsEntryName;
+
+    protected override async Task DeleteConfigAsync(
+        string projectId,
+        string environmentId,
+        CloudCodeScript script,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            await m_CloudCodeService.DeleteAsync(
+                projectId,
+                environmentId,
+                script.Name.ToString(),
+                cancellationToken);
+        }
+        catch (ApiException e)
+        {
+            throw new CliException($"Failed to delete [{script.Name}]. ", e, ExitCode.HandledError);
+        }
+
+        m_Logger.LogInformation("{Name} successfully deleted", script.Name);
+    }
+
+    protected override async Task<IEnumerable<CloudCodeScript>> ListConfigsAsync(
+        string cloudProjectId,
+        string environmentId,
+        CancellationToken cancellationToken)
+    {
+        var scriptsOnRemote = await m_CloudCodeService.ListAsync(
+            cloudProjectId,
+            environmentId,
+            cancellationToken
+        );
+
+        var scriptNames = scriptsOnRemote.Select(s => s.Name);
+        var scriptsWithData = await ImportExportUtils.GetScriptDetails(cloudProjectId, environmentId, scriptNames, m_CloudCodeService, cancellationToken);
+        var scriptsWithDataArray = scriptsWithData as CloudCodeScript[] ?? scriptsWithData.ToArray();
+        return scriptsWithDataArray;
+    }
+
+    protected override async Task CreateConfigAsync(string projectId, string environmentId, CloudCodeScript script, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var parameters = ImportExportUtils.ConvertAuthoringParamsToParams(script.Parameters);
+            await m_CloudCodeService.CreateAsync(
+                projectId,
+                environmentId,
+                script.Name.ToString(),
+                ScriptType.API,
+                Language.JS,
+                script.Body,
+                parameters,
+                cancellationToken);
+            await m_CloudCodeService.PublishAsync(projectId, environmentId, script.Name.ToString(), 0,
+                cancellationToken);
+        }
+        catch (ApiException e)
+        {
+            var supress = ShouldSuppressException(e);
+            if (!supress)
+                throw new CliException($"Failed to create [{script.Name}]. ", e, ExitCode.HandledError);
+        }
+
+        m_Logger.LogInformation("Script [{ConfigName}] successfully created", script.Name);
+    }
+
+    protected override async Task UpdateConfigAsync(string projectId, string environmentId, CloudCodeScript script, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var parameters = ImportExportUtils.ConvertAuthoringParamsToParams(script.Parameters);
+            await m_CloudCodeService.UpdateAsync(
+                projectId,
+                environmentId,
+                script.Name.ToString(),
+                script.Body,
+                parameters,
+                cancellationToken);
+            await m_CloudCodeService.PublishAsync(projectId, environmentId, script.Name.ToString(), 0,
+                cancellationToken);
+        }
+        catch (ApiException e)
+        {
+            var supress = ShouldSuppressException(e);
+            if (!supress)
+                throw new CliException($"Failed to update [{script.Name}]. ", e, ExitCode.HandledError);
+        }
+
+        m_Logger.LogInformation("Script [{ConfigName}] successfully updated", script.Name);
+    }
+
+    static bool ShouldSuppressException(ApiException e)
+    {
+        var wasAlreadyPublished = false;
+        if (e.ErrorContent is string errContent)
+        {
+            var errDetails = JsonConvert.DeserializeObject<JObject>(errContent)!;
+            var code = errDetails["code"]?.Value<long>() ?? 0;
+            if (code == ScriptAlreadyActive)
+            {
+                wasAlreadyPublished = true;
+            }
+        }
+
+        return wasAlreadyPublished;
+    }
+
+    protected override ImportExportEntry<CloudCodeScript> ToImportExportEntry(CloudCodeScript value)
+    {
+        return new ImportExportEntry<CloudCodeScript>(value.Name.GetHashCode(), value.Name.ToString(), value);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ExportHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ExportHandler.cs
new file mode 100644
index 0000000..e21b5fa
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ExportHandler.cs
@@ -0,0 +1,20 @@
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Common.Console;
+
+namespace Unity.Services.Cli.CloudCode.Handlers.ImportExport.Scripts;
+
+static class ExportHandler
+{
+    internal const string k_LoadingIndicatorMessage = "Exporting your environment...";
+
+    public static async Task ExportAsync(
+        ExportInput exportInput,
+        CloudCodeScriptsExporter? cloudCodeScriptsExporter,
+        ILoadingIndicator loadingIndicator,
+        CancellationToken cancellationToken)
+    {
+        await loadingIndicator.StartLoadingAsync(
+            k_LoadingIndicatorMessage,
+            _ => cloudCodeScriptsExporter!.ExportAsync(exportInput, cancellationToken));
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ImportExportUtils.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ImportExportUtils.cs
new file mode 100644
index 0000000..3fbea5a
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ImportExportUtils.cs
@@ -0,0 +1,62 @@
+using Unity.Services.Cli.CloudCode.Deploy;
+using Unity.Services.Cli.CloudCode.Service;
+using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
+
+namespace Unity.Services.Cli.CloudCode.Handlers.ImportExport.Scripts;
+
+static class ImportExportUtils
+{
+    public static async Task<IEnumerable<CloudCodeScript>> GetScriptDetails(
+        string projectId,
+        string environmentId,
+        IEnumerable<String> scriptNames,
+        ICloudCodeService cloudCodeService,
+        CancellationToken cancellationToken)
+    {
+        var scriptsWithData = new List<CloudCodeScript>();
+        foreach (var scriptName in scriptNames)
+        {
+            var remoteScript = await cloudCodeService.GetAsync(
+                projectId, environmentId, scriptName, cancellationToken);
+            var newScriptFromRemote = new CloudCodeScript(remoteScript);
+            scriptsWithData.Add(newScriptFromRemote);
+        }
+
+        return scriptsWithData;
+    }
+
+    public static IReadOnlyList<ScriptParameter> ConvertAuthoringParamsToParams(List<CloudCodeParameter> parameters)
+    {
+        // convert parameters to CLI parameters
+        var cliParameters = new List<ScriptParameter>();
+        foreach (var parameter in parameters)
+        {
+            cliParameters.Add(new ScriptParameter(
+                parameter.Name,
+                ConvertTypeOptionsToParamType(parameter.ParameterType),
+                parameter.Required));
+        }
+
+        return cliParameters;
+    }
+
+    static ScriptParameter.TypeEnum ConvertTypeOptionsToParamType(ParameterType parameterType)
+    {
+        switch (parameterType)
+        {
+            case ParameterType.String:
+                return ScriptParameter.TypeEnum.STRING;
+            case ParameterType.Numeric:
+                return ScriptParameter.TypeEnum.NUMERIC;
+            case ParameterType.Boolean:
+                return ScriptParameter.TypeEnum.BOOLEAN;
+            case ParameterType.JSON:
+                return ScriptParameter.TypeEnum.JSON;
+            case ParameterType.Any:
+                return ScriptParameter.TypeEnum.ANY;
+        }
+
+        return default;
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ImportHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ImportHandler.cs
new file mode 100644
index 0000000..29dae3b
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ImportHandler.cs
@@ -0,0 +1,20 @@
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.Common.Console;
+
+namespace Unity.Services.Cli.CloudCode.Handlers.ImportExport.Scripts;
+
+static class ImportHandler
+{
+    internal const string k_LoadingIndicatorMessage = "Importing Cloud Code scripts...";
+
+    public static async Task ImportAsync(
+        ImportInput importInput,
+        CloudCodeScriptsImporter? scriptsImporter,
+        ILoadingIndicator loadingIndicator,
+        CancellationToken cancellationToken)
+    {
+        await loadingIndicator.StartLoadingAsync(
+            k_LoadingIndicatorMessage,
+            _ => scriptsImporter!.ImportAsync(importInput, cancellationToken));
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ScriptExportHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ScriptExportHandler.cs
new file mode 100644
index 0000000..c27171b
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ImportExport/Scripts/ScriptExportHandler.cs
@@ -0,0 +1,20 @@
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Common.Console;
+
+namespace Unity.Services.Cli.CloudCode.Handlers.ImportExport.Scripts;
+
+static class ScriptExportHandler
+{
+    internal const string k_LoadingIndicatorMessage = "Exporting your environment...";
+
+    public static async Task ExportAsync(
+        ExportInput exportInput,
+        CloudCodeScriptsExporter? cloudCodeScriptsExporter,
+        ILoadingIndicator loadingIndicator,
+        CancellationToken cancellationToken)
+    {
+        await loadingIndicator.StartLoadingAsync(
+            k_LoadingIndicatorMessage,
+            _ => cloudCodeScriptsExporter!.ExportAsync(exportInput, cancellationToken));
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ListHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ListHandler.cs
index 78ce88b..43d3cd8 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ListHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ListHandler.cs
@@ -1,4 +1,5 @@
 using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.CloudCode.Model;
 using Unity.Services.Cli.CloudCode.Service;
 using Unity.Services.Cli.Common.Console;
 using Unity.Services.Cli.Common.Input;
@@ -34,7 +35,9 @@ internal static async Task ListAsync(
         var scripts = await cloudCodeService.ListAsync(
             projectId, environmentId, cancellationToken);
 
-        var result = scripts.Select(s => s.Name);
+        var result = scripts
+            .Select(s => new CloudListScriptResult(s.Name, s.LastPublishedDate) )
+            .ToList();
 
         logger.LogResultValue(result);
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ListModulesHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ListModulesHandler.cs
index 10943dd..f4d9c65 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ListModulesHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/ListModulesHandler.cs
@@ -1,4 +1,5 @@
 using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.CloudCode.Model;
 using Unity.Services.Cli.CloudCode.Service;
 using Unity.Services.Cli.Common.Console;
 using Unity.Services.Cli.Common.Exceptions;
@@ -37,7 +38,9 @@ internal static async Task ListModulesAsync(
         var modules = await cloudCodeService
             .ListModulesAsync(projectId, environmentId, cancellationToken);
 
-        var result = modules.Select(m => m.Name);
+        var result = modules
+            .Select(m => new CloudListModuleResult(m.Name, m.DateModified))
+            .ToList();
 
         logger.LogResultValue(result);
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/UpdateHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/UpdateHandler.cs
index 34ba18a..1a0fa5d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/UpdateHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Handlers/UpdateHandler.cs
@@ -39,9 +39,16 @@ internal static async Task UpdateAsync(
 
         loadingContext?.Status("Loading script...");
         var code = await cloudCodeInputParser.LoadScriptCodeAsync(input, cancellationToken);
-        var parameters = await cloudCodeInputParser.CloudCodeScriptParser.ParseScriptParametersAsync(code, cancellationToken);
+        var parametersParsingResult = await cloudCodeInputParser.CloudCodeScriptParser
+            .ParseScriptParametersAsync(code, cancellationToken);
         loadingContext?.Status("Uploading script...");
-        await cloudCodeService.UpdateAsync(projectId, environmentId, input.ScriptName, code, parameters, CancellationToken.None);
+        await cloudCodeService.UpdateAsync(
+            projectId,
+            environmentId,
+            input.ScriptName,
+            code,
+            parametersParsingResult.Parameters,
+            CancellationToken.None);
 
         logger.LogInformation("Script '{scriptName}' updated.", input.ScriptName);
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/ActiveScriptOutput.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/ActiveScriptOutput.cs
index 3814749..8290b2c 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/ActiveScriptOutput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/ActiveScriptOutput.cs
@@ -1,3 +1,4 @@
+using System.Globalization;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
 
 namespace Unity.Services.Cli.CloudCode.Model;
@@ -5,7 +6,7 @@ namespace Unity.Services.Cli.CloudCode.Model;
 public class ActiveScriptOutput
 {
     public int Version { get; }
-    public DateTime DatePublished { get; }
+    public string DatePublished { get; }
     public List<ScriptParameter> Params { get; }
     public string Code { get; }
 
@@ -13,11 +14,12 @@ public ActiveScriptOutput()
     {
         Code = String.Empty;
         Params = new List<ScriptParameter>();
+        DatePublished = String.Empty;
     }
     public ActiveScriptOutput(GetScriptResponseActiveScript activeScript)
     {
         Version = activeScript._Version;
-        DatePublished = activeScript.DatePublished;
+        DatePublished = activeScript.DatePublished.ToString("s", CultureInfo.InvariantCulture);
         Params = activeScript.Params;
         Code = activeScript.Code;
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/CloudListModuleResult.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/CloudListModuleResult.cs
new file mode 100644
index 0000000..4957414
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/CloudListModuleResult.cs
@@ -0,0 +1,11 @@
+using System.Globalization;
+
+namespace Unity.Services.Cli.CloudCode.Model;
+
+public record CloudListModuleResult(string Name, DateTime? DateModified)
+{
+    public override string ToString()
+    {
+        return $"{Name} -  Date Modified: {DateModified?.ToString("s", CultureInfo.InvariantCulture) ?? "Never"}";
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/CloudListScriptResult.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/CloudListScriptResult.cs
new file mode 100644
index 0000000..6a31db0
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/CloudListScriptResult.cs
@@ -0,0 +1,11 @@
+using System.Globalization;
+
+namespace Unity.Services.Cli.CloudCode.Model;
+
+public record CloudListScriptResult(string Name, DateTime? DatePublished)
+{
+    public override string ToString()
+    {
+        return $"{Name} -  Date Created: {DatePublished?.ToString("s", CultureInfo.InvariantCulture) ?? "Never"}";
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/DeletedCloudCode.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/DeletedCloudCode.cs
new file mode 100644
index 0000000..cf4b813
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/DeletedCloudCode.cs
@@ -0,0 +1,15 @@
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.DeploymentApi.Editor;
+
+namespace Unity.Services.Cli.CloudCode.Model;
+
+class DeletedCloudCode : DeployContent
+{
+    public DeletedCloudCode(string name, string type, string path, float progress = 0, DeploymentStatus? status = null)
+        : base(name, type, path, progress, status) { }
+
+    public override string ToString()
+    {
+        return $"'{Name}' - Deleted Remotely";
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/GetModuleResponseOutput.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/GetModuleResponseOutput.cs
index 37c9a2a..fdce59b 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/GetModuleResponseOutput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/GetModuleResponseOutput.cs
@@ -5,7 +5,7 @@
 
 namespace Unity.Services.Cli.CloudCode.Model;
 
-internal class GetModuleResponseOutput
+class GetModuleResponseOutput
 {
     public string Name { get; }
     public Language Language { get; }
@@ -16,8 +16,8 @@ public GetModuleResponseOutput(GetModuleResponse response)
     {
         Name = response.Name;
         Language = response.Language;
-        DateModified = TruncateDate(response.DateModified);
-        DateCreated = TruncateDate(response.DateCreated);
+        DateModified = response.DateModified.ToString("s", CultureInfo.InvariantCulture);
+        DateCreated = response.DateCreated.ToString("s", CultureInfo.InvariantCulture);
     }
 
     public override string ToString()
@@ -28,9 +28,4 @@ public override string ToString()
             .Build();
         return serializer.Serialize(this);
     }
-
-    static String TruncateDate(DateTime dateTime)
-    {
-        return dateTime.ToString("yyyy-MM-dd'T'HH:mm:ss.FFFK", CultureInfo.InvariantCulture);
-    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/GetScriptResponseOutput.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/GetScriptResponseOutput.cs
index 9d10ceb..438c89d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/GetScriptResponseOutput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/GetScriptResponseOutput.cs
@@ -4,7 +4,7 @@
 
 namespace Unity.Services.Cli.CloudCode.Model;
 
-internal class GetScriptResponseOutput
+class GetScriptResponseOutput
 {
     public string Name { get; }
     public Language Language { get; }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/ParseScriptParametersResult.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/ParseScriptParametersResult.cs
new file mode 100644
index 0000000..643c147
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Model/ParseScriptParametersResult.cs
@@ -0,0 +1,17 @@
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
+
+namespace Unity.Services.Cli.CloudCode.Model;
+
+
+public class ParseScriptParametersResult
+{
+    public bool ScriptContainsParametersJson { get; }
+    public IReadOnlyList<ScriptParameter> Parameters { get; }
+
+    public ParseScriptParametersResult(bool scriptContainsParametersJson, IReadOnlyList<ScriptParameter> parameters)
+    {
+        ScriptContainsParametersJson = scriptContainsParametersJson;
+        Parameters = parameters;
+    }
+}
+
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/CloudCodeScriptParser.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/CloudCodeScriptParser.cs
index 0cfcc1e..cf904af 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/CloudCodeScriptParser.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/CloudCodeScriptParser.cs
@@ -1,6 +1,7 @@
 using System.IO.Abstractions;
 using System.Reflection;
 using Unity.Services.Cli.CloudCode.Exceptions;
+using Unity.Services.Cli.CloudCode.Model;
 using Unity.Services.Cli.Common.Process;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
 using Unity.Services.Cli.Common.Utils;
@@ -8,7 +9,7 @@
 
 namespace Unity.Services.Cli.CloudCode.Parameters;
 
-internal class CloudCodeScriptParser : ICloudCodeScriptParser
+class CloudCodeScriptParser : ICloudCodeScriptParser
 {
     const int k_ParsingTimeLimitInMillisecond = 5000;
     const int k_MemorySizeLimitInMB = 256;
@@ -46,16 +47,17 @@ async Task CreateScriptParameterParserAsync(CancellationToken token)
         }
     }
 
-    public async Task<IReadOnlyList<ScriptParameter>> ParseScriptParametersAsync(string scriptCode, CancellationToken cancellationToken)
+    public async Task<ParseScriptParametersResult> ParseScriptParametersAsync(string scriptCode, CancellationToken cancellationToken)
     {
         var parameterInJson = await ParseToScriptParamsJsonAsync(scriptCode, cancellationToken);
         var parameters = new List<ScriptParameter>();
+
         if (parameterInJson is not null)
         {
             parameters = m_CloudScriptParametersParser.ParseToScriptParameters(parameterInJson);
         }
 
-        return parameters;
+        return new ParseScriptParametersResult(!string.IsNullOrEmpty(parameterInJson), parameters);
     }
 
     internal async Task<string?> ParseToScriptParamsJsonAsync(string scriptCode, CancellationToken token)
@@ -81,6 +83,7 @@ public async Task<IReadOnlyList<ScriptParameter>> ParseScriptParametersAsync(str
                 $"--max-old-space-size={k_MemorySizeLimitInMB}",
                 k_ParameterScriptFile
             }, parseTimeoutTokenSource.Token, writeToStandardInput: WriteToProcessStandardInput);
+
             paramString = paramString.Replace(System.Environment.NewLine, "");
             return string.IsNullOrEmpty(paramString) ? null : paramString;
         }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/CloudScriptParametersParser.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/CloudScriptParametersParser.cs
index 1dd9c05..2e7b11b 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/CloudScriptParametersParser.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/CloudScriptParametersParser.cs
@@ -5,7 +5,7 @@
 
 namespace Unity.Services.Cli.CloudCode.Parameters;
 
-internal class CloudScriptParametersParser : ICloudScriptParametersParser
+class CloudScriptParametersParser : ICloudScriptParametersParser
 {
     struct EvaluatedParam
     {
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/ICloudCodeScriptParser.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/ICloudCodeScriptParser.cs
index 8dd6c00..9c75ff7 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/ICloudCodeScriptParser.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/ICloudCodeScriptParser.cs
@@ -1,3 +1,4 @@
+using Unity.Services.Cli.CloudCode.Model;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
 
 namespace Unity.Services.Cli.CloudCode.Parameters;
@@ -9,6 +10,6 @@ public interface ICloudCodeScriptParser
     /// </summary>
     /// <param name="scriptCode">script code</param>
     /// <param name="cancellationToken">token to cancel operation</param>
-    /// <returns>list of script parameters</returns>
-    Task<IReadOnlyList<ScriptParameter>> ParseScriptParametersAsync(string scriptCode, CancellationToken cancellationToken);
+    /// <returns>Result of the parameter parsing, containing a list of script parameters</returns>
+    Task<ParseScriptParametersResult> ParseScriptParametersAsync(string scriptCode, CancellationToken cancellationToken);
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/ICloudScriptParametersParser.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/ICloudScriptParametersParser.cs
index c9d8544..5382fd1 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/ICloudScriptParametersParser.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Parameters/ICloudScriptParametersParser.cs
@@ -2,7 +2,7 @@
 
 namespace Unity.Services.Cli.CloudCode.Parameters;
 
-internal interface ICloudScriptParametersParser
+interface ICloudScriptParametersParser
 {
     public List<ScriptParameter> ParseToScriptParameters(string parameterJsonString);
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Unity.Services.Cli.CloudCode.csproj b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Unity.Services.Cli.CloudCode.csproj
index fe030ec..83e534f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Unity.Services.Cli.CloudCode.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Unity.Services.Cli.CloudCode.csproj
@@ -22,13 +22,21 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Unity.Services.CloudCode.Authoring.Editor.Core" Version="0.4.0" />
-    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.1.0" />
-    <PackageReference Include="YamlDotNet" Version="13.0.2" />
+    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.2.0" />
+    <PackageReference Include="YamlDotNet" Version="13.1.0" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="JavaScripts\script_parameters.js" />
     <EmbeddedResource Include="JavaScripts\script_template.js" />
   </ItemGroup>
+  <ItemGroup>
+    <Reference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated">
+      <HintPath>..\..\..\..\.nuget\packages\unity.services.gateway.cloudcodeapiv1.generated\1.1.1\lib\netstandard2.0\Unity.Services.Gateway.CloudCodeApiV1.Generated.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Handlers\ImportExport\Modules\" />
+  </ItemGroup>
   <PropertyGroup>
     <DefineConstants Condition=" '$(ExtraDefineConstants)' != '' ">$(DefineConstants);$(ExtraDefineConstants)</DefineConstants>
   </PropertyGroup>
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Utils/CloudCodeConstants.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Utils/CloudCodeConstants.cs
new file mode 100644
index 0000000..0a5cab8
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Utils/CloudCodeConstants.cs
@@ -0,0 +1,20 @@
+using Unity.Services.Cli.Common.Telemetry;
+
+namespace Unity.Services.Cli.CloudCode.Utils;
+
+static class CloudCodeConstants
+{
+    public const string ServiceType = "Cloud Code Scripts";
+    public const string ServiceTypeModules = "Cloud Code Modules";
+    public const string JavaScriptFileExtension = ".js";
+    public const string JavascriptZipName = "ugs-cc-scripts.jszip";
+    public const string SingleModuleFileExtension = ".ccm";
+    public const string ModulesZipName = "ugs.ccmzip";
+    internal static readonly string EntryName = $"__ugs-cli_{TelemetryConfigurationProvider.GetCliVersion()}";
+
+    internal static readonly string ModulesEntryName = "cloud-code modules";
+    internal static readonly string ScriptsEntryName = "cloud-code scripts";
+
+    internal static readonly string ServiceName = "cloud-code-scripts";
+    internal static readonly string ServiceNameModule = "cloud-code-modules";
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Utils/CloudCodeScriptParserExtensions.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Utils/CloudCodeScriptParserExtensions.cs
index db46cf8..1f41c64 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Utils/CloudCodeScriptParserExtensions.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Utils/CloudCodeScriptParserExtensions.cs
@@ -1,7 +1,6 @@
 using Unity.Services.Cli.CloudCode.Exceptions;
 using Unity.Services.Cli.CloudCode.Parameters;
 using Unity.Services.CloudCode.Authoring.Editor.Core.Model;
-using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
 
 namespace Unity.Services.Cli.CloudCode;
 
@@ -9,21 +8,22 @@ static class CloudCodeScriptParserExtensions
 {
     internal const string ErrorMessageFormat = "Script {0} threw:{1}\"{2}\".";
 
-    public static async Task<(bool HasParameters, string? ErrorMessage)> TryParseScriptParametersAsync(
-        this ICloudCodeScriptParser self, IScript script, CancellationToken token)
+    public static async Task<(bool HasParameters, string? ErrorMessage)>
+        TryParseScriptParametersAsync(this ICloudCodeScriptParser self, IScript script, CancellationToken token)
     {
-        IReadOnlyList<ScriptParameter>? scriptParams;
         string? errorMessage = null;
+        bool scriptContainsParametersJson = false;
+
         try
         {
-            scriptParams = await self.ParseScriptParametersAsync(script.Body, token);
+            var paramsParsingResponse = await self.ParseScriptParametersAsync(script.Body, token);
+            scriptContainsParametersJson = paramsParsingResponse.ScriptContainsParametersJson;
         }
         catch (ScriptEvaluationException e)
         {
             errorMessage = string.Format(ErrorMessageFormat, script.Name.ToString(), System.Environment.NewLine, e.Message);
-            scriptParams = null;
         }
 
-        return ((scriptParams is not null) && (scriptParams.Count > 0), errorMessage);
+        return (scriptContainsParametersJson, errorMessage);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Utils/Constants.cs b/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Utils/Constants.cs
deleted file mode 100644
index 1ca8a5d..0000000
--- a/Unity.Services.Cli/Unity.Services.Cli.CloudCode/Utils/Constants.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-namespace Unity.Services.Cli.CloudCode;
-
-// TODO: Reuse throughout the module
-static class Constants
-{
-    public const string ServiceType = "Cloud Code";
-
-    public const string JavaScriptFileExtension = ".js";
-}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Batching/BatchingTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Batching/BatchingTests.cs
new file mode 100644
index 0000000..5131007
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Batching/BatchingTests.cs
@@ -0,0 +1,124 @@
+using NUnit.Framework;
+
+namespace Unity.Services.Cli.Common.UnitTest.Batching;
+
+using Unity.Services.ModuleTemplate.Authoring.Core.Batching;
+
+[TestFixture]
+public class BatchingTests
+{
+    readonly object m_BatchItemInvokeCountLock = new();
+    int m_BatchItemInvokeCount;
+    const int k_BatchSize = 2;
+    const double k_SecondsDelay = 0;
+    const int k_IntReturnValue = 1;
+
+    [TearDown]
+    public void TearDown()
+    {
+        m_BatchItemInvokeCount = 0;
+    }
+
+    [Test]
+    public void ExecuteFuncNoResultBatchAsyncHandlesExceptionsCorrectly()
+    {
+        List<Func<Task>> delegates = new List<Func<Task>>
+        {
+            AsyncTaskWithoutReturnValueThrows,
+            AsyncTaskWithoutReturnValueThrows,
+            AsyncTaskWithoutReturnValueThrows
+        };
+
+        var exception = Assert.ThrowsAsync<AggregateException>(
+            async () => await Batching.ExecuteInBatchesAsync(
+                delegates,
+                CancellationToken.None, k_BatchSize, k_SecondsDelay));
+
+        Assert.AreEqual(
+            delegates.Count,
+            exception?.InnerExceptions.Count);
+
+        async Task AsyncTaskWithoutReturnValueThrows()
+        {
+            await Task.CompletedTask;
+            throw new Exception();
+        }
+    }
+
+    [Test]
+    public void ExecuteFuncResultBatchAsyncHandlesExceptionsCorrectly()
+    {
+        List<Func<Task<int>>> delegates = new List<Func<Task<int>>>
+        {
+            AsyncTaskWithReturnValueThrows,
+            AsyncTaskWithReturnValueThrows,
+            AsyncTaskWithReturnValueThrows
+        };
+
+        var exception = Assert.ThrowsAsync<AggregateException>(
+            async () => await Batching.ExecuteInBatchesAsync(
+                delegates,
+                CancellationToken.None, k_BatchSize, k_SecondsDelay));
+
+        Assert.AreEqual(
+            delegates.Count,
+            exception?.InnerExceptions.Count);
+
+        async Task<int> AsyncTaskWithReturnValueThrows()
+        {
+            await Task.CompletedTask;
+            throw new Exception();
+        }
+    }
+
+    [Test]
+    public async Task ExecuteFuncNoResultBatchesAsyncInvokesAction()
+    {
+        List<Func<Task>> delegates = new List<Func<Task>>
+        {
+            AsyncTaskWithoutReturnValue,
+            AsyncTaskWithoutReturnValue,
+            AsyncTaskWithoutReturnValue
+        };
+
+        await Batching.ExecuteInBatchesAsync(delegates,
+            CancellationToken.None, k_BatchSize, k_SecondsDelay);
+
+        Assert.AreEqual(delegates.Count, m_BatchItemInvokeCount);
+
+        async Task AsyncTaskWithoutReturnValue()
+        {
+            lock (m_BatchItemInvokeCountLock)
+            {
+                m_BatchItemInvokeCount++;
+            }
+            await Task.CompletedTask;
+        }
+    }
+
+    [Test]
+    public async Task ExecuteFuncResultBatchesAsyncInvokesAction()
+    {
+        List<Func<Task<int>>> delegates = new List<Func<Task<int>>>
+        {
+            AsyncTaskWithReturnValue,
+            AsyncTaskWithReturnValue,
+            AsyncTaskWithReturnValue
+        };
+
+        await Batching.ExecuteInBatchesAsync(delegates,
+            CancellationToken.None, k_BatchSize, k_SecondsDelay);
+
+        Assert.AreEqual(delegates.Count, m_BatchItemInvokeCount);
+
+        async Task<int> AsyncTaskWithReturnValue()
+        {
+            lock (m_BatchItemInvokeCountLock)
+            {
+                m_BatchItemInvokeCount++;
+            }
+            await Task.CompletedTask;
+            return k_IntReturnValue;
+        }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Exceptions/ExceptionHelperTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Exceptions/ExceptionHelperTests.cs
index f216426..fde8c37 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Exceptions/ExceptionHelperTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Exceptions/ExceptionHelperTests.cs
@@ -59,62 +59,100 @@ public void HandleApiException(Exception exception)
     }
 
     [Test]
-    public void HandleCliException()
+    public void HandleHandledCliException()
     {
-        var expectedExitCode = -5;
+        var expectedExitCode = ExitCode.HandledError;
+        var errorMessage = "my error";
         Assert.DoesNotThrow(
             () => m_ExceptionHelper!.HandleException(
-                new CliException(expectedExitCode),
+                new CliException(errorMessage, ExitCode.HandledError),
                 k_MockHelper.MockLogger.Object, m_Context!));
-        TestsHelper.VerifyLoggerWasCalled(k_MockHelper.MockLogger, LogLevel.Error);
+        TestsHelper.VerifyLoggerWasCalled(k_MockHelper.MockLogger, LogLevel.Error, null, Times.Once, errorMessage);
+        k_MockAnsiConsole.Verify(ex => ex.Write(It.IsAny<IRenderable>()), Times.Never);
         Assert.AreEqual(expectedExitCode, m_Context!.ExitCode);
     }
 
     [Test]
-    public void HandleUnhandledException()
+    public void HandleUnhandledCliException()
     {
         var expectedExitCode = ExitCode.UnhandledError;
+        var exception = new Exception();
         Assert.DoesNotThrow(
             () => m_ExceptionHelper!.HandleException(
-                new CookieException(),
+                exception,
                 k_MockHelper.MockLogger.Object, m_Context!));
-        k_MockAnsiConsole.Verify(ex => ex.Write(It.IsAny<IRenderable>()));
+        TestsHelper.VerifyLoggerWasCalled(k_MockHelper.MockLogger, LogLevel.Error, null, Times.Never);
+        k_MockAnsiConsole.Verify(ex => ex.Write(It.IsAny<IRenderable>()), Times.Once);
         Assert.AreEqual(expectedExitCode, m_Context!.ExitCode);
     }
 
     [Test]
-    public void HandleAggregateExceptionWithUnhandled()
+    public void HandleAggregateExceptionWithOnlyHandledExceptions()
     {
-        var exceptions = new List<Exception>()
+        var expectedExitCode = ExitCode.HandledError;
+        var exception = new CliException(ExitCode.HandledError);
+
+        var exceptions = new List<Exception>
         {
-            new CookieException(),
-            new CliException("test", 1)
+            exception,
+            exception
         };
-        // var aggregateException = new
-        var expectedExitCode = ExitCode.UnhandledError;
+
         Assert.DoesNotThrow(
             () => m_ExceptionHelper!.HandleException(
                 new AggregateException(exceptions),
                 k_MockHelper.MockLogger.Object, m_Context!));
-        k_MockAnsiConsole.Verify(ex => ex.Write(It.IsAny<IRenderable>()));
+
+        k_MockHelper.MockLogger.Verify(x => x.Log(
+            LogLevel.Error,
+            It.IsAny<EventId>(),
+            It.IsAny<It.IsAnyType>(),
+            It.IsAny<Exception>(),
+            It.Is<Func<It.IsAnyType, Exception?, string>>((o, t) => true)),
+            Times.Exactly(exceptions.Count));
+
+        k_MockAnsiConsole.Verify(ex => ex.Write(It.IsAny<IRenderable>()), Times.Never);
         Assert.AreEqual(expectedExitCode, m_Context!.ExitCode);
     }
 
     [Test]
-    public void HandleAggregateExceptionWithoutUnhandled()
+    public void HandleAggregateExceptionWithHandledAndUnhandledExceptions()
     {
-        var exceptions = new List<Exception>()
+        var expectedExitCode = ExitCode.UnhandledError;
+
+        var exceptions = new List<Exception>
         {
-            new MissingConfigurationException("test", 1),
-            new CliException("test2", 1)
+            new CliException(ExitCode.HandledError),
+            new (),
+            new ()
         };
-        // var aggregateException = new
-        var expectedExitCode = ExitCode.HandledError;
+
         Assert.DoesNotThrow(
             () => m_ExceptionHelper!.HandleException(
                 new AggregateException(exceptions),
                 k_MockHelper.MockLogger.Object, m_Context!));
-        k_MockAnsiConsole.Verify(ex => ex.Write(It.IsAny<IRenderable>()), Times.Never);
+
+        k_MockHelper.MockLogger.Verify(x => x.Log(
+                LogLevel.Error,
+                It.IsAny<EventId>(),
+                It.IsAny<It.IsAnyType>(),
+                It.IsAny<Exception>(),
+                It.Is<Func<It.IsAnyType, Exception?, string>>((o, t) => true)),
+            Times.Exactly(1));
+
+        k_MockAnsiConsole.Verify(ex => ex.Write(It.IsAny<IRenderable>()), Times.Once);
+        Assert.AreEqual(expectedExitCode, m_Context!.ExitCode);
+    }
+
+    [Test]
+    public void HandleUnhandledException()
+    {
+        var expectedExitCode = ExitCode.UnhandledError;
+        Assert.DoesNotThrow(
+            () => m_ExceptionHelper!.HandleException(
+                new CookieException(),
+                k_MockHelper.MockLogger.Object, m_Context!));
+        k_MockAnsiConsole.Verify(ex => ex.Write(It.IsAny<IRenderable>()));
         Assert.AreEqual(expectedExitCode, m_Context!.ExitCode);
     }
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Handlers/DeleteHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Handlers/DeleteHandlerTests.cs
index 24f356f..147065f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Handlers/DeleteHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Handlers/DeleteHandlerTests.cs
@@ -69,7 +69,7 @@ public void DeleteAsync_HavingNoOptionSpecifiedThrows()
     }
 
     [Test]
-    public void DeleteAsync_CallsConfigurationAndLogsAllKeysDeleted()
+    public async Task DeleteAsync_CallsConfigurationAndLogsAllKeysDeleted()
     {
         ConfigurationInput input = new ConfigurationInput
         {
@@ -77,7 +77,7 @@ public void DeleteAsync_CallsConfigurationAndLogsAllKeysDeleted()
             UseForce = true
         };
 
-        DeleteHandler.DeleteAsync(input, mockHelper.MockConfiguration.Object,
+        await DeleteHandler.DeleteAsync(input, mockHelper.MockConfiguration.Object,
             mockHelper.MockLogger.Object, m_MockSystemEnvironmentProvider.Object, CancellationToken.None);
 
         TestsHelper.VerifyLoggerWasCalled(mockHelper.MockLogger, LogLevel.Information, null, null,
@@ -88,7 +88,7 @@ public void DeleteAsync_CallsConfigurationAndLogsAllKeysDeleted()
     }
 
     [Test]
-    public void DeleteAsync_CallsConfigurationAndLogsSpecifiedKeysDeleted()
+    public async Task DeleteAsync_CallsConfigurationAndLogsSpecifiedKeysDeleted()
     {
         ConfigurationInput input = new ConfigurationInput
         {
@@ -96,7 +96,7 @@ public void DeleteAsync_CallsConfigurationAndLogsSpecifiedKeysDeleted()
             UseForce = true
         };
 
-        DeleteHandler.DeleteAsync(input, mockHelper.MockConfiguration.Object,
+        await DeleteHandler.DeleteAsync(input, mockHelper.MockConfiguration.Object,
             mockHelper.MockLogger.Object, m_MockSystemEnvironmentProvider.Object, CancellationToken.None);
 
         TestsHelper.VerifyLoggerWasCalled(mockHelper.MockLogger, LogLevel.Information, null, null,
@@ -107,7 +107,7 @@ public void DeleteAsync_CallsConfigurationAndLogsSpecifiedKeysDeleted()
     }
 
     [Test]
-    public void DeleteAsync_ChecksEnvironmentVariablesAndLogsWarningWhenValueStillSetInEnvironmentVariables()
+    public async Task DeleteAsync_ChecksEnvironmentVariablesAndLogsWarningWhenValueStillSetInEnvironmentVariables()
     {
         ConfigurationInput input = new ConfigurationInput
         {
@@ -119,7 +119,7 @@ public void DeleteAsync_ChecksEnvironmentVariablesAndLogsWarningWhenValueStillSe
         m_MockSystemEnvironmentProvider.Setup(ex => ex
             .GetSystemEnvironmentVariable(It.IsAny<string>(), out errorMsg)).Returns("value");
 
-        DeleteHandler.DeleteAsync(input, mockHelper.MockConfiguration.Object,
+        await DeleteHandler.DeleteAsync(input, mockHelper.MockConfiguration.Object,
             mockHelper.MockLogger.Object, m_MockSystemEnvironmentProvider.Object, CancellationToken.None);
 
         m_MockSystemEnvironmentProvider.Verify(ex => ex
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/JsonLoggerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/JsonLoggerTests.cs
index a79a36a..a388140 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/JsonLoggerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/JsonLoggerTests.cs
@@ -7,7 +7,7 @@ namespace Unity.Services.Cli.Common.UnitTest;
 [TestFixture]
 class JsonLoggerTests
 {
-    const string k_Message = "Message";
+    const string k_Result = "Message";
 
     readonly Logger m_Logger = new();
     LogMessageTestHelper? m_LogMessageTestHelper;
@@ -31,7 +31,7 @@ public void TearDown()
     [TestCase(LogLevel.Critical)]
     public void Log_CorrectInformationOutput(LogLevel level)
     {
-        m_Logger.Log(level, k_Message);
+        m_Logger.Log(level, k_Result);
         m_Logger.Write();
         var resultLogMessage = m_LogMessageTestHelper!.LogMessage;
         var messageList = new List<LogMessage>
@@ -39,24 +39,22 @@ public void Log_CorrectInformationOutput(LogLevel level)
             new()
             {
                 Name = "",
-                Message = k_Message,
+                Message = k_Result,
                 Type = level
             }
         };
-        var expectMessage =
-            LogMessageTestHelper.GetJsonLogMessage(messageList, null);
+        var expectMessage = LogMessageTestHelper.GetJsonLogFormatted(null, messageList);
         Assert.AreEqual(expectMessage, resultLogMessage);
     }
 
     [Test]
     public void LogResult_JsonResultOutput()
     {
-        m_Logger.LogResultValue(k_Message);
+        m_Logger.LogResultValue(k_Result);
         m_Logger.Write();
         var resultLogMessage = m_LogMessageTestHelper!.LogMessage;
         var messageList = new List<LogMessage>();
-        var expectMessage =
-            LogMessageTestHelper.GetJsonLogMessage(messageList, k_Message);
+        var expectMessage = LogMessageTestHelper.GetJsonLogFormatted(k_Result, messageList);
         Assert.AreEqual(expectMessage, resultLogMessage);
     }
 
@@ -64,8 +62,8 @@ public void LogResult_JsonResultOutput()
     public void Log_JsonResultAndInformationOutput()
     {
         var level = LogLevel.Information;
-        m_Logger.LogResultValue(k_Message);
-        m_Logger.Log(level, k_Message);
+        m_Logger.LogResultValue(k_Result);
+        m_Logger.Log(level, k_Result);
         m_Logger.Write();
         var resultLogMessage = m_LogMessageTestHelper!.LogMessage;
         var messageList = new List<LogMessage>
@@ -73,12 +71,11 @@ public void Log_JsonResultAndInformationOutput()
             new()
             {
                 Name = "",
-                Message = k_Message,
+                Message = k_Result,
                 Type = level
             }
         };
-        var expectMessage =
-            LogMessageTestHelper.GetJsonLogMessage(messageList, k_Message);
+        var expectMessage = LogMessageTestHelper.GetJsonLogFormatted(k_Result, messageList);
         Assert.AreEqual(expectMessage, resultLogMessage);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogFormatter/JsonLogFormatterTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogFormatter/JsonLogFormatterTests.cs
index 661a1ab..cc82022 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogFormatter/JsonLogFormatterTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogFormatter/JsonLogFormatterTests.cs
@@ -1,4 +1,5 @@
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
 using NUnit.Framework;
 using Unity.Services.Cli.Common.Logging;
 
@@ -18,7 +19,7 @@ public class JsonLogFormatterTests
             "result1",
             "result2"
         },
-        "test output"
+        "test result"
     };
 
     [SetUp]
@@ -27,7 +28,7 @@ public void SetUp()
         m_LogMessageTestHelper = new LogMessageTestHelper();
 
         m_Cache = new LogCache();
-        m_Formatter = new JsonLogFormatter();
+        m_Formatter = new JsonLogFormatter(System.Console.Out, System.Console.Error);
     }
 
     [TearDown]
@@ -43,8 +44,9 @@ public void WriteResult_OutputsStringOrStringListCorrectly(object result)
         m_Cache!.AddResult(result);
         m_Formatter!.WriteLog(m_Cache);
         var resultLogMessage = m_LogMessageTestHelper!.LogMessage;
-        var expectedLog = LogMessageTestHelper.GetJsonLogMessage(null, result);
-        Assert.AreEqual(expectedLog, resultLogMessage);
+        Assert.AreEqual(
+            JsonConvert.SerializeObject(result, Formatting.Indented) + System.Environment.NewLine,
+            resultLogMessage);
     }
 
     [TestCase(LogLevel.Information)]
@@ -61,10 +63,12 @@ public void WriteMessage_OutputsCorrectFormat(LogLevel level)
         };
         m_Cache!.AddMessage("TestMessage", level, "TestName");
         m_Formatter!.WriteLog(m_Cache);
+
         var resultLogMessage = m_LogMessageTestHelper!.LogMessage;
         List<LogMessage> messages = new List<LogMessage>();
         messages.Add(msgInfo);
-        var expectedLog = LogMessageTestHelper.GetJsonLogMessage(messages, null);
+        var expectedLog = LogMessageTestHelper.GetJsonLogFormatted(null, messages);
+
         Assert.AreEqual(expectedLog, resultLogMessage);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogFormatter/LogFormatterTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogFormatter/LogFormatterTests.cs
index a4da23b..0d71fe4 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogFormatter/LogFormatterTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogFormatter/LogFormatterTests.cs
@@ -16,7 +16,7 @@ public void SetUp()
     {
         m_LogMessageTestHelper = new LogMessageTestHelper();
         m_Cache = new LogCache();
-        m_Formatter = new Logging.LogFormatter();
+        m_Formatter = new Logging.LogFormatter(System.Console.Out, System.Console.Error);
     }
 
     [TearDown]
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogMessageTestHelper.cs b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogMessageTestHelper.cs
index a3089e7..14120e6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogMessageTestHelper.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Logging/LogMessageTestHelper.cs
@@ -9,42 +9,55 @@ class LogMessageTestHelper : IDisposable
     readonly StringWriter m_StringWriter;
 
     readonly TextWriter m_PreviousTextWriter;
+    readonly TextWriter m_PreviousErrorTextWriter;
 
     public string LogMessage => m_StringWriter.ToString();
 
     public LogMessageTestHelper()
     {
         m_PreviousTextWriter = System.Console.Out;
+        m_PreviousErrorTextWriter = System.Console.Error;
         m_StringWriter = new StringWriter();
         System.Console.SetOut(m_StringWriter);
+        System.Console.SetError(m_StringWriter);
     }
 
     public void Dispose()
     {
         System.Console.SetOut(m_PreviousTextWriter);
+        System.Console.SetError(m_PreviousErrorTextWriter);
         m_StringWriter.Close();
     }
 
-    public static string GetJsonLogMessage(List<LogMessage>? messages, object? result)
+    public static string GetJsonLogFormatted(object? result, List<LogMessage> logMessages)
     {
-        var jsonMessages = new List<JsonLogMessage>();
+        return GetJsonResult(result) + GetJsonLogMessage(logMessages);
+    }
+
+    static string GetJsonResult(object? result)
+    {
+        return JsonConvert.SerializeObject(result, Formatting.Indented) + System.Environment.NewLine;
+    }
 
-        if (messages != null)
+    static string GetJsonLogMessage(List<LogMessage> logMessages)
+    {
+        var messages = new List<JsonLogMessage>(logMessages.Capacity);
+        foreach (var message in logMessages)
         {
-            foreach (var message in messages)
+            messages.Add(new JsonLogMessage()
             {
-                jsonMessages.Add(new JsonLogMessage()
-                {
-                    Message = message.Message,
-                    Type = message.Type.ToString()
-                });
-            }
+                Message = message.Message,
+                Type = message.Type.ToString()
+            });
         }
 
-        return JsonConvert.SerializeObject(new
+        string result = "";
+        if (messages.Any())
         {
-            Result = result,
-            Messages = jsonMessages
-        }, Formatting.Indented) + System.Environment.NewLine;
+            result = JsonConvert.SerializeObject(messages, Formatting.Indented) + System.Environment.NewLine;
+
+        }
+
+        return result;
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Middleware/ContextBinderTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Middleware/ContextBinderTests.cs
index a8be99f..7b6251c 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Middleware/ContextBinderTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Middleware/ContextBinderTests.cs
@@ -29,7 +29,7 @@ class FakeService : IFakeService { }
     const int k_TestIntValue = 1234;
     const string k_TestStringValue = "TestString";
     const string k_Command = "test";
-    private const string k_GetConfigMockedReturnValue = "value-from-mocked-config";
+    const string k_GetConfigMockedReturnValue = "value-from-mocked-config";
 
     CommandLineBuilder? m_CommandLineBuilder;
     TestInput? m_TestInput;
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Policies/RetryPolicyTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Policies/RetryPolicyTests.cs
new file mode 100644
index 0000000..2bbb01d
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Policies/RetryPolicyTests.cs
@@ -0,0 +1,294 @@
+using System.Net;
+using NUnit.Framework;
+using RestSharp;
+using Unity.Services.Cli.Common.Policies;
+
+namespace Unity.Services.Cli.Common.UnitTest.Policies;
+
+[TestFixture]
+public class RetryPolicyTests
+{
+    const string k_BlankUri = "https://blank.org";
+    const string k_RetryAfterHeaderName = "Retry-After";
+    static readonly HttpStatusCode[] k_HttpStatusCodeCases = RetryPolicy.RetryHttpStatuses;
+    TestHttpMessageHandler? m_MessageHandler;
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_MessageHandler = new TestHttpMessageHandler();
+    }
+
+    class TestHttpMessageHandler : HttpMessageHandler
+    {
+        readonly Queue<HttpResponseMessage> m_ResponseMessages = new();
+        internal int RequestCount { get; private set; }
+
+        internal void EnqueueHttpResponseMessage(HttpResponseMessage responseMessage)
+        {
+            m_ResponseMessages.Enqueue(responseMessage);
+        }
+
+        protected override Task<HttpResponseMessage> SendAsync(
+            HttpRequestMessage request,
+            CancellationToken cancellationToken)
+        {
+            RequestCount++;
+            return Task.FromResult(m_ResponseMessages.Dequeue());
+        }
+
+        protected override HttpResponseMessage Send(
+            HttpRequestMessage request,
+            CancellationToken cancellationToken)
+        {
+            RequestCount++;
+            return m_ResponseMessages.Dequeue();
+        }
+    }
+
+    [Test]
+    public void AsyncHttpRetryPolicyBubblesUpException()
+    {
+        var policy = RetryPolicy.GetAsyncHttpRetryPolicy(1, false);
+
+        Assert.IsNotNull(policy);
+
+        Assert.ThrowsAsync<Exception>(async () =>
+        {
+            await policy.ExecuteAsync(() => throw new Exception());
+        });
+    }
+
+    [Test]
+    public void HttpRetryPolicyBubblesUpException()
+    {
+        var policy = RetryPolicy.GetHttpRetryPolicy(1, false);
+
+        Assert.IsNotNull(policy);
+
+        Assert.Throws<Exception>(() =>
+        {
+            policy.Execute(() => throw new Exception());
+        });
+    }
+
+    [TestCaseSource(nameof(k_HttpStatusCodeCases))]
+    public async Task AsyncHttpRetryPolicyRetriesRequestOnErrorStatusCodes(HttpStatusCode statusCode)
+    {
+        const int nbRetries = 1;
+
+        // Queue http responses that give off the desired status code
+        for (int i = 0; i < nbRetries + 1; i++)
+        {
+            m_MessageHandler!.EnqueueHttpResponseMessage(new HttpResponseMessage(statusCode));
+        }
+
+        var httpClient = new HttpClient(m_MessageHandler!);
+        var policy = RetryPolicy.GetAsyncHttpRetryPolicy(nbRetries, false);
+
+        Assert.IsNotNull(policy);
+
+        // Use the policy to retry the mocked http requests
+        await policy.ExecuteAsync(async () => await MakeMockAsyncHttpRequest(httpClient));
+
+        Assert.AreEqual(nbRetries + 1, m_MessageHandler!.RequestCount);
+    }
+
+    [TestCaseSource(nameof(k_HttpStatusCodeCases))]
+    public void HttpRetryPolicyRetriesRequestOnErrorStatusCodes(HttpStatusCode statusCode)
+    {
+        const int nbRetries = 1;
+
+        // Queue http responses that give off the desired status code
+        for (int i = 0; i < nbRetries + 1; i++)
+        {
+            m_MessageHandler!.EnqueueHttpResponseMessage(new HttpResponseMessage(statusCode));
+        }
+
+        var httpClient = new HttpClient(m_MessageHandler!);
+        var policy = RetryPolicy.GetHttpRetryPolicy(nbRetries, false);
+
+        Assert.IsNotNull(policy);
+
+        // Use the policy to retry the mocked http requests
+        policy.Execute(() => MakeMockHttpRequest(httpClient));
+
+        Assert.AreEqual(nbRetries + 1, m_MessageHandler!.RequestCount);
+    }
+
+    [Test]
+    public async Task AsyncHttpRetryPolicyStopsRetryingAfterSuccess()
+    {
+        const int nbRetries = 5;
+
+        m_MessageHandler!.EnqueueHttpResponseMessage(new HttpResponseMessage(HttpStatusCode.TooManyRequests));
+        m_MessageHandler!.EnqueueHttpResponseMessage(new HttpResponseMessage(HttpStatusCode.OK));
+
+        var httpClient = new HttpClient(m_MessageHandler!);
+        var policy = RetryPolicy.GetAsyncHttpRetryPolicy(nbRetries, false);
+
+        Assert.IsNotNull(policy);
+
+        // Use the policy to retry the mocked http requests
+        await policy.ExecuteAsync(async () => await MakeMockAsyncHttpRequest(httpClient));
+
+        Assert.AreEqual(2, m_MessageHandler!.RequestCount);
+    }
+
+    [Test]
+    public void HttpRetryPolicyStopsRetryingAfterSuccess()
+    {
+        const int nbRetries = 5;
+
+        m_MessageHandler!.EnqueueHttpResponseMessage(new HttpResponseMessage(HttpStatusCode.TooManyRequests));
+        m_MessageHandler!.EnqueueHttpResponseMessage(new HttpResponseMessage(HttpStatusCode.OK));
+
+        var httpClient = new HttpClient(m_MessageHandler!);
+        var policy = RetryPolicy.GetHttpRetryPolicy(nbRetries, false);
+
+        Assert.IsNotNull(policy);
+
+        // Use the policy to retry the mocked http requests
+        policy.Execute(() => MakeMockHttpRequest(httpClient));
+
+        Assert.AreEqual(2, m_MessageHandler!.RequestCount);
+    }
+
+    static RestResponse MakeMockHttpRequest(HttpClient httpClient)
+    {
+        var responseMessage = httpClient.Send(new HttpRequestMessage(HttpMethod.Get, k_BlankUri));
+
+        return CreateRestResponseFromHttpResponseMessage(responseMessage);
+    }
+
+    static async Task<RestResponse> MakeMockAsyncHttpRequest(HttpClient httpClient)
+    {
+        var responseMessage = await httpClient.GetAsync(k_BlankUri);
+
+        return CreateRestResponseFromHttpResponseMessage(responseMessage);
+    }
+
+    static RestResponse CreateRestResponseFromHttpResponseMessage(HttpResponseMessage responseMessage)
+    {
+        RestResponse restResponse = new RestResponse
+        {
+            StatusCode = responseMessage.StatusCode,
+            ResponseStatus = ResponseStatus.Completed,
+        };
+
+        var retryAfterDelta = responseMessage.Headers.RetryAfter?.Delta;
+        if (retryAfterDelta != null)
+        {
+            restResponse.Headers = new[]
+            {
+                new HeaderParameter("Retry-After", retryAfterDelta.Value.TotalSeconds.ToString())
+            };
+        }
+
+        return restResponse;
+    }
+
+    [TestCase("2", 2)]
+    [TestCase("10", 10)]
+    public void GetTimeSpanFromRetryAfterHeaderInSecondsReturnsCorrectTimeSpan(string retryAfterValue, double expected)
+    {
+        RestResponse response = new RestResponse();
+        HeaderParameter retryAfterHeader = new HeaderParameter(k_RetryAfterHeaderName, retryAfterValue);
+
+        response.Headers = new[]
+        {
+            retryAfterHeader
+        };
+
+        TimeSpan? timeSpan = RetryPolicy.GetTimeSpanFromRetryAfterHeader(response);
+
+        Assert.NotNull(timeSpan);
+        Assert.AreEqual(expected, timeSpan!.Value.TotalSeconds);
+    }
+
+    [TestCase("Sat, 1 Mar 2025 08:00:00 GMT")]
+    [TestCase("Tue, 1 Jan 2030 08:00:00 GMT")]
+    public void GetTimeSpanFromRetryAfterHeaderValidDateReturnsValidTimeSpan(string retryAfterValue)
+    {
+        RestResponse response = new RestResponse();
+        HeaderParameter retryAfterHeader = new HeaderParameter(k_RetryAfterHeaderName, retryAfterValue);
+
+        response.Headers = new[]
+        {
+            retryAfterHeader
+        };
+
+        TimeSpan? timeSpan = RetryPolicy.GetTimeSpanFromRetryAfterHeader(response);
+
+        Assert.NotNull(timeSpan);
+    }
+
+    [TestCase("Sat, 2 Mar 2025 08:00:00 GMT")]
+    public void GetTimeSpanFromRetryAfterHeaderInvalidDateReturnsNullTimeSpan(string retryAfterValue)
+    {
+        RestResponse response = new RestResponse();
+        HeaderParameter retryAfterHeader = new HeaderParameter(k_RetryAfterHeaderName, retryAfterValue);
+
+        response.Headers = new[]
+        {
+            retryAfterHeader
+        };
+
+        TimeSpan? timeSpan = RetryPolicy.GetTimeSpanFromRetryAfterHeader(response);
+
+        Assert.IsNull(timeSpan);
+    }
+
+    [Test]
+    public void GetTimeSpanFromRetryAfterHeaderWithRequestWithoutHeaderReturnsNull()
+    {
+        RestResponse response = new RestResponse();
+        TimeSpan? timeSpan = RetryPolicy.GetTimeSpanFromRetryAfterHeader(response);
+        Assert.IsNull(timeSpan);
+    }
+
+    [TestCase(1, 1)]
+    [TestCase(2, 4)]
+    [TestCase(3, 9)]
+    public void GetExponentialBackoffTimeSpanWithoutJitterReturnsCorrectTimeSpan(int retryCount, int expectedSeconds)
+    {
+        TimeSpan expectedTimeSpan = TimeSpan.FromSeconds(expectedSeconds);
+        Assert.AreEqual(expectedTimeSpan, RetryPolicy.GetExponentialBackoffTimeSpan(retryCount));
+    }
+
+    [TestCase(1)]
+    [TestCase(5)]
+    public void GetConstantBackoffTimeSpanWithoutJitterReturnsCorrectTimeSpan(int seconds)
+    {
+        TimeSpan expectedTimeSpan = TimeSpan.FromSeconds(seconds);
+        Assert.AreEqual(expectedTimeSpan, RetryPolicy.GetConstantBackoffTimeSpan(seconds));
+    }
+
+    [TestCase(2, 4)]
+    [Repeat(20)]
+    public void GetExponentialBackoffTimeSpanWithJitterReturnsCorrectTimeSpan(int retryCount, int expectedSeconds)
+    {
+        TimeSpan timeSpan = RetryPolicy.GetExponentialBackoffTimeSpan(retryCount, true);
+
+        Assert.That(timeSpan.TotalSeconds <= expectedSeconds + RetryPolicy.MaxJitter &&
+                    timeSpan.TotalSeconds >= expectedSeconds);
+    }
+
+    [TestCase(3)]
+    [Repeat(20)]
+    public void GetConstantBackoffTimeSpanWithJitterReturnsCorrectTimeSpan(int seconds)
+    {
+        TimeSpan timeSpan = RetryPolicy.GetConstantBackoffTimeSpan(seconds, true);
+
+        Assert.That(timeSpan.TotalSeconds <= seconds + RetryPolicy.MaxJitter &&
+                    timeSpan.TotalSeconds >= seconds);
+    }
+
+    [Test]
+    [Repeat(20)]
+    public void GenerateJitterGeneratesRandomNumberInCorrectRange()
+    {
+        double jitter = RetryPolicy.GenerateJitter();
+        Assert.That(jitter >= 0 && jitter <= RetryPolicy.MaxJitter);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Unity.Services.Cli.Common.UnitTest.csproj b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Unity.Services.Cli.Common.UnitTest.csproj
index 54c497b..83495d0 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Unity.Services.Cli.Common.UnitTest.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common.UnitTest/Unity.Services.Cli.Common.UnitTest.csproj
@@ -18,7 +18,7 @@
     <PackageReference Include="NUnit3TestAdapter" Version="4.4.2" />
     <PackageReference Include="coverlet.collector" Version="3.2.0" />
     <PackageReference Include="System.CommandLine.Hosting" Version="0.4.0-alpha.22272.1" />
-    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.1.0" />
+    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.2.0" />
     <PackageReference Include="Unity.Services.TelemetryApi.Generated" Version="1.0.1" />
   </ItemGroup>
   <ItemGroup>
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common/Exceptions/ExceptionHelper.cs b/Unity.Services.Cli/Unity.Services.Cli.Common/Exceptions/ExceptionHelper.cs
index 1e8091e..6102d3c 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common/Exceptions/ExceptionHelper.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common/Exceptions/ExceptionHelper.cs
@@ -32,20 +32,29 @@ public ExceptionHelper(IAnalyticEvent diagnostics, IAnsiConsole ansiConsole)
         m_AnsiConsole = ansiConsole;
     }
 
-    public void HandleException(Exception exception, ILogger logger, InvocationContext context)
+    public int HandleException(Exception exception, ILogger logger, InvocationContext context, int depth = 0)
     {
         var cancellationToken = context.GetCancellationToken();
         if (cancellationToken.IsCancellationRequested)
         {
             context.ExitCode = ExitCode.Cancelled;
-            return;
+            return ExitCode.Cancelled;
         }
 
+        var exitCode = ExitCode.HandledError;
+
         switch (exception)
         {
             case CliException cliException:
-                logger.LogError(cliException.Message);
-                context.ExitCode = cliException.ExitCode;
+                if (cliException.ExitCode == ExitCode.HandledError)
+                {
+                    logger.LogError(cliException.Message);
+                }
+                else if (cliException.ExitCode == ExitCode.UnhandledError)
+                {
+                    ExecuteUnhandledExceptionFlow(exception, context, depth);
+                    exitCode = ExitCode.UnhandledError;
+                }
                 break;
             case DeploymentFailureException deploymentFailureException:
                 // We don't log this exception because the deployment content already
@@ -53,42 +62,63 @@ public void HandleException(Exception exception, ILogger logger, InvocationConte
                 context.ExitCode = deploymentFailureException.ExitCode;
                 break;
             case IdentityApiException identityApiException:
-                HandleApiException(exception, logger, context, identityApiException.ErrorCode);
+                HandleApiException(exception, logger, identityApiException.ErrorCode);
                 break;
             case CloudCodeApiException cloudCodeApiException:
-                HandleApiException(exception, logger, context, cloudCodeApiException.ErrorCode);
+                HandleApiException(exception, logger, cloudCodeApiException.ErrorCode);
                 break;
             case EconomyApiException economyApiException:
-                HandleApiException(exception, logger, context, economyApiException.ErrorCode);
+                HandleApiException(exception, logger, economyApiException.ErrorCode);
                 break;
             case LobbyApiException lobbyApiException:
-                HandleApiException(exception, logger, context, lobbyApiException.ErrorCode);
+                HandleApiException(exception, logger, lobbyApiException.ErrorCode);
                 break;
             case LeaderboardApiException leaderboardApiException:
-                HandleApiException(exception, logger, context, leaderboardApiException.ErrorCode);
+                HandleApiException(exception, logger, leaderboardApiException.ErrorCode);
                 break;
             case PlayerAdminApiException playerAdminApiException:
-                HandleApiException(exception, logger, context, playerAdminApiException.ErrorCode);
+                HandleApiException(exception, logger, playerAdminApiException.ErrorCode);
                 break;
             case PlayerAuthException playerAuthApiException:
-                HandleApiException(exception, logger, context, playerAuthApiException.ErrorCode);
+                HandleApiException(exception, logger, playerAuthApiException.ErrorCode);
                 break;
             case AggregateException aggregateException:
-                HandleAggregateException(aggregateException, logger, context);
+                foreach (var ex in aggregateException.InnerExceptions)
+                {
+                    var aggregateExitCode = HandleException(ex, logger, context, depth + 1);
+                    if (aggregateExitCode > exitCode)
+                    {
+                        exitCode = aggregateExitCode;
+                    }
+                }
+
+                if (depth == 0 && exitCode != ExitCode.HandledError)
+                {
+                    m_AnsiConsole.WriteException(exception);
+                }
+
+                context.ExitCode = exitCode;
                 break;
             case HostingApiException hostingException:
-                HandleApiException(exception, logger, context, hostingException.ErrorCode);
+                HandleApiException(exception, logger, hostingException.ErrorCode);
                 break;
             default:
-                ExecuteUnhandledExceptionFlow(exception, context);
+                ExecuteUnhandledExceptionFlow(exception, context, depth);
+                exitCode = ExitCode.UnhandledError;
                 break;
         }
+
+        context.ExitCode = exitCode;
+        return exitCode;
     }
 
-    void ExecuteUnhandledExceptionFlow(Exception exception, InvocationContext context)
+    void ExecuteUnhandledExceptionFlow(Exception exception, InvocationContext context, int depth)
     {
-        context.ExitCode = ExitCode.UnhandledError;
-        m_AnsiConsole.WriteException(exception);
+        if (depth == 0)
+        {
+            m_AnsiConsole.WriteException(exception);
+        }
+
         try
         {
             Diagnostics.AddData(TagKeys.DiagnosticName, "cli_unhandled_exception");
@@ -110,34 +140,7 @@ void ExecuteUnhandledExceptionFlow(Exception exception, InvocationContext contex
         }
     }
 
-    void HandleAggregateException(AggregateException aggregateException, ILogger logger, InvocationContext context)
-    {
-        // Check for CLI Exceptions in the aggregated exceptions
-        var cliExceptions =
-            aggregateException.InnerExceptions.Where(e => e is CliException);
-
-        // Log any CLI Exception found
-        foreach (var e in cliExceptions)
-        {
-            logger.LogError(e.Message);
-        }
-
-        // Sets handled error in case no unhandled error is found
-        if (cliExceptions.Any())
-        {
-            context.ExitCode = ExitCode.HandledError;
-        }
-        var unhandledExceptions =
-            aggregateException.InnerExceptions.Where(e => e is not CliException);
-
-        // Sets default flow in case any exception is unhandled
-        if (unhandledExceptions.Any())
-        {
-            ExecuteUnhandledExceptionFlow(aggregateException, context);
-        }
-    }
-
-    void HandleApiException(Exception exception, ILogger logger, InvocationContext context, int errorCode)
+    void HandleApiException(Exception exception, ILogger logger, int errorCode)
     {
         bool isErrorCodeRelatedToHttpStatus = Enum.IsDefined(typeof(HttpStatusCode), errorCode);
         HttpStatusCode? statusCode = isErrorCodeRelatedToHttpStatus ? (HttpStatusCode?)errorCode : null;
@@ -153,6 +156,5 @@ void HandleApiException(Exception exception, ILogger logger, InvocationContext c
             : string.Join(Environment.NewLine, exception.Message, TroubleshootingHelp, troubleShootingLink);
 
         logger.LogError(fullExceptionMessage);
-        context.ExitCode = ExitCode.HandledError;
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/LogFormatter/JsonLogFormatter.cs b/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/LogFormatter/JsonLogFormatter.cs
index 14bcba9..7756d55 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/LogFormatter/JsonLogFormatter.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/LogFormatter/JsonLogFormatter.cs
@@ -1,14 +1,31 @@
+using System;
+using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 
 namespace Unity.Services.Cli.Common.Logging;
 
 class JsonLogFormatter : ILogFormatter
 {
+    readonly TextWriter m_StdOut;
+    readonly TextWriter m_StdErr;
+
+    public JsonLogFormatter(TextWriter stdOut, TextWriter stdErr)
+    {
+        m_StdOut = stdOut;
+        m_StdErr = stdErr;
+    }
+
     /// <inheritdoc cref="ILogFormatter.WriteLog"/>
     public void WriteLog(LogCache logCache)
     {
-        var messages = new List<JsonLogMessage>(logCache.Messages.Capacity);
-        foreach (var message in logCache.Messages)
+        m_StdOut.WriteLine(JsonConvert.SerializeObject(logCache.Result, Formatting.Indented));
+        WriteMessages(logCache.Messages);
+    }
+
+    void WriteMessages(List<LogMessage> logMessages)
+    {
+        var messages = new List<JsonLogMessage>(logMessages.Capacity);
+        foreach (var message in logMessages)
         {
             messages.Add(new JsonLogMessage()
             {
@@ -17,11 +34,9 @@ public void WriteLog(LogCache logCache)
             });
         }
 
-        var jsonLine = JsonConvert.SerializeObject(new
+        if (messages.Any())
         {
-            logCache.Result,
-            Messages = messages
-        }, Formatting.Indented);
-        System.Console.WriteLine(jsonLine);
+            m_StdErr.WriteLine(JsonConvert.SerializeObject(messages, Formatting.Indented));
+        }
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/LogFormatter/LogFormatter.cs b/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/LogFormatter/LogFormatter.cs
index 5a1bee9..1913eef 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/LogFormatter/LogFormatter.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/LogFormatter/LogFormatter.cs
@@ -2,13 +2,18 @@ namespace Unity.Services.Cli.Common.Logging;
 
 class LogFormatter : ILogFormatter
 {
+    readonly TextWriter m_Stdout;
+    readonly TextWriter m_StdErr;
     LogConfiguration LogConfiguration { get; set; }
 
-    public LogFormatter() : this(new LogConfiguration()) { }
-    public LogFormatter(LogConfiguration logConfiguration)
+    public LogFormatter(TextWriter stdout, TextWriter stdErr) : this(new LogConfiguration(), stdout, stdErr) { }
+    public LogFormatter(LogConfiguration logConfiguration, TextWriter stdout, TextWriter stdErr)
     {
+        m_Stdout = stdout;
+        m_StdErr = stdErr;
         LogConfiguration = logConfiguration;
     }
+
     /// <inheritdoc cref="ILogFormatter.WriteLog"/>
     public void WriteLog(LogCache logCache)
     {
@@ -23,12 +28,12 @@ public void WriteLog(LogCache logCache)
     void WriteResult(object result)
     {
         var resultString = result.ToString();
-        if (result is IEnumerable<string> valueList)
+        if (result is IEnumerable<object> valueList)
         {
             resultString = string.Join(Environment.NewLine, valueList);
         }
 
-        System.Console.WriteLine(resultString);
+        m_Stdout.WriteLine(resultString);
     }
 
     void WriteMessages(List<LogMessage> messages)
@@ -37,10 +42,10 @@ void WriteMessages(List<LogMessage> messages)
         {
             var previousForegroundColor = System.Console.ForegroundColor;
             System.Console.ForegroundColor = LogConfiguration.LogLevels[message.Type];
-            System.Console.Write($"[{message.Type}]: ");
+            m_StdErr.Write($"[{message.Type}]: ");
             System.Console.ForegroundColor = previousForegroundColor;
-            System.Console.WriteLine(message.Name);
-            System.Console.WriteLine($"    {message.Message}");
+            m_StdErr.WriteLine(message.Name);
+            m_StdErr.WriteLine($"    {message.Message}");
         }
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/Logger.cs b/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/Logger.cs
index 2d0da19..78630bc 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/Logger.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common/Logging/Logger.cs
@@ -25,6 +25,9 @@ public Logger(string name, LogConfiguration logConfiguration)
         (m_Name, Configuration) = (name, logConfiguration);
     }
 
+    public StreamWriter? StdOut { get; init; }
+    public StreamWriter? StdErr { get; init; }
+
     void ILogger.Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception,
         Func<TState, Exception?, string> formatter)
     {
@@ -43,14 +46,16 @@ void ILogger.Log<TState>(LogLevel logLevel, EventId eventId, TState state, Excep
         }
     }
 
-    static bool IsResultEvent(EventId eventId)
+    protected static bool IsResultEvent(EventId eventId)
     {
         return eventId.Id == LoggerExtension.ResultEventId.Id && eventId.Name == LoggerExtension.ResultEventId.Name;
     }
 
     public void Write()
     {
-        ILogFormatter formatter = Configuration.IsJson ? new JsonLogFormatter() : new LogFormatter(Configuration);
+        ILogFormatter formatter = Configuration.IsJson
+            ? new JsonLogFormatter(StdOut ?? System.Console.Out, StdErr ?? System.Console.Error)
+            : new LogFormatter(Configuration, StdOut ?? System.Console.Out, StdErr ?? System.Console.Error);
         WriteLog(formatter);
     }
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/EndpointHelper.cs b/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/EndpointHelper.cs
index 2600a7e..9e841d6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/EndpointHelper.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/EndpointHelper.cs
@@ -7,22 +7,6 @@ namespace Unity.Services.Cli.Common.Networking;
 /// </summary>
 public static class EndpointHelper
 {
-    /// <summary>
-    /// The network environment currently targeted by the CLI.
-    /// </summary>
-    public static CliNetworkEnvironment CurrentNetworkEnvironment
-    {
-        get
-        {
-#if USE_STAGING_ENDPOINTS
-            return CliNetworkEnvironment.Staging;
-#elif USE_MOCKSERVER_ENDPOINTS
-            return CliNetworkEnvironment.MockServer;
-#else
-            return CliNetworkEnvironment.Production;
-#endif
-        }
-    }
 
     static readonly Dictionary<Type, NetworkTargetEndpoints> k_NetworkTargetEndpoints = new();
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/Endpoints/NetworkTargetEndpoints.cs b/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/Endpoints/NetworkTargetEndpoints.cs
index 5153186..abe0011 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/Endpoints/NetworkTargetEndpoints.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/Endpoints/NetworkTargetEndpoints.cs
@@ -1,3 +1,7 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Unity.Services.Cli.IntegrationTest")]
+
 namespace Unity.Services.Cli.Common.Networking;
 
 /// <summary>
@@ -5,6 +9,7 @@ namespace Unity.Services.Cli.Common.Networking;
 /// </summary>
 public abstract class NetworkTargetEndpoints
 {
+    internal static bool UseMockEndpoints { get; set; }
     /// <summary>
     /// URL to use when targeting production.
     /// </summary>
@@ -30,6 +35,8 @@ public string Current
 #elif USE_MOCKSERVER_ENDPOINTS
             return MockServer;
 #else
+            if (UseMockEndpoints)
+                return MockServer;
             return Prod;
 #endif
         }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/Endpoints/RemoteConfigEndpoints.cs b/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/Endpoints/RemoteConfigEndpoints.cs
index 6f5387c..ef9d70d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/Endpoints/RemoteConfigEndpoints.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common/Networking/Endpoints/RemoteConfigEndpoints.cs
@@ -9,3 +9,13 @@ public sealed class RemoteConfigEndpoints : NetworkTargetEndpoints
 
     protected override string Staging { get; } = "https://staging.services.api.unity.com";
 }
+
+/// <summary>
+/// Endpoints used to reach the Unity Remote Config Service's internal admin APIs.
+/// </summary>
+public sealed class RemoteConfigInternalEndpoints : NetworkTargetEndpoints
+{
+    protected override string Prod { get; } = "https://services.unity.com";
+
+    protected override string Staging { get; } = "https://staging.services.unity.com";
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common/Policies/RetryPolicy.cs b/Unity.Services.Cli/Unity.Services.Cli.Common/Policies/RetryPolicy.cs
new file mode 100644
index 0000000..867c78f
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common/Policies/RetryPolicy.cs
@@ -0,0 +1,166 @@
+using System.Net;
+using Polly;
+using RestSharp;
+
+namespace Unity.Services.Cli.Common.Policies;
+
+public static class RetryPolicy
+{
+    const int k_NbRetries = 3;
+    internal const double MaxJitter = 0.5;
+    const double k_ConstantBackoffDelay = 3;
+    internal const double MaxRetryDelay = 15;
+
+    /// <summary>
+    /// For the Remote Service API HTTP Request policy, this is a whitelist of the statuses to retry for
+    /// </summary>
+    internal static readonly HttpStatusCode[] RetryHttpStatuses =
+    {
+        HttpStatusCode.RequestTimeout,
+        HttpStatusCode.TooManyRequests,
+        HttpStatusCode.InternalServerError,
+        HttpStatusCode.BadGateway,
+        HttpStatusCode.ServiceUnavailable,
+        HttpStatusCode.GatewayTimeout
+    };
+
+    /// <summary>
+    /// Defines a synchronous retry policy for Remote Service API HTTP Requests.
+    /// This is meant to be used as template by services, but can be used for other HTTP request purposes.
+    /// </summary>
+    /// <param name="nbRetries">The number of retries to attempt</param>
+    /// <param name="withJitter">Whether to add jitter or not to the backoff</param>
+    /// <returns>A synchronous HTTP retry policy</returns>
+    public static Policy<RestResponse> GetHttpRetryPolicy(int nbRetries = k_NbRetries, bool withJitter = true)
+    {
+        // Trick to get Policy to bubble up the latest exception thrown by the retry policy defined below
+        var fallback = Policy
+            .HandleResult<RestResponse>(_ => false)
+            // Never happens
+            .Fallback(_ => null!);
+
+        var retry = Policy
+            .HandleResult<RestResponse>(ShouldRetryHttpRequest)
+            .WaitAndRetry(
+                nbRetries,
+                (retryCount, result, _) => GetRetryTimeSpan(retryCount, result, withJitter));
+
+        return fallback.Wrap(retry);
+    }
+
+    /// <summary>
+    /// Defines an async retry policy for Remote Service API HTTP Requests.
+    /// This is meant to be used as template by services, but can be used for other HTTP request purposes.
+    /// </summary>
+    /// <param name="nbRetries">The number of retries to attempt</param>
+    /// <param name="withJitter">Whether to add jitter or not to the backoff</param>
+    /// <returns>An asynchronous HTTP retry policy</returns>
+    public static AsyncPolicy<RestResponse> GetAsyncHttpRetryPolicy(int nbRetries = k_NbRetries, bool withJitter = true)
+    {
+        // Trick to get Policy to bubble up the latest exception thrown by the retry policy defined below
+        var fallback = Policy
+            .HandleResult<RestResponse>(_ => false)
+            // Never happens
+            .FallbackAsync(_ => null);
+
+        var retry = Policy
+            .HandleResult<RestResponse>(ShouldRetryHttpRequest)
+            .WaitAndRetryAsync(
+                nbRetries,
+                (retryCount, result, _) => GetRetryTimeSpan(retryCount, result, withJitter),
+                (_, _, _, _) => Task.CompletedTask);
+
+        return fallback.WrapAsync(retry);
+    }
+
+    /// <summary>
+    /// Get the amount of time to wait before making another retry request.
+    /// </summary>
+    /// <param name="retryCount">The current retry counter</param>
+    /// <param name="result">Http response result delegate</param>
+    /// <param name="withJitter">Whether to add jitter or not to the backoff</param>
+    /// <returns>A TimeSpan containing the timing information for the next retry run</returns>
+    static TimeSpan GetRetryTimeSpan(int retryCount, DelegateResult<RestResponse> result, bool withJitter)
+    {
+        TimeSpan timeSpan = GetTimeSpanFromRetryAfterHeader(result.Result) ??
+                            GetExponentialBackoffTimeSpan(retryCount, withJitter);
+
+        if (timeSpan.TotalSeconds > MaxRetryDelay)
+        {
+            return TimeSpan.FromSeconds(MaxRetryDelay);
+        }
+
+        return timeSpan;
+    }
+
+    static bool ShouldRetryHttpRequest(RestResponse response)
+        => RetryHttpStatuses.Contains(response.StatusCode);
+
+    /// <summary>
+    /// From an http RestResponse, attempt to find the "Retry-After" header and get its value to determine when
+    /// the next retry should be executed
+    /// </summary>
+    /// <param name="httpResponse">Http response to parse</param>
+    /// <returns>A TimeSpan containing the timing information for the next retry run</returns>
+    internal static TimeSpan? GetTimeSpanFromRetryAfterHeader(RestResponse httpResponse)
+    {
+        HeaderParameter? param = httpResponse.Headers?
+            .ToList()
+            .Find(headerParameter => headerParameter.Name == "Retry-After");
+
+        string? retryAfterValue = param?.Value?.ToString();
+
+        if (retryAfterValue == null)
+            return null;
+
+        // At this point, the Retry-After header can be in two formats.
+        // Format 1 being an int with the number of seconds to wait, ex: 120
+        if (int.TryParse(retryAfterValue, out int seconds))
+        {
+            return TimeSpan.FromSeconds(seconds);
+        }
+
+        // Format 2 being a date in html ugc format, ex: Wed, 21 Oct 2023 07:24:00 GMT
+        if (DateTime.TryParse(retryAfterValue, out DateTime date))
+        {
+            return date - DateTime.Now;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Generates a TimeSpan depending on the current retry count, following an exponential backoff policy.
+    /// </summary>
+    /// <param name="retryAttempt">A count on the number of retries</param>
+    /// <param name="withJitter">Whether to add jitter or not to the backoff</param>
+    /// <returns>A TimeSpan containing the timing information for the next retry run</returns>
+    public static TimeSpan GetExponentialBackoffTimeSpan(
+        int retryAttempt = k_NbRetries,
+        bool withJitter = false)
+        => TimeSpan.FromSeconds(Math.Pow(retryAttempt, 2) + (withJitter ? GenerateJitter() : 0));
+
+    /// <summary>
+    /// Generates a TimeSpan depending on the current retry count, following a constant backoff policy.
+    /// </summary>
+    /// <param name="backoffDelay">The delay in seconds between each try</param>
+    /// <param name="withJitter">Whether to add jitter or not to the backoff</param>
+    /// <returns>A TimeSpan containing the timing information for the next retry run</returns>
+    public static TimeSpan GetConstantBackoffTimeSpan(
+        double backoffDelay = k_ConstantBackoffDelay,
+        bool withJitter = false)
+        => TimeSpan.FromSeconds(backoffDelay + (withJitter ? GenerateJitter() : 0));
+
+    /// <summary>
+    /// Generates a random number between 0 and maxJitter.
+    /// This number is used to help balance the load of requests made to the servers that receive the request and to
+    /// mitigate synchronized behaviour.
+    /// </summary>
+    /// <returns>Random number between 0 and maxJitter</returns>
+    internal static double GenerateJitter()
+    {
+        Random random = new();
+        double jitterMultiplier = random.NextDouble();
+        return jitterMultiplier * MaxJitter;
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common/Telemetry/TagKeys.cs b/Unity.Services.Cli/Unity.Services.Cli.Common/Telemetry/TagKeys.cs
index 97be026..d7e182d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common/Telemetry/TagKeys.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common/Telemetry/TagKeys.cs
@@ -1,6 +1,6 @@
 namespace Unity.Services.Cli.Common.Telemetry;
 
-internal static class TagKeys
+static class TagKeys
 {
     /// <summary>
     /// Full description of OS being used
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Common/Unity.Services.Cli.Common.csproj b/Unity.Services.Cli/Unity.Services.Cli.Common/Unity.Services.Cli.Common.csproj
index eeafbf1..4553baf 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Common/Unity.Services.Cli.Common.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.Common/Unity.Services.Cli.Common.csproj
@@ -14,7 +14,7 @@
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
     <PackageReference Include="System.CommandLine.Hosting" Version="0.4.0-alpha.22272.1" />
     <PackageReference Include="Unity.Services.Gateway.AccessApiV1.Generated" Version="1.0.1" />
-    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.1.0" />
+    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.2.0" />
     <PackageReference Include="Unity.Services.Gateway.EconomyApiV2.Generated" Version="2.0.2" />
     <PackageReference Include="Unity.Services.Gateway.IdentityApiV1.Generated" Version="1.0.6" />
     <PackageReference Include="Unity.Services.Gateway.LeaderboardApiV1.Generated" Version="1.0.5-beta" />
@@ -22,7 +22,7 @@
     <PackageReference Include="Unity.Services.Gateway.PlayerAuthApiV1.Generated" Version="1.0.1" />
     <PackageReference Include="Unity.Services.TelemetryApi.Generated" Version="1.0.1" />
     <PackageReference Include="Unity.Services.MpsLobby.LobbyApiV1.Generated" Version="0.11.1" />
-    <PackageReference Include="Unity.Services.Gateway.GameServerHostingApiV1.Generated" Version="0.1.3" />
+    <PackageReference Include="Unity.Services.Gateway.GameServerHostingApiV1.Generated" Version="0.3.0" />
     <PackageReference Include="UnityAnalytic.Modules.Sender" Version="0.1.0" />
   </ItemGroup>
   <ItemGroup>
@@ -33,6 +33,11 @@
       <_Parameter1>DynamicProxyGenAssembly2</_Parameter1>
     </AssemblyAttribute>
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\Unity.Services.ModuleTemplate.Authoring.Core\Batching\Batching.cs">
+      <Link>Batching\Batching.cs</Link>
+    </Compile>
+  </ItemGroup>
   <PropertyGroup>
     <DefineConstants Condition=" '$(ExtraDefineConstants)' != '' ">$(DefineConstants);$(ExtraDefineConstants)</DefineConstants>
   </PropertyGroup>
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Environment/EnvironmentModule.cs b/Unity.Services.Cli/Unity.Services.Cli.Environment/EnvironmentModule.cs
index 9bf7948..fbbdc20 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Environment/EnvironmentModule.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Environment/EnvironmentModule.cs
@@ -5,6 +5,7 @@
 using Unity.Services.Cli.Common;
 using Unity.Services.Cli.Common.Console;
 using Unity.Services.Cli.Common.Input;
+using Unity.Services.Cli.Common.Policies;
 using Unity.Services.Cli.Common.Utils;
 using Unity.Services.Cli.Common.Validator;
 using Unity.Services.Cli.Environment.Handlers;
@@ -89,5 +90,11 @@ public static void RegisterServices(HostBuilderContext hostBuilderContext, IServ
 
         var unityEnvironment = new UnityEnvironment(environmentService, validator);
         serviceCollection.AddSingleton<IUnityEnvironment>(unityEnvironment);
+
+        // Set retry policy
+        Gateway.IdentityApiV1.Generated.Client.RetryConfiguration.RetryPolicy =
+            RetryPolicy.GetHttpRetryPolicy();
+        Gateway.IdentityApiV1.Generated.Client.RetryConfiguration.AsyncRetryPolicy =
+            RetryPolicy.GetAsyncHttpRetryPolicy();
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/AccessApiMock.cs b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/AccessApiMock.cs
index e0ef378..1f591bb 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/AccessApiMock.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/AccessApiMock.cs
@@ -14,11 +14,11 @@ public class AccessApiMock : IServiceApiMock
     readonly string m_ProjectId;
     readonly string m_EnvironmentId;
     readonly string m_PlayerId;
-    private readonly string k_AccessModulePath = "/access/v1";
+    readonly string k_AccessModulePath = "/access/v1";
 
-    private readonly string projectPolicyUrl;
-    private readonly string playerPolicyUrl;
-    private readonly string allPlayerPoliciesUrl;
+    readonly string projectPolicyUrl;
+    readonly string playerPolicyUrl;
+    readonly string allPlayerPoliciesUrl;
 
     public const string PlayerId = "j0oM0dnufzxgtwGqoH0zIpSyWUV7XUgy";
 
@@ -33,14 +33,14 @@ public AccessApiMock()
         allPlayerPoliciesUrl = $"{k_AccessModulePath}/projects/{m_ProjectId}/environments/{m_EnvironmentId}/players/resource-policy";
     }
 
-    private static Policy GetPolicy()
+    static Policy GetPolicy()
     {
         List<Statement> statementLists = new List<Statement>();
         var policy = new Policy(statementLists);
 
         return policy;
     }
-    private PlayerPolicy GetPlayerPolicy()
+    PlayerPolicy GetPlayerPolicy()
     {
         List<Statement> statementLists = new List<Statement>();
         var policy = new PlayerPolicy(playerId: m_PlayerId, statementLists);
@@ -48,7 +48,7 @@ private PlayerPolicy GetPlayerPolicy()
         return policy;
     }
 
-    private PlayerPolicies GetPlayerPolicies()
+    PlayerPolicies GetPlayerPolicies()
     {
         List<PlayerPolicy> results = new List<PlayerPolicy>();
         results.Add(GetPlayerPolicy());
@@ -73,7 +73,7 @@ void MockGetProjectPolicy(WireMockServer mockServer)
     {
         mockServer.Given(Request.Create().WithPath(projectPolicyUrl).UsingGet())
             .RespondWith(Response.Create()
-                .WithHeaders(new Dictionary<string, string> {{"Content-Type","application/json"}})
+                .WithHeaders(new Dictionary<string, string> { { "Content-Type", "application/json" } })
                 .WithBodyAsJson(GetPolicy())
                 .WithStatusCode(HttpStatusCode.OK));
     }
@@ -82,7 +82,7 @@ void MockGetPlayerPolicy(WireMockServer mockServer)
     {
         mockServer.Given(Request.Create().WithPath(playerPolicyUrl).UsingGet())
             .RespondWith(Response.Create()
-                .WithHeaders(new Dictionary<string, string> {{"Content-Type","application/json"}})
+                .WithHeaders(new Dictionary<string, string> { { "Content-Type", "application/json" } })
                 .WithBodyAsJson(GetPlayerPolicy())
                 .WithStatusCode(HttpStatusCode.OK));
     }
@@ -91,7 +91,7 @@ void MockGetAllPlayerPolicies(WireMockServer mockServer)
     {
         mockServer.Given(Request.Create().WithPath(allPlayerPoliciesUrl).UsingGet())
             .RespondWith(Response.Create()
-                .WithHeaders(new Dictionary<string, string> {{"Content-Type","application/json"}})
+                .WithHeaders(new Dictionary<string, string> { { "Content-Type", "application/json" } })
                 .WithBodyAsJson(GetPlayerPolicies())
                 .WithStatusCode(HttpStatusCode.OK));
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/CloudCode/CloudCodeFetchMock.cs b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/CloudCode/CloudCodeFetchMock.cs
index 6efea61..0c074d8 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/CloudCode/CloudCodeFetchMock.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/CloudCode/CloudCodeFetchMock.cs
@@ -2,6 +2,8 @@
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Cli.MockServer.ServiceMocks.RemoteConfig;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
+using Unity.Services.Gateway.EconomyApiV2.Generated.Model;
+
 using WireMock.Admin.Mappings;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
@@ -42,9 +44,9 @@ public class CloudCodeFetchMock : IServiceApiMock
         };
     public async Task<IReadOnlyList<MappingModel>> CreateMappingModels()
     {
-        var script1Models= await GetScriptModels("remoteScript1");
-        var script2Models= await GetScriptModels("remoteScript2");
-        var script3Models= await GetScriptModels("remoteScript3");
+        var script1Models = await GetScriptModels("remoteScript1");
+        var script2Models = await GetScriptModels("remoteScript2");
+        var script3Models = await GetScriptModels("remoteScript3");
         return script1Models.Concat(script2Models).Concat(script3Models).ToArray();
     }
 
@@ -52,21 +54,43 @@ public void CustomMock(WireMockServer mockServer)
     {
         MockListScript(mockServer);
         MockListRemoteConfigEmpty(mockServer);
+        MockListEconomyResourceEmpty(mockServer);
+    }
+
+    static void MockListEconomyResourceEmpty(WireMockServer mockServer)
+    {
+        var publishedResourcesResponse = new GetPublishedResourcesResponse(new List<GetResourcesResponseResultsInner>());
+        mockServer.Given(Request.Create().WithPath($"*/economy/v2/projects/{CommonKeys.ValidProjectId}/environments/{CommonKeys.ValidEnvironmentId}/configs/published/resources").UsingGet())
+            .RespondWith(Response.Create().WithHeaders(new Dictionary<string, string>
+            {
+                {
+                    "Content-Type", "application/json"
+                }
+            }).WithBodyAsJson(publishedResourcesResponse).WithStatusCode(HttpStatusCode.OK));
+
+        var resourcesResponse = new GetResourcesResponse(new List<GetResourcesResponseResultsInner>());
+        mockServer.Given(Request.Create().WithPath($"*/economy/v2/projects/{CommonKeys.ValidProjectId}/environments/{CommonKeys.ValidEnvironmentId}/configs/draft/resources").UsingGet())
+            .RespondWith(Response.Create().WithHeaders(new Dictionary<string, string>
+            {
+                {
+                    "Content-Type", "application/json"
+                }
+            }).WithBodyAsJson(resourcesResponse).WithStatusCode(HttpStatusCode.OK));
     }
 
-    void MockListRemoteConfigEmpty(WireMockServer mockServer)
+    static void MockListRemoteConfigEmpty(WireMockServer mockServer)
     {
         mockServer.Given(Request.Create().WithPath($"*/remote-config/v1/projects/{CommonKeys.ValidProjectId}/environments/{CommonKeys.ValidEnvironmentId}/configs").UsingGet())
             .RespondWith(Response.Create()
-                .WithHeaders(new Dictionary<string, string> {{"Content-Type","application/json"}})
+                .WithHeaders(new Dictionary<string, string> { { "Content-Type", "application/json" } })
                 .WithBodyAsJson(new GetResponse
                 {
-                    Configs = new List<Config> ()
+                    Configs = new List<Config>()
                 })
                 .WithStatusCode(HttpStatusCode.OK));
     }
 
-    void MockListScript(WireMockServer mockServer)
+    static void MockListScript(WireMockServer mockServer)
     {
         var response = new ListScriptsResponse(
             RemoteScripts,
@@ -82,7 +106,7 @@ void MockListScript(WireMockServer mockServer)
             }).WithBodyAsJson(response).WithStatusCode(HttpStatusCode.OK));
     }
 
-    async Task<IEnumerable<MappingModel>> GetScriptModels(string validScriptName)
+    static async Task<IEnumerable<MappingModel>> GetScriptModels(string validScriptName)
     {
         var models = await MappingModelUtils.ParseMappingModelsFromGeneratorConfigAsync(k_CloudCodeV1Config, new());
         return models.Select(
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/CloudCode/CloudCodeV1Mock.cs b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/CloudCode/CloudCodeV1Mock.cs
index 4015dc6..71fc114 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/CloudCode/CloudCodeV1Mock.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/CloudCode/CloudCodeV1Mock.cs
@@ -1,4 +1,5 @@
 using System.Net;
+using OpenTelemetry.Trace;
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
 using WireMock.Admin.Mappings;
@@ -6,18 +7,19 @@
 using WireMock.ResponseBuilders;
 using WireMock.Server;
 
-namespace Unity.Services.Cli.MockServer.ServiceMocks;
+namespace Unity.Services.Cli.MockServer.ServiceMocks.CloudCode;
 
 public class CloudCodeV1Mock : IServiceApiMock
 {
     const string k_CloudCodeV1Config = "cloud-code-api-v1-generator-config.yaml";
     public const string ValidScriptName = "test-3";
     public const string ValidModuleName = "test_3";
+    const string sampleURL = "https://google.com";
 
     public async Task<IReadOnlyList<MappingModel>> CreateMappingModels()
     {
-        var scriptModels= await GetScriptModels(ValidScriptName);
-        var exampleScriptModels= await GetScriptModels("example-string");
+        var scriptModels = await GetScriptModels(ValidScriptName);
+        var exampleScriptModels = await GetScriptModels("example-string");
         var moduleModels = (await GetModuleModels(ValidModuleName))
             .Concat(await GetModuleModels("ExistingModule"))
             .Concat(await GetModuleModels("AnotherExistingModule"));
@@ -27,20 +29,26 @@ public async Task<IReadOnlyList<MappingModel>> CreateMappingModels()
     public void CustomMock(WireMockServer mockServer)
     {
         MockListCSharpModule(mockServer);
+        MockHttpClientForModuleDownloads(mockServer);
     }
 
-    void MockListCSharpModule(WireMockServer mockServer)
+    static void MockListCSharpModule(WireMockServer mockServer)
     {
         var response = new ListModulesResponse(
             new List<ListModulesResponseResultsInner>
             {
                 new(
                     "ExistingModule",
-                    Language.CS
+                    Language.CS,
+                    null,
+                    sampleURL
+
                 ),
                 new(
                     "AnotherExistingModule",
-                    Language.CS
+                    Language.CS,
+                    null,
+                    sampleURL
                 )
             },
             ""
@@ -55,7 +63,23 @@ void MockListCSharpModule(WireMockServer mockServer)
             }).WithBodyAsJson(response).WithStatusCode(HttpStatusCode.OK));
     }
 
-    async Task<IEnumerable<MappingModel>> GetScriptModels(string validScriptName = "test-script")
+    // Mocks out the file stream response for HTTPClient when testing import/export.
+    static void MockHttpClientForModuleDownloads(WireMockServer mockServer)
+    {
+        const string testFile
+            = "../../../../Unity.Services.Cli.CloudCode.UnitTest/ModuleTestCases/test.ccmzip";
+        mockServer?.Given(Request.Create().WithUrl(sampleURL).UsingGet())
+            .RespondWith(Response.Create().WithHeaders(new Dictionary<string, string>
+            {
+                {
+                    "Content-Type", "application/zip"
+                }
+            }).WithBodyFromFile(testFile)
+                .WithStatusCode(HttpStatusCode.OK));
+
+    }
+
+    static async Task<IEnumerable<MappingModel>> GetScriptModels(string validScriptName = "test-script")
     {
         var models = await MappingModelUtils.ParseMappingModelsFromGeneratorConfigAsync(k_CloudCodeV1Config, new());
         return models.Select(
@@ -64,7 +88,7 @@ async Task<IEnumerable<MappingModel>> GetScriptModels(string validScriptName = "
                 .ConfigMappingPathWithKey("scripts", validScriptName));
     }
 
-    async Task<IEnumerable<MappingModel>> GetModuleModels(string validModuleName = "test_module")
+    static async Task<IEnumerable<MappingModel>> GetModuleModels(string validModuleName = "test_module")
     {
         var models = await MappingModelUtils.ParseMappingModelsFromGeneratorConfigAsync(k_CloudCodeV1Config, new());
         return models.Select(
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/EconomyApiMock.cs b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/EconomyApiMock.cs
index f7bdf97..b1049c4 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/EconomyApiMock.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/EconomyApiMock.cs
@@ -1,5 +1,11 @@
+using System.Net;
 using Unity.Services.Cli.MockServer.Common;
+using Unity.Services.Cli.MockServer.ServiceMocks.RemoteConfig;
+using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
+using Unity.Services.Gateway.EconomyApiV2.Generated.Model;
 using WireMock.Admin.Mappings;
+using WireMock.RequestBuilders;
+using WireMock.ResponseBuilders;
 using WireMock.Server;
 
 namespace Unity.Services.Cli.MockServer.ServiceMocks;
@@ -7,18 +13,98 @@ namespace Unity.Services.Cli.MockServer.ServiceMocks;
 public class EconomyApiMock : IServiceApiMock
 {
     const string k_EconomyOpenApiUrl = "https://services.docs.unity.com/specs/v2/65636f6e6f6d792d61646d696e.yaml";
+    public const string ValidFileName = "validname";
+
+    public static CurrencyItemResponse Currency = new CurrencyItemResponse(
+        "GOLD_COIN",
+        "Gold Coin",
+        CurrencyItemResponse.TypeEnum.CURRENCY,
+        0,
+        100,
+        "custom data",
+        new ModifiedMetadata(new DateTime(2023, 1, 1)),
+        new ModifiedMetadata(new DateTime(2023, 1, 1))
+    );
 
     public async Task<IReadOnlyList<MappingModel>> CreateMappingModels()
     {
-        var economyServiceModels = await MappingModelUtils.ParseMappingModelsAsync(k_EconomyOpenApiUrl, new());
+        var economyServiceModels =
+            await MappingModelUtils.ParseMappingModelsAsync(k_EconomyOpenApiUrl, new());
         economyServiceModels = economyServiceModels.Select(
             m => m.ConfigMappingPathWithKey(CommonKeys.ProjectIdKey, CommonKeys.ValidProjectId)
                 .ConfigMappingPathWithKey(CommonKeys.EnvironmentIdKey, CommonKeys.ValidEnvironmentId));
         return economyServiceModels.ToArray();
     }
 
+    static void MockListCloudCodeScriptEmpty(WireMockServer mockServer)
+    {
+        var response = new ListScriptsResponse(
+            new List<ListScriptsResponseResultsInner>
+            {
+            },
+            new ListScriptsResponseLinks("links")
+        );
+
+        mockServer.Given(Request.Create().WithPath("*/cloud-code/*/scripts").UsingGet())
+            .RespondWith(Response.Create().WithHeaders(new Dictionary<string, string>
+            {
+                {
+                    "Content-Type", "application/json"
+                }
+            }).WithBodyAsJson(response).WithStatusCode(HttpStatusCode.OK));
+
+        var responseModules = new ListModulesResponse(
+            new List<ListModulesResponseResultsInner> { },
+            ""
+        );
+
+        mockServer?.Given(Request.Create().WithPath("*/cloud-code/*/modules").UsingGet())
+            .RespondWith(Response.Create().WithHeaders(new Dictionary<string, string>
+            {
+                {
+                    "Content-Type", "application/json"
+                }
+            }).WithBodyAsJson(responseModules).WithStatusCode(HttpStatusCode.OK));
+    }
+
+    static void MockList(WireMockServer mockServer)
+    {
+        var response = new List<GetResourcesResponseResultsInner>
+        {
+            new GetResourcesResponseResultsInner(Currency)
+        };
+
+        GetResourcesResponse responseOut = new GetResourcesResponse(response);
+
+        mockServer.Given(Request.Create()
+                .WithPath("*/economy/v2/projects/*/environments/*/configs/draft/resources")
+                .UsingGet())
+        .RespondWith(Response.Create()
+            .WithHeaders(new Dictionary<string, string> { { "Content-Type", "application/json" } })
+            .WithBodyAsJson(responseOut)
+            .WithStatusCode(HttpStatusCode.OK));
+    }
+
     public void CustomMock(WireMockServer mockServer)
     {
+        MockList(mockServer);
+        MockListCloudCodeScriptEmpty(mockServer);
+        MockListRemoteConfigEmpty(mockServer);
         mockServer.AllowPartialMapping();
     }
+
+    public static void MockListRemoteConfigEmpty(WireMockServer mockServer)
+    {
+        var getResponse = new GetResponse
+        {
+            Configs = new List<Config> { }
+        };
+        mockServer.Given(Request.Create()
+                .WithPath("/remote-config/v1/projects/*environments/*configs")
+                .UsingGet())
+            .RespondWith(Response.Create()
+                .WithHeaders(new Dictionary<string, string> { { "Content-Type", "application/json" } })
+                .WithBodyAsJson(getResponse)
+                .WithStatusCode(HttpStatusCode.OK));
+    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/GameServerHosting/GameServerHostingApiMock.cs b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/GameServerHosting/GameServerHostingApiMock.cs
new file mode 100644
index 0000000..885f49b
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/GameServerHosting/GameServerHostingApiMock.cs
@@ -0,0 +1,255 @@
+using System.Net;
+using Unity.Services.Cli.MockServer.Common;
+using Unity.Services.Gateway.GameServerHostingApiV1.Generated.Model;
+using WireMock.Admin.Mappings;
+using WireMock.Net.OpenApiParser.Settings;
+using WireMock.RequestBuilders;
+using WireMock.ResponseBuilders;
+using WireMock.Server;
+
+namespace Unity.Services.Cli.MockServer.ServiceMocks.GameServerHosting;
+
+public class GameServerHostingApiMock : IServiceApiMock
+{
+    public async Task<IReadOnlyList<MappingModel>> CreateMappingModels()
+    {
+        var models = await MappingModelUtils.ParseMappingModelsAsync(
+            "https://services.docs.unity.com/specs/v1/6d756c7469706c61792d636f6e666967.yaml",
+            new WireMockOpenApiParserSettings()
+        );
+
+        models = models.Select(
+            m => m
+                .ConfigMappingPathWithKey(CommonKeys.ProjectIdKey, CommonKeys.ValidProjectId)
+                .ConfigMappingPathWithKey(CommonKeys.EnvironmentIdKey, CommonKeys.ValidEnvironmentId)
+        );
+
+        return models.ToArray();
+    }
+
+    public void CustomMock(WireMockServer mockServer)
+    {
+        MockFleetGet(mockServer);
+        MockServerGet(mockServer);
+        MockServerList(mockServer);
+        MockBuildInstalls(mockServer);
+        MockBuild(mockServer);
+        MockBuildList(mockServer);
+        MockBuildCreateResponse(mockServer);
+    }
+
+    static void MockFleetGet(WireMockServer mockServer)
+    {
+        var fleet = new Fleet(
+            name: "Test Fleet",
+            id: Guid.Parse(Keys.ValidFleetId),
+            osFamily: Fleet.OsFamilyEnum.LINUX,
+            osName: "Ubuntu 20.04",
+            status: Fleet.StatusEnum.OFFLINE,
+            buildConfigurations: new List<BuildConfiguration2>(),
+            fleetRegions: new List<FleetRegion1>(),
+            servers: new Servers(
+                new FleetServerBreakdown(new ServerStatus()),
+                new FleetServerBreakdown(new ServerStatus()),
+                new FleetServerBreakdown(new ServerStatus())
+            ),
+            allocationTTL: 0,
+            deleteTTL: 0,
+            disabledDeleteTTL: 0,
+            shutdownTTL: 0
+        );
+
+        var request = Request.Create()
+            .WithPath(Keys.ValidFleetPath)
+            .UsingGet();
+
+        var response = Response.Create()
+            .WithBodyAsJson(fleet)
+            .WithStatusCode(HttpStatusCode.OK);
+
+        mockServer.Given(request).RespondWith(response);
+    }
+
+    static void MockServerGet(WireMockServer mockServer)
+    {
+        var server = new Server(
+            buildConfigurationID: Keys.ValidBuildConfigurationId,
+            buildConfigurationName: "Test Build Configuration",
+            buildName: "Test Build",
+            deleted: false,
+            fleetID: Guid.Parse(Keys.ValidFleetId),
+            fleetName: "Test Fleet",
+            hardwareType: Server.HardwareTypeEnum.CLOUD,
+            id: Int64.Parse(Keys.ValidServerId),
+            ip: "1.1.1.1",
+            locationID: 0,
+            locationName: "Test Location",
+            machineID: 123,
+            port: 0,
+            status: Server.StatusEnum.ONLINE
+        );
+
+        var request = Request.Create()
+            .WithPath(Keys.ValidServersPath)
+            .UsingGet();
+
+        var response = Response.Create()
+            .WithBodyAsJson(server);
+
+        mockServer.Given(request).RespondWith(response);
+    }
+
+    static void MockServerList(WireMockServer mockServer)
+    {
+        var servers = new List<Server>
+        {
+            new(
+                buildConfigurationID: Keys.ValidBuildConfigurationId,
+                buildConfigurationName: "Test Build Configuration",
+                buildName: "Test Build",
+                deleted: false,
+                fleetID: Guid.Parse(Keys.ValidFleetId),
+                fleetName: "Test Fleet",
+                hardwareType: Server.HardwareTypeEnum.CLOUD,
+                id: Int64.Parse(Keys.ValidServerId),
+                ip: "1.1.1.1",
+                locationID: 0,
+                locationName: "Test Location",
+                machineID: 123,
+                port: 0,
+                status: Server.StatusEnum.ONLINE
+            )
+        };
+
+        var request = Request.Create()
+            .WithPath(Keys.ServersPath)
+            .UsingGet();
+
+        var response = Response.Create()
+            .WithBodyAsJson(servers)
+            .WithStatusCode(HttpStatusCode.OK);
+
+        mockServer.Given(request).RespondWith(response);
+    }
+    static void MockBuildList(WireMockServer mockServer)
+    {
+        Console.WriteLine(Keys.ValidBuildPath);
+        var build = new List<BuildListInner>
+        {
+            new(
+                1,
+                11,
+                "Build1",
+                ccd: new CCDDetails(
+                    new Guid(Keys.ValidBucketId),
+                    new Guid(Keys.ValidRegionId)),
+                osFamily: BuildListInner.OsFamilyEnum.LINUX,
+                syncStatus: BuildListInner.SyncStatusEnum.SYNCED,
+                updated: new DateTime(2022, 10, 11)),
+            new(
+                2,
+                22,
+                "Build2",
+                container: new ContainerImage("v1"),
+                osFamily: BuildListInner.OsFamilyEnum.LINUX,
+                syncStatus: BuildListInner.SyncStatusEnum.SYNCED,
+                updated: new DateTime(2022, 10, 11))
+        };
+        var request = Request.Create()
+            .WithPath(Keys.BuildsPath)
+            .UsingGet();
+
+        var response = Response.Create()
+            .WithBodyAsJson(build)
+            .WithStatusCode(HttpStatusCode.OK);
+
+        mockServer.Given(request).RespondWith(response);
+    }
+
+    static void MockBuild(WireMockServer mockServer)
+    {
+        Console.WriteLine(Keys.ValidBuildPath);
+        var build = new CreateBuild200Response(
+            1,
+            "name1",
+            CreateBuild200Response.BuildTypeEnum.S3,
+            ccd: new CCDDetails()
+        );
+        var request = Request.Create()
+            .WithPath(Keys.ValidBuildPath)
+            .UsingGet();
+
+        var response = Response.Create()
+            .WithBodyAsJson(build)
+            .WithStatusCode(HttpStatusCode.OK);
+
+        mockServer.Given(request).RespondWith(response);
+    }
+
+    static void MockBuildInstalls(WireMockServer mockServer)
+    {
+        var buildInstalls = new List<BuildListInner1>
+        {
+            new BuildListInner1(
+                new CCDDetails(
+                    Guid.Parse(Keys.ValidBucketId),
+                    Guid.Parse(Keys.ValidReleaseId)
+                ),
+                completedMachines: 1,
+                container: new ContainerImage(
+                    "tag"
+                ),
+                failures: new List<BuildListInner1FailuresInner>
+                {
+                    new(
+                        1234,
+                        "failure",
+                        DateTime.Now
+                    )
+                },
+                fleetName: "fleet name",
+                pendingMachines: 1,
+                regions: new List<RegionsInner>
+                {
+                    new(
+                        1,
+                        1,
+                        1,
+                        "region name"
+                    )
+                }
+            )
+        };
+        var request = Request.Create()
+            .WithPath(Keys.ValidBuildInstallsPath)
+            .UsingGet();
+
+        var response = Response.Create()
+            .WithBodyAsJson(buildInstalls)
+            .WithStatusCode(HttpStatusCode.OK);
+        mockServer.Given(request).RespondWith(response);
+    }
+
+    static void MockBuildCreateResponse(WireMockServer mockServer)
+    {
+        var build = new CreateBuild200Response(
+            1,
+            "Build1",
+            ccd: new CCDDetails(
+                new Guid(Keys.ValidBucketId),
+                new Guid(Keys.ValidReleaseId)
+            ),
+            osFamily: CreateBuild200Response.OsFamilyEnum.LINUX,
+            syncStatus: CreateBuild200Response.SyncStatusEnum.SYNCED,
+            updated: new DateTime(2022, 10, 11)
+        );
+        var request = Request.Create()
+            .WithPath(Keys.BuildsPath)
+            .UsingPost();
+
+        var response = Response.Create()
+            .WithBodyAsJson(build)
+            .WithStatusCode(HttpStatusCode.OK);
+        mockServer.Given(request).RespondWith(response);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/GameServerHosting/Keys.cs b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/GameServerHosting/Keys.cs
new file mode 100644
index 0000000..a5f5622
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/GameServerHosting/Keys.cs
@@ -0,0 +1,31 @@
+using Unity.Services.Cli.MockServer.Common;
+
+namespace Unity.Services.Cli.MockServer.ServiceMocks.GameServerHosting;
+
+public static class Keys
+{
+    public const string FleetIdKey = "fleets";
+
+    public const long ValidBuildConfigurationId = 1;
+    public const string ValidFleetId = "00000000-0000-0000-1000-000000000000";
+    public const string ValidRegionId = "00000000-0000-0000-0000-100000000000";
+    public const string ValidTemplateRegionId = "00000000-0000-0000-0000-1a0000000000";
+    public const long ValidBuildId = 1;
+    public const string ValidBucketId = "00000000-0000-0000-0000-000000000000";
+    public const string ValidReleaseId = "00000000-0000-0000-0000-000000000000";
+
+    public const string ValidServerId = "123";
+
+    public const string ProjectPathPart =
+        $"projects/{CommonKeys.ValidProjectId}/environments/{CommonKeys.ValidEnvironmentId}";
+
+    public const string FleetsPath = $"/multiplay/fleets/v1/{ProjectPathPart}/fleets";
+    public const string ServersPath = $"/multiplay/servers/v1/{ProjectPathPart}/servers";
+
+    public const string ValidFleetPath = $"{FleetsPath}/{ValidFleetId}";
+    public const string ValidServersPath = $"{ServersPath}/{ValidServerId}";
+
+    public const string BuildsPath = $"/multiplay/builds/v1/{ProjectPathPart}/builds";
+    public static readonly string ValidBuildPath = $"{BuildsPath}/{ValidBuildId}";
+    public static readonly string ValidBuildInstallsPath = $"{ValidBuildPath}/installs";
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/LeaderboardApiMock.cs b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/LeaderboardApiMock.cs
index 1b9a882..75d1d8e 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/LeaderboardApiMock.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/LeaderboardApiMock.cs
@@ -10,8 +10,9 @@ namespace Unity.Services.Cli.MockServer.ServiceMocks;
 
 public class LeaderboardApiMock : IServiceApiMock
 {
-    const string k_LeaderboardPath = "/leaderboards/v1beta1";
+    const string k_LeaderboardPath = "/leaderboards/v1";
     static readonly string k_Leaderboard1VersionId = "v10";
+
     public static readonly UpdatedLeaderboardConfig Leaderboard1 = new(
         "lb1",
         "leaderboard 1",
@@ -30,6 +31,106 @@ public class LeaderboardApiMock : IServiceApiMock
         10,
         new ResetConfig(new DateTime(2023, 1, 1), "@1d", true)
     );
+    public static readonly UpdatedLeaderboardConfig Leaderboard3 = new(
+        "lb3",
+        "leaderboard 3",
+        SortOrder.Asc,
+        UpdateType.Aggregate,
+        10,
+        new ResetConfig(new DateTime(2023, 1, 1), "@1d", true),
+        new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>(){new TieringConfigTiersInner("tier1", 2)}),
+        versions: new List<LeaderboardVersion>()
+    );
+    public static readonly UpdatedLeaderboardConfig Leaderboard4 = new(
+        "lb4",
+        "leaderboard 4",
+        SortOrder.Asc,
+        UpdateType.Aggregate,
+        10,
+        new ResetConfig(new DateTime(2023, 1, 1), "@1d", true),
+        new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>(){new TieringConfigTiersInner("tier1", 2)}),
+        versions: new List<LeaderboardVersion>()
+    );
+    public static readonly UpdatedLeaderboardConfig Leaderboard5 = new(
+        "lb5",
+        "leaderboard 5",
+        SortOrder.Asc,
+        UpdateType.Aggregate,
+        10,
+        new ResetConfig(new DateTime(2023, 1, 1), "@1d", true),
+        new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>(){new TieringConfigTiersInner("tier1", 2)}),
+        versions: new List<LeaderboardVersion>()
+    );
+    public static readonly UpdatedLeaderboardConfig Leaderboard6 = new(
+        "lb6",
+        "leaderboard 6",
+        SortOrder.Asc,
+        UpdateType.Aggregate,
+        10,
+        new ResetConfig(new DateTime(2023, 1, 1), "@1d", true),
+        new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>(){new TieringConfigTiersInner("tier1", 2)}),
+        versions: new List<LeaderboardVersion>()
+    );
+    public static readonly UpdatedLeaderboardConfig Leaderboard7 = new(
+        "lb7",
+        "leaderboard 7",
+        SortOrder.Asc,
+        UpdateType.Aggregate,
+        10,
+        new ResetConfig(new DateTime(2023, 1, 1), "@1d", true),
+        new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>(){new TieringConfigTiersInner("tier1", 2)}),
+        versions: new List<LeaderboardVersion>()
+    );
+    public static readonly UpdatedLeaderboardConfig Leaderboard8 = new(
+        "lb8",
+        "leaderboard 8",
+        SortOrder.Asc,
+        UpdateType.Aggregate,
+        10,
+        new ResetConfig(new DateTime(2023, 1, 1), "@1d", true),
+        new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>(){new TieringConfigTiersInner("tier1", 2)}),
+        versions: new List<LeaderboardVersion>()
+    );
+    public static readonly UpdatedLeaderboardConfig Leaderboard9 = new(
+        "lb9",
+        "leaderboard 9",
+        SortOrder.Asc,
+        UpdateType.Aggregate,
+        10,
+        new ResetConfig(new DateTime(2023, 1, 1), "@1d", true),
+        new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>(){new TieringConfigTiersInner("tier1", 2)}),
+        versions: new List<LeaderboardVersion>()
+    );
+    public static readonly UpdatedLeaderboardConfig Leaderboard10 = new(
+        "lb10",
+        "leaderboard 10",
+        SortOrder.Asc,
+        UpdateType.Aggregate,
+        10,
+        new ResetConfig(new DateTime(2023, 1, 1), "@1d", true),
+        new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>(){new TieringConfigTiersInner("tier1", 2)}),
+        versions: new List<LeaderboardVersion>()
+    );
+    public static readonly UpdatedLeaderboardConfig Leaderboard11 = new(
+        "lb11",
+        "leaderboard 11",
+        SortOrder.Asc,
+        UpdateType.Aggregate,
+        10,
+        new ResetConfig(new DateTime(2023, 1, 1), "@1d", true),
+        new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>(){new TieringConfigTiersInner("tier1", 2)}),
+        versions: new List<LeaderboardVersion>()
+    );
+    public static readonly UpdatedLeaderboardConfig Leaderboard12 = new(
+        "lb12",
+        "leaderboard 12",
+        SortOrder.Asc,
+        UpdateType.Aggregate,
+        10,
+        new ResetConfig(new DateTime(2023, 1, 1), "@1d", true),
+        new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>(){new TieringConfigTiersInner("tier1", 2)}),
+        versions: new List<LeaderboardVersion>()
+    );
 
     readonly string BaseUrl;
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/RemoteConfig/RemoteConfigMock.cs b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/RemoteConfig/RemoteConfigMock.cs
index 95bac14..fd8774c 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/RemoteConfig/RemoteConfigMock.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/ServiceMocks/RemoteConfig/RemoteConfigMock.cs
@@ -2,6 +2,7 @@
 using Unity.Services.Cli.Common.Networking;
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
+using Unity.Services.Gateway.EconomyApiV2.Generated.Model;
 using WireMock.Admin.Mappings;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
@@ -33,7 +34,8 @@ public RemoteConfigMock()
         UpdateConfigUrl = $"{k_RemoteConfigPath}/projects/{m_ProjectId}/configs";
         GetAllConfigsUrl = $"{k_RemoteConfigPath}/projects/{m_ProjectId}/environments/{m_EnvironmentId}/configs";
         DeleteConfigUrl = $"{k_RemoteConfigPath}/projects/{m_ProjectId}/configs";
-        m_Config = new() {
+        m_Config = new()
+        {
             ProjectId = m_ProjectId,
             EnvironmentId = m_EnvironmentId,
             Type = ConfigTypeDefaultValue,
@@ -60,12 +62,34 @@ public Task<IReadOnlyList<MappingModel>> CreateMappingModels()
     public void CustomMock(WireMockServer mockServer)
     {
         MockListCloudCodeScriptEmpty(mockServer);
+        MockListEconomyResourceEmpty(mockServer);
         MockGetAllConfigsFromEnvironmentAsync(mockServer, ConfigId);
         MockUpdateConfigAsync(mockServer, ConfigId);
         MockDeleteConfigAsync(mockServer, ConfigId);
     }
 
-    void MockListCloudCodeScriptEmpty(WireMockServer mockServer)
+    static void MockListEconomyResourceEmpty(WireMockServer mockServer)
+    {
+        var publishedResourcesResponse = new GetPublishedResourcesResponse(new List<GetResourcesResponseResultsInner>());
+        mockServer.Given(Request.Create().WithPath($"*/economy/v2/projects/{CommonKeys.ValidProjectId}/environments/{CommonKeys.ValidEnvironmentId}/configs/published/resources").UsingGet())
+            .RespondWith(Response.Create().WithHeaders(new Dictionary<string, string>
+            {
+                {
+                    "Content-Type", "application/json"
+                }
+            }).WithBodyAsJson(publishedResourcesResponse).WithStatusCode(HttpStatusCode.OK));
+
+        var resourcesResponse = new GetResourcesResponse(new List<GetResourcesResponseResultsInner>());
+        mockServer.Given(Request.Create().WithPath($"*/economy/v2/projects/{CommonKeys.ValidProjectId}/environments/{CommonKeys.ValidEnvironmentId}/configs/draft/resources").UsingGet())
+            .RespondWith(Response.Create().WithHeaders(new Dictionary<string, string>
+            {
+                {
+                    "Content-Type", "application/json"
+                }
+            }).WithBodyAsJson(resourcesResponse).WithStatusCode(HttpStatusCode.OK));
+    }
+
+    static void MockListCloudCodeScriptEmpty(WireMockServer mockServer)
     {
         var response = new ListScriptsResponse(
             new List<ListScriptsResponseResultsInner>
@@ -88,7 +112,7 @@ public void MockGetAllConfigsFromEnvironmentAsync(WireMockServer mockServer, str
         m_Config.Id = configId;
         mockServer.Given(Request.Create().WithPath(GetAllConfigsUrl).UsingGet())
             .RespondWith(Response.Create()
-                .WithHeaders(new Dictionary<string, string> {{"Content-Type","application/json"}})
+                .WithHeaders(new Dictionary<string, string> { { "Content-Type", "application/json" } })
                 .WithBodyAsJson(m_GetResponse)
                 .WithStatusCode(HttpStatusCode.OK));
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/Unity.Services.Cli.Integration.MockServer.csproj b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/Unity.Services.Cli.Integration.MockServer.csproj
index eec6901..23431a4 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/Unity.Services.Cli.Integration.MockServer.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServer/Unity.Services.Cli.Integration.MockServer.csproj
@@ -9,7 +9,8 @@
     <SonarQubeExclude>true</SonarQubeExclude>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.1.0" />
+    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.2.0" />
+    <PackageReference Include="Unity.Services.Gateway.LeaderboardApiV1.Generated" Version="1.0.7-beta" />
     <PackageReference Include="WireMock.Net" Version="1.5.21" />
     <PackageReference Include="WireMock.Net.OpenApiParser" Version="1.5.18" />
   </ItemGroup>
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServerApp/Program.cs b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServerApp/Program.cs
index a720d83..f80795f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServerApp/Program.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Integration.MockServerApp/Program.cs
@@ -2,6 +2,7 @@
 using Unity.Services.Cli.MockServer;
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Cli.MockServer.ServiceMocks;
+using Unity.Services.Cli.MockServer.ServiceMocks.CloudCode;
 
 namespace Unity.Services.Cli.Integration.MockServerApp;
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/AccessTests/AccessTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/AccessTests/AccessTests.cs
index 03167d4..80720f8 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/AccessTests/AccessTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/AccessTests/AccessTests.cs
@@ -1,11 +1,13 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Connections;
 using Newtonsoft.Json;
 using NUnit.Framework;
 using Unity.Services.Cli.Common.Exceptions;
 using Unity.Services.Cli.Common.Models;
 using Unity.Services.Cli.Common.Networking;
+using Unity.Services.Cli.IntegrationTest.Common;
 using Unity.Services.Cli.MockServer;
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Cli.MockServer.ServiceMocks;
@@ -15,8 +17,7 @@ namespace Unity.Services.Cli.IntegrationTest.AccessTests;
 
 public class AccessTests : UgsCliFixture
 {
-
-    private const string k_FilePath = "policy.json";
+    const string k_FilePath = "policy.json";
     const string k_ProjectIdNotSetErrorMessage = "'project-id' is not set in project configuration."
                                                  + " '" + Keys.EnvironmentKeys.ProjectId + "' is not set in system environment variables.";
     const string k_LoggedOutErrorMessage = "You are not logged into any service account."
@@ -26,7 +27,7 @@ public class AccessTests : UgsCliFixture
 
     readonly string k_TestDirectory = Path.GetFullPath(Path.Combine(UgsCliBuilder.RootDirectory, "Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/AccessTests/Data/"));
 
-    private const string k_RequiredArgumentMissing = "Required argument missing for command";
+    const string k_RequiredArgumentMissing = "Required argument missing for command";
 
     [SetUp]
     public async Task SetUp()
@@ -63,7 +64,7 @@ public async Task AccessCommandsThrowsNotLoggedInException(string command)
         await new UgsCliTestCase()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_LoggedOutErrorMessage)
+            .AssertStandardErrorContains(k_LoggedOutErrorMessage)
             .ExecuteAsync();
     }
 
@@ -97,7 +98,7 @@ public async Task AccessGetProjectPolicyReturnsZeroExitCode()
     {
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
-        await AssertSuccess("access get-project-policy", "\"statements\": []");
+        await AssertSuccess("access get-project-policy", expectedStdOut: "\"statements\": []");
     }
 
     // access get-player-policy
@@ -113,7 +114,7 @@ public async Task AccessGetPlayerPolicyReturnsZeroExitCode()
             statements = new List<Statement>()
         };
 
-        await AssertSuccess($"access get-player-policy {AccessApiMock.PlayerId}", JsonConvert.SerializeObject(playerPolicy, Formatting.Indented));
+        await AssertSuccess($"access get-player-policy {AccessApiMock.PlayerId}", expectedStdOut: JsonConvert.SerializeObject(playerPolicy, Formatting.Indented));
     }
 
     // access get-all-player-policies
@@ -132,7 +133,7 @@ public async Task AccessGetAllPlayerPoliciesReturnsZeroExitCode()
         List<object> obj = new List<object>();
         obj.Add(playerPolicy);
 
-        await AssertSuccess("access get-all-player-policies", JsonConvert.SerializeObject(obj, Formatting.Indented));
+        await AssertSuccess("access get-all-player-policies", expectedStdOut: JsonConvert.SerializeObject(obj, Formatting.Indented));
     }
 
     // access upsert-project-policy
@@ -185,22 +186,29 @@ public static IEnumerable<string> AccessModuleCommands
             yield return $"access delete-player-policy-statements {AccessApiMock.PlayerId} policy.json";
         }
     }
-
-    private static async Task AssertSuccess(string command, string expectedMessage)
+    
+    static async Task AssertSuccess(string command, string? expectedStdErr = null, string? expectedStdOut = null)
     {
-        await GetLoggedInCli()
-            .Command(command)
-            .AssertNoErrors()
-            .AssertStandardOutputContains(expectedMessage)
-            .ExecuteAsync();
+        var test = GetLoggedInCli()
+            .Command(command);
+        if (expectedStdErr != null)
+        {
+            test = test.AssertStandardErrorContains(expectedStdErr);
+        }
+
+        if (expectedStdOut != null)
+        {
+            test = test.AssertStandardOutputContains(expectedStdOut);
+        }
+        await test.ExecuteAsync();
     }
 
-    private static async Task AssertException(string command, string expectedMessage)
+    static async Task AssertException(string command, string expectedMessage)
     {
         await GetLoggedInCli()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMessage)
+            .AssertStandardErrorContains(expectedMessage)
             .ExecuteAsync();
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/AuthTests/AuthTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/AuthTests/AuthTests.cs
index 2cd4a3d..99b640a 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/AuthTests/AuthTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/AuthTests/AuthTests.cs
@@ -3,6 +3,7 @@
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 using NUnit.Framework;
+using Unity.Services.Cli.IntegrationTest.Common;
 using Unity.Services.Cli.MockServer.Common;
 
 namespace Unity.Services.Cli.IntegrationTest.AuthTests;
@@ -29,7 +30,6 @@ public void TearDown()
     public async Task AuthLoginWithCredentialsSavesToken()
     {
         await GetLoggedInCli()
-            .AssertNoErrors()
             .WaitForExit(() => AssertToken(CommonKeys.ValidAccessToken))
             .ExecuteAsync();
     }
@@ -55,9 +55,8 @@ public async Task AuthLogoutRemovesToken()
     {
         await GetLoggedInCli()
             .Command("logout")
-            .AssertNoErrors()
             .WaitForExit(AssertTokenNotSaved)
-            .AssertStandardOutputContains("Service Account key cleared from local configuration.")
+            .AssertStandardErrorContains("Service Account key cleared from local configuration.")
             .ExecuteAsync();
     }
 
@@ -67,9 +66,8 @@ public async Task AuthLogoutWithCredentialEnvironmentVariablesSetPrintsLoggedOut
         LoginWithEnvironment();
         await GetLoggedInCli()
             .Command("logout")
-            .AssertNoErrors()
             .WaitForExit(AssertTokenNotSaved)
-            .AssertStandardOutput(output =>
+            .AssertStandardError(output =>
                 {
                     StringAssert.Contains("Service Account key cleared from local configuration.", output);
                     StringAssert.Contains("Because UGS_CLI_SERVICE_KEY_ID and" +
@@ -85,8 +83,7 @@ public async Task AuthStatusReturnsLoggedOut()
     {
         await new UgsCliTestCase()
             .Command("status")
-            .AssertNoErrors()
-            .AssertStandardOutputContains("No Service Account key stored.")
+            .AssertStandardErrorContains("No Service Account key stored.")
             .ExecuteAsync();
     }
 
@@ -95,8 +92,7 @@ public async Task AuthStatusReturnsLoggedIn()
     {
         await GetLoggedInCli()
             .Command("status")
-            .AssertNoErrors()
-            .AssertStandardOutputContains("Using Service Account key from local configuration.")
+            .AssertStandardErrorContains("Using Service Account key from local configuration.")
             .ExecuteAsync();
     }
 
@@ -106,8 +102,7 @@ public async Task AuthStatusReturnsLoggedInWithLocalConfiguration()
         LoginWithEnvironment();
         await GetLoggedInCli()
             .Command("status")
-            .AssertNoErrors()
-            .AssertStandardOutputContains("Using Service Account key from local configuration.")
+            .AssertStandardErrorContains("Using Service Account key from local configuration.")
             .ExecuteAsync();
     }
 
@@ -117,8 +112,7 @@ public async Task AuthStatusReturnsLoggedInWithEnvironmentVariables()
         LoginWithEnvironment();
         await new UgsCliTestCase()
             .Command("status")
-            .AssertNoErrors()
-            .AssertStandardOutputContains("Using Service Account key from system environment variables.")
+            .AssertStandardErrorContains("Using Service Account key from system environment variables.")
             .ExecuteAsync();
     }
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/AuthoringTestCase.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/AuthoringTestCase.cs
index 4f2c722..36ad5ee 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/AuthoringTestCase.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/AuthoringTestCase.cs
@@ -1,5 +1,6 @@
 using System.IO;
 using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.DeploymentApi.Editor;
 
 namespace Unity.Services.Cli.IntegrationTest.Authoring;
 
@@ -8,7 +9,7 @@ public class AuthoringTestCase
     public readonly string ConfigValue;
     public readonly string ConfigFileName;
     public readonly string ConfigFilePath;
-    public readonly DeployContent DeployedContent;
+    public DeployContent DeployedContent;
     public AuthoringTestCase(
         string configValue,
         string configFileName,
@@ -16,11 +17,29 @@ public AuthoringTestCase(
         float progress,
         string status,
         string detail,
-        string directoryPath)
+        string directoryPath,
+        SeverityLevel level = SeverityLevel.None)
     {
         ConfigValue = configValue;
         ConfigFileName = configFileName;
         ConfigFilePath = Path.Combine(directoryPath, ConfigFileName);
+        DeployedContent =
+            new DeployContent(ConfigFileName, configType, ConfigFilePath, progress, status, detail, level);
+    }
+
+    public AuthoringTestCase(
+        string configValue,
+        string configName,
+        string configFileName,
+        string configType,
+        float progress,
+        string status,
+        string detail,
+        string directoryPath)
+    {
+        ConfigValue = configValue;
+        ConfigFileName = configName;
+        ConfigFilePath = Path.Combine(directoryPath, configFileName);
         DeployedContent =
             new DeployContent(ConfigFileName, configType, ConfigFilePath, progress, status, detail);
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/CloudCode/CloudCodeDeployTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/CloudCode/CloudCodeDeployTests.cs
index 565377c..6e5968a 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/CloudCode/CloudCodeDeployTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/CloudCode/CloudCodeDeployTests.cs
@@ -8,6 +8,8 @@
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Cli.MockServer.ServiceMocks;
+using Unity.Services.DeploymentApi.Editor;
+using Unity.Services.Cli.MockServer.ServiceMocks.CloudCode;
 
 namespace Unity.Services.Cli.IntegrationTest.Authoring.Deploy.CloudCode;
 
@@ -20,22 +22,24 @@ public class CloudCodeDeployTests : UgsCliFixture
         new AuthoringTestCase(
             "module.exports = () => {}\n module.exports.params = { sides: 'NUMERIC'};",
             $"{CloudCodeV1Mock.ValidScriptName}.js",
-            "Cloud Code",
+            "Cloud Code Scripts",
             100,
             "Up to date",
             "",
-            k_TestDirectory),
+            k_TestDirectory,
+            SeverityLevel.Success)
     };
     readonly IReadOnlyList<AuthoringTestCase> m_ReconcileTestCases = new[]
     {
         new AuthoringTestCase(
             "module.exports = () => {}\n module.exports.params = { sides: 'NUMERIC'};",
             $"{CloudCodeV1Mock.ValidScriptName}.js",
-            "Cloud Code",
+            "Cloud Code Scripts",
             100,
             "Up to date",
             "",
-            k_TestDirectory)
+            k_TestDirectory,
+            SeverityLevel.Success)
     };
 
     readonly IReadOnlyList<AuthoringTestCase> m_DryRunDeployedTestCases = new[]
@@ -43,7 +47,7 @@ public class CloudCodeDeployTests : UgsCliFixture
         new AuthoringTestCase(
             "module.exports = () => {}\n module.exports.params = { sides: 'NUMERIC'};",
             "dry_script.js",
-            "Cloud Code",
+            "Cloud Code Scripts",
             0,
             "Loaded",
             "",
@@ -92,10 +96,10 @@ public async Task DeployValidConfigFromDirectorySucceed()
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await CreateDeployTestFilesAsync(m_DeployedTestCases, m_DeployedContents);
-        var deployedConfigFileString = string.Join(Environment.NewLine + "    ", m_DeployedTestCases.Select(a=>a.ConfigFileName));
+        var deployedConfigFileString = string.Join(Environment.NewLine + "    ", m_DeployedTestCases.Select(a => $"'{a.ConfigFilePath}'"));
         await GetLoggedInCli()
             .Command($"deploy {k_TestDirectory}")
-            .AssertStandardOutputContains($"Deployed:{Environment.NewLine}    {deployedConfigFileString}")
+            .AssertStandardOutputContains($"Successfully deployed the following files:{Environment.NewLine}    {deployedConfigFileString}")
             .AssertNoErrors()
             .ExecuteAsync();
     }
@@ -106,12 +110,12 @@ public async Task DeployValidConfigFromDirectorySucceedWithJsonOutput()
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await CreateDeployTestFilesAsync(m_DeployedTestCases, m_DeployedContents);
-        var logResult = new JsonDeployLogResult(CreateResult(
+        var logResult = DeployTestsFixture.CreateResult(
             m_DeployedContents,
             Array.Empty<DeployContent>(),
             Array.Empty<DeployContent>(),
             m_DeployedContents,
-            Array.Empty<DeployContent>()));
+            Array.Empty<DeployContent>());
         var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
         await GetLoggedInCli()
             .Command($"deploy {k_TestDirectory} -j")
@@ -127,13 +131,13 @@ public async Task DeployConfig_DryRun()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await CreateDeployTestFilesAsync(m_DryRunDeployedTestCases, m_DryRunContents);
 
-        var logResult = new JsonDeployLogResult(new DeploymentResult(
-            m_DryRunContents,
+        var logResult = new DeploymentResult(
             Array.Empty<DeployContent>(),
             Array.Empty<DeployContent>(),
+            m_DryRunContents,
             Array.Empty<DeployContent>(),
             Array.Empty<DeployContent>(),
-            true));
+            true);
         var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
         await GetLoggedInCli()
             .Command($"deploy {k_TestDirectory} -j --dry-run")
@@ -149,22 +153,24 @@ public async Task DeployWithReconcileWillDeleteRemoteFiles()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await CreateDeployTestFilesAsync(m_ReconcileTestCases, m_DeployedContents);
 
-        var logResult = new JsonDeployLogResult(CreateResult(
+        var deletedStatus = new DeploymentStatus("Deployed", "Deleted remotely", SeverityLevel.Success);
+
+        var logResult = DeployTestsFixture.CreateResult(
             m_DeployedContents,
             Array.Empty<DeployContent>(),
             new[]
             {
-                new DeployContent("example-string.js", "JS", ""),
-                new DeployContent("example-string.js", "JS", ""),
-                new DeployContent("example-string.js", "JS", ""),
-                new DeployContent("ExistingModule.ccm", "JS", ""),
-                new DeployContent("AnotherExistingModule.ccm", "JS", ""),
+                new DeployContent("example-string.js", "Cloud Code Scripts", "", 100, deletedStatus),
+                new DeployContent("example-string.js", "Cloud Code Scripts", "",100, deletedStatus),
+                new DeployContent("example-string.js", "Cloud Code Scripts", "", 100, deletedStatus),
+                new DeployContent("ExistingModule.ccm", "JS", "", 100, deletedStatus),
+                new DeployContent("AnotherExistingModule.ccm", "JS", "", 100, deletedStatus),
             },
             m_DeployedContents,
-            Array.Empty<DeployContent>()));
+            Array.Empty<DeployContent>());
         var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
         await GetLoggedInCli()
-            .Command($"deploy {k_TestDirectory} -j --reconcile")
+            .Command($"deploy {k_TestDirectory} -j --reconcile -s cloud-code-scripts -s cloud-code-modules")
             .AssertStandardOutputContains(resultString)
             .AssertNoErrors()
             .ExecuteAsync();
@@ -177,12 +183,12 @@ public async Task DeployWithoutReconcileWillNotDeleteRemoteFiles()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await CreateDeployTestFilesAsync(m_ReconcileTestCases, m_DeployedContents);
 
-        var logResult = new JsonDeployLogResult(CreateResult(
+        var logResult = DeployTestsFixture.CreateResult(
             m_DeployedContents,
             Array.Empty<DeployContent>(),
             Array.Empty<DeployContent>(),
             m_DeployedContents,
-            Array.Empty<DeployContent>()));
+            Array.Empty<DeployContent>());
         var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
         await GetLoggedInCli()
             .Command($"deploy {k_TestDirectory} -j")
@@ -200,32 +206,4 @@ static async Task CreateDeployTestFilesAsync(IReadOnlyList<AuthoringTestCase> te
             contents.Add(testCase.DeployedContent);
         }
     }
-
-    static DeploymentResult CreateResult(
-        IReadOnlyCollection<DeployContent> created,
-        IReadOnlyCollection<DeployContent> updated,
-        IReadOnlyCollection<DeployContent> deleted,
-        IReadOnlyCollection<DeployContent> deployed,
-        IReadOnlyCollection<DeployContent> failed,
-        bool dryRun = false)
-    {
-        var createdCopy = new List<DeployContent>();
-
-        foreach (var createdOriginal in created)
-        {
-            var progress = createdOriginal.Progress;
-            var status = createdOriginal.Status;
-            var detail = createdOriginal.Detail;
-
-            createdCopy.Add(new DeployContent(
-                createdOriginal.Name,
-                createdOriginal.Type,
-                createdOriginal.Path,
-                progress,
-                status,
-                detail));
-        }
-
-        return new DeploymentResult(createdCopy, updated, deleted, deployed, failed, dryRun);
-    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/DeployPreconditionTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/DeployPreconditionTests.cs
index 5f80589..3f483ed 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/DeployPreconditionTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/DeployPreconditionTests.cs
@@ -4,6 +4,7 @@
 using NUnit.Framework;
 using Unity.Services.Cli.Common.Exceptions;
 using Unity.Services.Cli.Common.Networking;
+using Unity.Services.Cli.IntegrationTest.Common;
 using Unity.Services.Cli.MockServer;
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Cli.MockServer.ServiceMocks;
@@ -32,7 +33,7 @@ public async Task DeployInvalidPath()
 
         await GetLoggedInCli()
             .Command($"deploy {invalidDirectory}")
-            .AssertStandardOutputContains(expectedOutput)
+            .AssertStandardErrorContains(expectedOutput)
             .AssertExitCode(ExitCode.HandledError)
             .ExecuteAsync();
     }
@@ -43,7 +44,7 @@ public async Task DeployWithoutEnvironmentConfig()
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
         await GetLoggedInCli()
             .Command($"deploy .")
-            .AssertStandardOutputContains($"[Error]: {Environment.NewLine}    'environment-name' is not set")
+            .AssertStandardErrorContains($"[Error]: {Environment.NewLine}    'environment-name' is not set")
             .AssertExitCode(ExitCode.HandledError)
             .ExecuteAsync();
     }
@@ -54,7 +55,7 @@ public async Task DeployWithoutProjectConfig()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await GetLoggedInCli()
             .Command($"deploy .")
-            .AssertStandardOutputContains($"[Error]: {Environment.NewLine}    'project-id' is not set")
+            .AssertStandardErrorContains($"[Error]: {Environment.NewLine}    'project-id' is not set")
             .AssertExitCode(ExitCode.HandledError)
             .ExecuteAsync();
     }
@@ -67,7 +68,7 @@ public async Task DeployWithoutLogin()
 
         await new UgsCliTestCase()
             .Command($"deploy .")
-            .AssertStandardOutputContains($"[Error]: {Environment.NewLine}    You are not logged into any service account. Please login using the 'ugs login' command.")
+            .AssertStandardErrorContains($"[Error]: {Environment.NewLine}    You are not logged into any service account. Please login using the 'ugs login' command.")
             .AssertExitCode(ExitCode.HandledError)
             .ExecuteAsync();
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/RemoteConfig/RemoteConfigDeployTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/RemoteConfig/RemoteConfigDeployTests.cs
index 76ae843..f43fec4 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/RemoteConfig/RemoteConfigDeployTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/RemoteConfig/RemoteConfigDeployTests.cs
@@ -7,11 +7,10 @@
 using NUnit.Framework;
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.Common.Exceptions;
-using Unity.Services.Cli.Common.Networking;
-using Unity.Services.Cli.MockServer;
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Cli.MockServer.ServiceMocks;
 using Unity.Services.Cli.MockServer.ServiceMocks.RemoteConfig;
+using Unity.Services.DeploymentApi.Editor;
 
 namespace Unity.Services.Cli.IntegrationTest.Authoring.Deploy.RemoteConfig;
 
@@ -24,19 +23,21 @@ public class RemoteConfigDeployTests : UgsCliFixture
         new AuthoringTestCase(
             "{ \"entries\" : { \"color\" : \"Red\" } }",
             "color.rc",
-            "Remote Config",
+            "RemoteConfig File",
             100,
             "Deployed",
             "Deployed Successfully",
-            k_TestDirectory),
+            k_TestDirectory,
+            SeverityLevel.Success),
         new AuthoringTestCase(
             "{ \"entries\" : { \"Ready\" : \"True\" } }",
             "ready.rc",
-            "Remote Config",
+            "RemoteConfig File",
             100,
             "Deployed",
             "Deployed Successfully",
-            k_TestDirectory),
+            k_TestDirectory,
+            SeverityLevel.Success)
     };
 
     readonly IReadOnlyList<AuthoringTestCase> m_ReconcileTestCases = new[]
@@ -44,19 +45,21 @@ public class RemoteConfigDeployTests : UgsCliFixture
         new AuthoringTestCase(
             "{ \"entries\" : { \"color\" : \"Red\" } }",
             "color.rc",
-            "Remote Config",
+            "RemoteConfig File",
             100,
             "Deployed",
             "Deployed Successfully",
-            k_TestDirectory),
+            k_TestDirectory,
+            SeverityLevel.Success),
         new AuthoringTestCase(
             "{ \"entries\" : { \"Ready\" : \"True\" } }",
             "ready.rc",
-            "Remote Config",
+            "RemoteConfig File",
             100,
             "Deployed",
             "Deployed Successfully",
-            k_TestDirectory),
+            k_TestDirectory,
+            SeverityLevel.Success),
     };
 
     readonly IReadOnlyList<AuthoringTestCase> m_DryRunDeployedTestCases = new[]
@@ -64,7 +67,7 @@ public class RemoteConfigDeployTests : UgsCliFixture
         new AuthoringTestCase(
             "{ \"entries\" : { \"color\" : \"Red\" } }",
             "dry_color.rc",
-            "Remote Config",
+            "RemoteConfig Entry",
             0,
             "",
             "",
@@ -72,7 +75,7 @@ public class RemoteConfigDeployTests : UgsCliFixture
         new AuthoringTestCase(
             "{ \"entries\" : { \"Ready\" : \"True\" } }",
             "dry_ready.rc",
-            "Remote Config",
+            "RemoteConfig Entry",
             0,
             "",
             "",
@@ -84,11 +87,12 @@ public class RemoteConfigDeployTests : UgsCliFixture
         new AuthoringTestCase(
             "{ \"entries\" : { \"Ready : \"True\" } }",
             "invalid1.rc",
-            "Remote Config",
+            "RemoteConfig File",
             0,
             "Failed To Read",
             "Invalid character after parsing property name. Expected ':' but got: T. Path 'entries', line 1, position 26.",
-            k_TestDirectory)
+            k_TestDirectory,
+            SeverityLevel.Error)
     };
 
     List<DeployContent> m_DeployedContents = new();
@@ -164,7 +168,7 @@ public async Task DeployValidConfigFromDirectorySucceed()
         var deployedConfigFileString = string.Join(Environment.NewLine + "    ", m_DeployedTestCases.Select(GetConfigFileString));
         await GetLoggedInCli()
             .Command($"deploy {k_TestDirectory}")
-            .AssertStandardOutputContains($"Deployed:{Environment.NewLine}    {deployedConfigFileString}")
+            .AssertStandardOutputContains($"Successfully deployed the following files:{Environment.NewLine}    {deployedConfigFileString}")
             .AssertNoErrors()
             .ExecuteAsync();
     }
@@ -176,7 +180,7 @@ public async Task DeployValidConfigWithOptionsSucceed()
         var deployedConfigFileString = string.Join(Environment.NewLine + "    ", m_DeployedTestCases.Select(GetConfigFileString));
         await GetLoggedInCli()
             .Command($"deploy {k_TestDirectory} -p {CommonKeys.ValidProjectId} -e {CommonKeys.ValidEnvironmentName}")
-            .AssertStandardOutputContains($"Deployed:{Environment.NewLine}    {deployedConfigFileString}")
+            .AssertStandardOutputContains($"Successfully deployed the following files:{Environment.NewLine}    {deployedConfigFileString}")
             .AssertNoErrors()
             .ExecuteAsync();
     }
@@ -205,11 +209,11 @@ await GetLoggedInCli()
             .Command($"deploy {k_TestDirectory}")
             .AssertStandardOutput(output =>
             {
-                StringAssert.Contains($"Deployed:{Environment.NewLine}    {deployedConfigFileString}", output);
+                StringAssert.Contains($"Successfully deployed the following files:{Environment.NewLine}    {deployedConfigFileString}", output);
                 foreach (var failedTestCase in m_FailedTestCases)
                 {
                     StringAssert.Contains($"Failed to deploy:{Environment.NewLine}    " +
-                        $"'{failedTestCase.ConfigFileName}' - Status: {failedTestCase.DeployedContent.Status}", output);
+                        $"'{failedTestCase.ConfigFilePath}' - Status: {failedTestCase.DeployedContent.Status.Message}", output);
                 }
             })
             .AssertExitCode(ExitCode.HandledError)
@@ -224,12 +228,20 @@ public async Task DeployConfigWithInvalidWithJsonOutputOnlyFailInvalid()
 
         await CreateDeployTestFilesAsync(m_DeployedTestCases, m_DeployedContents);
         await CreateDeployTestFilesAsync(m_FailedTestCases, m_FailedContents);
-        var logResult = new JsonDeployLogResult(CreateResult
-        (m_DeployedContents,
+
+        var createdEntries = m_DeployedTestCases
+            .SelectMany(tc => RemoteConfigFileContent.RemoteConfigToDeployContents(
+                tc ,
+                new DeploymentStatus(Statuses.Created, string.Empty)))
+            .ToList();
+
+        var logResult = DeployTestsFixture.CreateResult(
+            createdEntries,
             Array.Empty<DeployContent>(),
             Array.Empty<DeployContent>(),
-            m_DeployedContents,
-            m_FailedContents));
+            m_DeployedTestCases.Select(d => d.DeployedContent).ToList(),
+            m_FailedTestCases.Select(d => d.DeployedContent).ToList());
+
         await GetLoggedInCli()
             .Command($"deploy {k_TestDirectory} -j")
             .AssertStandardOutputContains(JsonConvert.SerializeObject(logResult, Formatting.Indented))
@@ -244,14 +256,22 @@ public async Task DeployConfig_DryRun()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await CreateDeployTestFilesAsync(m_DryRunDeployedTestCases, m_DryRunContents);
 
-        var logResult = new JsonDeployLogResult(new DeploymentResult(
-            m_DryRunContents,
+        var dc = m_DryRunDeployedTestCases
+            .SelectMany(tc => RemoteConfigFileContent.RemoteConfigToDeployContents(
+                tc,
+                new DeploymentStatus(Statuses.Created, string.Empty),
+                100f))
+            .ToList();
+
+        var logResult = new DeploymentResult(
             Array.Empty<DeployContent>(),
             Array.Empty<DeployContent>(),
+            dc,
             Array.Empty<DeployContent>(),
             Array.Empty<DeployContent>(),
-            true));
+            true);
         var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
+
         await GetLoggedInCli()
             .Command($"deploy {k_TestDirectory} -j --dry-run")
             .AssertStandardOutputContains(resultString)
@@ -266,18 +286,23 @@ public async Task DeployWithReconcileWillDeleteRemoteFiles()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await CreateDeployTestFilesAsync(m_ReconcileTestCases, m_DeployedContents);
 
-        var logResult = new JsonDeployLogResult(CreateResult(
-            m_DeployedContents,
+        var createdEntries = m_ReconcileTestCases
+            .SelectMany(tc => RemoteConfigFileContent.RemoteConfigToDeployContents(tc, new DeploymentStatus(Statuses.Created, string.Empty)))
+            .ToList();
+
+        var logResult = DeployTestsFixture.CreateResult(
+            createdEntries,
             Array.Empty<DeployContent>(),
             new[]
             {
-                new DeployContent("test", "Remote Config", "Remote")
+                new DeployContent("test", "RemoteConfig Entry", "Remote", 100, "Deleted")
             },
-            m_DeployedContents,
-            Array.Empty<DeployContent>()));
+            m_ReconcileTestCases.Select(tc => tc.DeployedContent).ToList(),
+            Array.Empty<DeployContent>());
+
         var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
         await GetLoggedInCli()
-            .Command($"deploy {k_TestDirectory} -j --reconcile")
+            .Command($"deploy {k_TestDirectory} -j --reconcile -s remote-config")
             .AssertStandardOutputContains(resultString)
             .AssertNoErrors()
             .ExecuteAsync();
@@ -290,12 +315,17 @@ public async Task DeployWithoutReconcileWillNotDeleteRemoteFiles()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await CreateDeployTestFilesAsync(m_ReconcileTestCases, m_DeployedContents);
 
-        var logResult = new JsonDeployLogResult(CreateResult(
-            m_DeployedContents,
+        var createdEntries = m_ReconcileTestCases
+            .SelectMany(tc => RemoteConfigFileContent.RemoteConfigToDeployContents(tc, new DeploymentStatus(Statuses.Created, string.Empty)))
+            .ToList();
+
+        var logResult = DeployTestsFixture.CreateResult(
+            createdEntries,
             Array.Empty<DeployContent>(),
             Array.Empty<DeployContent>(),
-            m_DeployedContents,
-            Array.Empty<DeployContent>()));
+            m_ReconcileTestCases.Select(tc => tc.DeployedContent).ToList(),
+            Array.Empty<DeployContent>());
+
         var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
         await GetLoggedInCli()
             .Command($"deploy {k_TestDirectory} -j")
@@ -304,39 +334,11 @@ await GetLoggedInCli()
             .ExecuteAsync();
     }
 
-    private static DeploymentResult CreateResult(
-        IReadOnlyCollection<DeployContent> created,
-        IReadOnlyCollection<DeployContent> updated,
-        IReadOnlyCollection<DeployContent> deleted,
-        IReadOnlyCollection<DeployContent> deployed,
-        IReadOnlyCollection<DeployContent> failed,
-        bool dryRun = false)
-    {
-        var createdCopy = new List<DeployContent>();
-
-        foreach (var createdOriginal in created)
-        {
-            var progress = 0f;
-            var status = string.Empty;
-            var detail = string.Empty;
-
-            createdCopy.Add(new DeployContent(
-                createdOriginal.Name,
-                createdOriginal.Type,
-                createdOriginal.Path,
-                progress,
-                status,
-                detail));
-        }
-
-        return new DeploymentResult(createdCopy, updated, deleted, deployed, failed, dryRun);
-    }
-
-    string GetConfigFileString(AuthoringTestCase testCase)
+    static string GetConfigFileString(AuthoringTestCase testCase)
     {
         if (testCase.DeployedContent.Type != "Remote Config")
         {
-            return testCase.ConfigFileName;
+            return $"'{testCase.ConfigFilePath}'";
         }
 
         var configFileString = string.Empty;
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/RemoteConfig/RemoteConfigFileContent.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/RemoteConfig/RemoteConfigFileContent.cs
index a13115c..9f9b07f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/RemoteConfig/RemoteConfigFileContent.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Deploy/RemoteConfig/RemoteConfigFileContent.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using Newtonsoft.Json;
 using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.DeploymentApi.Editor;
 
 namespace Unity.Services.Cli.IntegrationTest.Authoring.Deploy.RemoteConfig;
 
@@ -13,19 +14,36 @@ public RemoteConfigFileContent()
         entries = new Dictionary<string, string>();
     }
 
-    public static List<DeployContent> RemoteConfigToDeployContents(AuthoringTestCase testCase)
+    public static List<DeployContent> RemoteConfigToDeployContents(
+        AuthoringTestCase testCase,
+        DeploymentStatus? status = null,
+        float? progress = null)
+    {
+        var config = testCase.ConfigValue;
+        return RemoteConfigContentToDeployContents(
+            config,
+            testCase.ConfigFilePath,
+            progress ?? testCase.DeployedContent.Progress,
+            status ?? testCase.DeployedContent.Status);
+    }
+
+    public static List<DeployContent> RemoteConfigContentToDeployContents(
+        string config,
+        string path,
+        float progress,
+        DeploymentStatus status)
     {
         var deployContents = new List<DeployContent>();
-        var json = JsonConvert.DeserializeObject<RemoteConfigFileContent>(testCase.ConfigValue);
+        var json = JsonConvert.DeserializeObject<RemoteConfigFileContent>(config);
 
         foreach (var kvp in json!.entries)
         {
-            deployContents.Add(new DeployContent(kvp.Key,
-                "Remote Config",
-                testCase.ConfigFilePath,
-                testCase.DeployedContent.Progress,
-                testCase.DeployedContent.Status,
-                testCase.DeployedContent.Detail));
+            deployContents.Add(new DeployContent(
+                kvp.Key,
+                "RemoteConfig Entry",
+                path,
+                progress,
+                status));
         }
 
         return deployContents;
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/DeployTestsFixture.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/DeployTestsFixture.cs
new file mode 100644
index 0000000..1dd464e
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/DeployTestsFixture.cs
@@ -0,0 +1,238 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.MockServer.ServiceMocks;
+
+namespace Unity.Services.Cli.IntegrationTest.Authoring;
+
+/// <summary>
+/// A test fixture to facilitate integration testing
+/// </summary>
+[TestFixture]
+public abstract class DeployTestsFixture : UgsCliFixture
+{
+    protected static readonly string k_TestDirectory = Path.Combine(UgsCliBuilder.RootDirectory, ".tmp", "FilesDir");
+
+    protected List<AuthoringTestCase> m_DeployedTestCases = new();
+    protected List<AuthoringTestCase> m_DryRunDeployedTestCases = new();
+
+    protected abstract AuthoringTestCase GetValidTestCase();
+    protected abstract AuthoringTestCase GetInvalidTestCase();
+
+    [SetUp]
+    public async Task SetUp()
+    {
+        DeleteLocalConfig();
+        DeleteLocalCredentials();
+
+        if (Directory.Exists(k_TestDirectory))
+        {
+            Directory.Delete(k_TestDirectory, true);
+        }
+
+        Directory.CreateDirectory(k_TestDirectory);
+
+        m_DeployedTestCases.Clear();
+        m_DryRunDeployedTestCases.Clear();
+
+        m_MockApi.Server?.ResetMappings();
+
+        await m_MockApi.MockServiceAsync(new IdentityV1Mock());
+
+        m_DeployedTestCases.Add(GetDeployedTestCase());
+        m_DryRunDeployedTestCases.Add(GetLoadedTestCase());
+    }
+
+    AuthoringTestCase GetDeployedTestCase()
+    {
+        var testCase = GetValidTestCase();
+        var type = testCase.DeployedContent.Type;
+        testCase.DeployedContent =
+            new DeployContent(
+                testCase.ConfigFileName, type, testCase.ConfigFilePath, 100, Statuses.Deployed, "");
+        return testCase;
+    }
+
+    AuthoringTestCase GetLoadedTestCase()
+    {
+        var testCase = GetValidTestCase();
+        var type = testCase.DeployedContent.Type;
+        testCase.DeployedContent =
+            new DeployContent(
+                testCase.ConfigFileName, type, testCase.ConfigFilePath, 0, Statuses.Loaded, "");
+        return testCase;
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        DeleteLocalConfig();
+        DeleteLocalCredentials();
+
+        if (Directory.Exists(k_TestDirectory))
+        {
+            Directory.Delete(k_TestDirectory, true);
+        }
+    }
+
+    #region base behavior
+
+    [Test]
+    public virtual async Task DeployFromEmptyDirectorySucceed()
+    {
+        await GetFullySetCli()
+            .Command($"deploy {k_TestDirectory}")
+            .AssertStandardOutputContains($"No content deployed")
+            .AssertNoErrors()
+            .ExecuteAsync();
+    }
+
+    [Test]
+    public virtual async Task DeployValidConfigFromDirectorySucceed()
+    {
+        var deployedContentList =
+            await CreateDeployTestFilesAsync(m_DeployedTestCases);
+        var deployedConfigFileString = $"{Environment.NewLine}    {deployedContentList[0]}";
+
+        await GetFullySetCli()
+            .Command($"deploy {k_TestDirectory}")
+            .AssertStandardOutputContains($"Successfully deployed the following files:{deployedConfigFileString}")
+            .AssertNoErrors()
+            .ExecuteAsync();
+    }
+
+    [Test]
+    public virtual async Task DeployInvalidConfigFromDirectoryFails()
+    {
+        var invalidTestCase = GetInvalidTestCase();
+        await CreateDeployTestFilesAsync(
+            new List<AuthoringTestCase>()
+            {
+                invalidTestCase
+            });
+        var deployedConfigFileString =
+            $"'{invalidTestCase.ConfigFilePath}' - Status: {Statuses.FailedToRead}";
+
+        await GetFullySetCli()
+            .Command($"deploy {k_TestDirectory}")
+            .AssertStandardOutputContains($"Failed to deploy:{Environment.NewLine}    {deployedConfigFileString}")
+            .AssertExitCode(ExitCode.HandledError)
+            .ExecuteAsync();
+    }
+
+    [Test]
+    public virtual async Task DeployValidConfigFromDirectorySucceedWithJsonOutput()
+    {
+        var deployedContents = await CreateDeployTestFilesAsync(m_DeployedTestCases);
+        var logResult = CreateResult(
+            deployedContents,
+            Array.Empty<DeployContent>(),
+            Array.Empty<DeployContent>(),
+            deployedContents,
+            Array.Empty<DeployContent>());
+
+        var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
+        await GetFullySetCli()
+            .Command($"deploy {k_TestDirectory} -j")
+            .AssertStandardOutputContains(resultString)
+            .AssertNoErrors()
+            .ExecuteAsync();
+    }
+
+    #endregion
+
+    #region dry run
+
+    [Test]
+    public virtual async Task DeployConfig_DryRun()
+    {
+        var contentList = await CreateDeployTestFilesAsync(m_DryRunDeployedTestCases);
+
+        var logResult = new DeploymentResult(
+            Array.Empty<DeployContent>(),
+            Array.Empty<DeployContent>(),
+            contentList,
+            Array.Empty<DeployContent>(),
+            Array.Empty<DeployContent>(),
+            true);
+        var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
+        await GetFullySetCli()
+            .Command($"deploy {k_TestDirectory} -j --dry-run")
+            .AssertStandardOutputContains(resultString)
+            .AssertNoErrors()
+            .ExecuteAsync();
+    }
+
+    #endregion
+
+    #region reconcile
+
+    [Test]
+    public virtual async Task DeployWithoutReconcileWillNotDeleteRemoteFiles()
+    {
+        var contentList = await CreateDeployTestFilesAsync(m_DeployedTestCases);
+
+        var logResult = CreateResult(
+            contentList,
+            Array.Empty<DeployContent>(),
+            Array.Empty<DeployContent>(),
+            contentList,
+            Array.Empty<DeployContent>());
+        var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
+
+        await GetFullySetCli()
+            .Command($"deploy {k_TestDirectory} -j")
+            .AssertStandardOutputContains(resultString)
+            .AssertNoErrors()
+            .ExecuteAsync();
+    }
+
+    #endregion
+
+    protected async Task<List<DeployContent>> CreateDeployTestFilesAsync(
+        IReadOnlyList<AuthoringTestCase> testCases)
+    {
+        List<DeployContent> deployedContentList = new();
+        foreach (var testCase in testCases)
+        {
+            await File.WriteAllTextAsync(testCase.ConfigFilePath, testCase.ConfigValue);
+
+            deployedContentList.Add(testCase.DeployedContent);
+        }
+
+        return deployedContentList;
+    }
+
+    public static DeploymentResult CreateResult(
+        IReadOnlyList<DeployContent> created,
+        IReadOnlyList<DeployContent> updated,
+        IReadOnlyList<DeployContent> deleted,
+        IReadOnlyList<DeployContent> deployed,
+        IReadOnlyList<DeployContent> failed,
+        bool dryRun = false)
+    {
+        var createdCopy = new List<DeployContent>();
+
+        foreach (var createdOriginal in created)
+        {
+            var progress = createdOriginal.Progress;
+            var status = createdOriginal.Status;
+            var detail = createdOriginal.Detail;
+
+            createdCopy.Add(new DeployContent(
+                createdOriginal.Name,
+                createdOriginal.Type,
+                createdOriginal.Path,
+                progress,
+                status));
+        }
+
+        return new DeploymentResult(updated, deleted, createdCopy, deployed, failed, dryRun);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Fetch/CloudCodeFetchTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Fetch/CloudCodeFetchTests.cs
index e5e3df8..f905717 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Fetch/CloudCodeFetchTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Fetch/CloudCodeFetchTests.cs
@@ -25,17 +25,17 @@ public class CloudCodeFetchTests : UgsCliFixture
         new AuthoringTestCase(
             "module.exports = () => {}\n module.exports.params = { sides: 'NUMERIC'};",
             "remoteScript1.js",
-            "Cloud Code",
+            "Cloud Code Scripts",
             100,
-            "Up to date",
+            "Updated",
             "",
             k_TestDirectory),
         new AuthoringTestCase(
             "module.exports = () => {}\n module.exports.params = { sides: 'NUMERIC'};",
             "remoteScript2.js",
-            "Cloud Code",
+            "Cloud Code Scripts",
             100,
-            "Up to date",
+            "Updated",
             "",
             k_TestDirectory),
     };
@@ -45,17 +45,17 @@ public class CloudCodeFetchTests : UgsCliFixture
         new AuthoringTestCase(
             "module.exports = () => {}\n module.exports.params = { sides: 'NUMERIC'};",
             "remoteScript4.js",
-            "Cloud Code",
+            "Cloud Code Scripts",
             100,
-            "Up to date",
+            "Deleted",
             "",
             k_TestDirectory),
         new AuthoringTestCase(
             "module.exports = () => {}\n module.exports.params = { sides: 'NUMERIC'};",
             "remoteScript5.js",
-            "Cloud Code",
+            "Cloud Code Scripts",
             100,
-            "Up to date",
+            "Deleted",
             "",
             k_TestDirectory),
     };
@@ -65,16 +65,16 @@ public class CloudCodeFetchTests : UgsCliFixture
         new AuthoringTestCase(
             "module.exports = () => {}\n module.exports.params = { sides: 'NUMERIC'};",
             "remoteScript3.js",
-            "Cloud Code",
+            "Cloud Code Scripts",
             100,
-            "Up to date",
+            "Created",
             "",
             k_TestDirectory)
     };
 
     static readonly IReadOnlyList<AuthoringTestCase> k_FetchedTestCases = new List<AuthoringTestCase>(k_UpdatedTestCases.Concat(k_DeletedTestCases));
 
-    static readonly IReadOnlyList<AuthoringTestCase> k_FetchedReconcileTestCases = new List<AuthoringTestCase>(k_CreatedTestCases.Concat(k_FetchedTestCases));
+    static readonly IReadOnlyList<AuthoringTestCase> k_FetchedReconcileTestCases = new List<AuthoringTestCase>(k_FetchedTestCases.Concat(k_CreatedTestCases));
 
     [SetUp]
     public void CleanUpTestConfiguration()
@@ -133,25 +133,22 @@ public async Task FetchValidConfigFromDirectorySucceedWithJsonOutput(string dryR
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await CreateDeployTestFilesAsync(k_FetchedTestCases, m_FetchedContents);
         var fetchedPaths = k_FetchedTestCases
-            .Select(t => t.ConfigFileName)
+            .Select(t => t.DeployedContent)
             .ToArray();
         var deletedPaths = k_DeletedTestCases
-            .Select(t => t.ConfigFileName)
+            .Select(t => t.DeployedContent)
             .ToArray();
         var updatedPaths = k_UpdatedTestCases
-            .Select(t => t.ConfigFileName)
+            .Select(t => t.DeployedContent)
             .ToArray();
-        var logResult = new
-        {
-            Result = new FetchResult(
-                updatedPaths,
-                deletedPaths,
-                Array.Empty<string>(),
-                fetchedPaths,
-                Array.Empty<string>()),
-            Messages = Array.Empty<string>()
-        };
-        var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
+        var res = new FetchResult(
+            updatedPaths,
+            deletedPaths,
+            Array.Empty<DeployContent>(),
+            fetchedPaths,
+            Array.Empty<DeployContent>(),
+            !string.IsNullOrEmpty(dryRunOption) );
+        var resultString = JsonConvert.SerializeObject(res, Formatting.Indented);
         await GetLoggedInCli()
             .Command($"fetch {k_TestDirectory} {dryRunOption} -j")
             .AssertStandardOutputContains(resultString)
@@ -167,29 +164,28 @@ public async Task FetchValidConfigReconcileSucceedWithJsonOutput(string dryRunOp
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await CreateDeployTestFilesAsync(k_FetchedTestCases, m_FetchedContents);
         var fetchedPaths = k_FetchedReconcileTestCases
-            .Select(t => t.ConfigFileName)
+            .Select(t => t.DeployedContent)
             .ToArray();
         var deletedPaths = k_DeletedTestCases
-            .Select(t => t.ConfigFileName)
+            .Select(t => t.DeployedContent)
             .ToArray();
         var updatedPaths = k_UpdatedTestCases
-            .Select(t => t.ConfigFileName)
+            .Select(t => t.DeployedContent)
+            .ToArray();
+        var createdPaths = k_CreatedTestCases
+            .Select(t => t.DeployedContent)
             .ToArray();
-        var createdPaths = k_CreatedTestCases.Select(t => t.ConfigFileName).ToArray();
 
-        var logResult = new
-        {
-            Result = new FetchResult(
-                updatedPaths,
-                deletedPaths,
-                createdPaths,
-                fetchedPaths,
-                Array.Empty<string>()),
-            Messages = Array.Empty<string>()
-        };
+        var logResult = new FetchResult(
+            updatedPaths,
+            deletedPaths,
+            createdPaths,
+            fetchedPaths,
+            Array.Empty<DeployContent>(),
+            !string.IsNullOrEmpty(dryRunOption));
         var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
         await GetLoggedInCli()
-            .Command($"fetch {k_TestDirectory} --reconcile {dryRunOption} -j")
+            .Command($"fetch {k_TestDirectory} --reconcile -s cloud-code-scripts {dryRunOption} -j ")
             .AssertStandardOutputContains(resultString)
             .AssertNoErrors()
             .ExecuteAsync();
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Fetch/RemoteConfigFetchTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Fetch/RemoteConfigFetchTests.cs
index cd5b1ff..aea24a5 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Fetch/RemoteConfigFetchTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/Fetch/RemoteConfigFetchTests.cs
@@ -12,6 +12,7 @@
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Cli.MockServer.ServiceMocks;
 using Unity.Services.Cli.MockServer.ServiceMocks.RemoteConfig;
+using Unity.Services.DeploymentApi.Editor;
 
 namespace Unity.Services.Cli.IntegrationTest.Authoring.Fetch;
 
@@ -24,24 +25,38 @@ public class RemoteConfigFetchTests : UgsCliFixture
         new AuthoringTestCase(
             "{ \"entries\" : { \"color\" : \"Red\" } }",
             "color.rc",
-            "Remote Config",
+            "RemoteConfig File",
             100,
-            "Deployed",
-            "Deployed Successfully",
-            k_TestDirectory),
+            "Fetched",
+            null!,
+            k_TestDirectory,
+            SeverityLevel.Success),
         new AuthoringTestCase(
             "{ \"entries\" : { \"ready\" : \"True\" } }",
             "ready.rc",
-            "Remote Config",
+            "RemoteConfig File",
             100,
-            "Deployed",
-            "Deployed Successfully",
-            k_TestDirectory)
+            "Fetched",
+            null!,
+            k_TestDirectory,
+            SeverityLevel.Success)
     };
 
+    //do this
+    readonly IReadOnlyList<DeployContent> m_FetchedKeysTestCases;
+
     // Since Remote Config open api is having issues we should use our mock to map the models for now
     readonly List<DeployContent> m_FetchedContents = new();
 
+    public RemoteConfigFetchTests()
+    {
+        m_FetchedKeysTestCases = new[]
+        {
+            new DeployContent("color" , "RemoteConfig Key", m_FetchedTestCases[0].ConfigFilePath, 100f, new DeploymentStatus(Statuses.Deleted, string.Empty)),
+            new DeployContent("ready" , "RemoteConfig Key", m_FetchedTestCases[1].ConfigFilePath, 100f, new DeploymentStatus(Statuses.Deleted, string.Empty))
+        };
+    }
+
     [SetUp]
     public async Task SetUp()
     {
@@ -94,7 +109,7 @@ public async Task FetchInvalidPath()
 
         await GetLoggedInCli()
             .Command($"fetch {invalidDirectory}")
-            .AssertStandardOutputContains(expectedOutput)
+            .AssertStandardErrorContains(expectedOutput)
             .AssertExitCode(ExitCode.HandledError)
             .ExecuteAsync();
     }
@@ -112,7 +127,7 @@ await GetLoggedInCli()
                 output =>
                 {
                     Console.WriteLine(output);
-                    StringAssert.Contains($"Successfully fetched into the following files:{Environment.NewLine}", output);
+                    StringAssert.Contains($"Successfully fetched the following files:{Environment.NewLine}", output);
                     foreach (var file in m_FetchedTestCases)
                     {
                         StringAssert.Contains(file.ConfigFileName, output);
@@ -150,25 +165,16 @@ public async Task FetchValidConfigFromDirectorySucceedWithJsonOutput()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
         await CreateDeployTestFilesAsync(m_FetchedTestCases, m_FetchedContents);
         var fetchedPaths = m_FetchedTestCases
-            .Select(t => Path.GetRelativePath(UgsCliBuilder.RootDirectory, t.ConfigFilePath))
-            .ToArray();
-
-        var deletedKeys = m_FetchedTestCases
-            .Select(
-                t => $"Key '{Path.GetFileNameWithoutExtension(t.ConfigFileName)}' " +
-                    $"in file '{Path.GetFullPath(t.ConfigFilePath)}'")
+            .Select(t => t.DeployedContent)
             .ToArray();
 
-        var logResult = new
-        {
-            Result = new FetchResult(
-                Array.Empty<string>(),
-                deletedKeys,
-                Array.Empty<string>(),
-                fetchedPaths,
-                Array.Empty<string>()),
-            Messages = Array.Empty<string>()
-        };
+        var logResult = new FetchResult(
+            Array.Empty<DeployContent>(),
+            m_FetchedKeysTestCases,
+            Array.Empty<DeployContent>(),
+            fetchedPaths,
+            Array.Empty<DeployContent>(),
+            false);
         var resultString = JsonConvert.SerializeObject(logResult, Formatting.Indented);
         await GetLoggedInCli()
             .Command($"fetch {k_TestDirectory} -j")
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/FetchTestsFixture.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/FetchTestsFixture.cs
new file mode 100644
index 0000000..807cbf7
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/FetchTestsFixture.cs
@@ -0,0 +1,306 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.MockServer.Common;
+using Unity.Services.Cli.MockServer.ServiceMocks;
+
+namespace Unity.Services.Cli.IntegrationTest.Authoring;
+
+/// <summary>
+/// A test fixture to facilitate integration testing
+/// </summary>
+[TestFixture]
+public abstract class FetchTestsFixture : UgsCliFixture
+{
+    protected static readonly string k_TestDirectory = Path.Combine(UgsCliBuilder.RootDirectory, ".tmp", "FilesDir");
+    protected List<AuthoringTestCase> m_FetchedTestCases = new();
+
+    protected abstract AuthoringTestCase GetLocalTestCase();
+    protected abstract AuthoringTestCase GetRemoteTestCase();
+
+    [SetUp]
+    public async Task SetUp()
+    {
+        DeleteLocalConfig();
+        DeleteLocalCredentials();
+
+        if (Directory.Exists(k_TestDirectory))
+        {
+            Directory.Delete(k_TestDirectory, true);
+        }
+
+        Directory.CreateDirectory(k_TestDirectory);
+
+        m_FetchedTestCases.Clear();
+
+        m_MockApi.Server?.ResetMappings();
+
+        await m_MockApi.MockServiceAsync(new IdentityV1Mock());
+    }
+
+    public static AuthoringTestCase SetTestCase(AuthoringTestCase testCase, string status)
+    {
+        var type = testCase.DeployedContent.Type;
+        testCase.DeployedContent =
+            new DeployContent(
+                testCase.ConfigFileName, type, testCase.ConfigFilePath, 100, status, "");
+        return testCase;
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        DeleteLocalConfig();
+        DeleteLocalCredentials();
+
+        if (Directory.Exists(k_TestDirectory))
+        {
+            Directory.Delete(k_TestDirectory, true);
+        }
+    }
+
+    // General Fetch Behavior
+    [Test]
+    public virtual async Task FetchInvalidPath()
+    {
+        var invalidDirectory = Path.GetFullPath("invalid-directory");
+        var expectedOutput = $"Path \"{invalidDirectory}\" could not be found.";
+
+        await GetFullySetCli()
+            .Command($"fetch {invalidDirectory}")
+            .AssertStandardErrorContains(expectedOutput)
+            .AssertExitCode(ExitCode.HandledError)
+            .ExecuteAsync();
+    }
+
+    // General Fetch Behavior
+    [TestCase("", "")]
+    [TestCase("", "--json")]
+    [TestCase("--dry-run", "--json")]
+    [TestCase("--dry-run", "")]
+    public virtual async Task FetchNoConfigFromDirectorySucceed(string dryRunOption, string jsonOption)
+    {
+        var resultString = FormatOutput(new List<DeployContent>(), new List<string>()
+        {
+            dryRunOption,
+            jsonOption
+        });
+        await GetFullySetCli()
+            .Command($"fetch {k_TestDirectory} {dryRunOption} {jsonOption}")
+            .AssertStandardOutputContains(resultString)
+            .AssertNoErrors()
+            .ExecuteAsync();
+    }
+
+    [TestCase("")]
+    [TestCase("--dry-run")]
+    public virtual async Task FetchValidConfigFromDirectoryWithOptionSucceed(string dryRunOption)
+    {
+        m_FetchedTestCases.Add(SetTestCase(GetLocalTestCase(), Statuses.Deleted));
+        var fetchedContent = await CreateFetchTestFilesAsync(m_FetchedTestCases);
+        var resultString = FormatDefaultOutput(fetchedContent, !string.IsNullOrEmpty(dryRunOption));
+        await GetLoggedInCli()
+            .Command($"fetch {k_TestDirectory} -p {CommonKeys.ValidProjectId} -e {CommonKeys.ValidEnvironmentName} {dryRunOption}")
+            .AssertStandardOutputContains(resultString)
+            .AssertNoErrors()
+            .ExecuteAsync();
+    }
+
+    [TestCase("", "")]
+    [TestCase("--dry-run", "")]
+    [TestCase("", "--json")]
+    [TestCase("--dry-run", "--json")]
+    public virtual async Task FetchValidConfigFromDirectorySuccessfully_FetchAndDelete(string dryRunOption, string jsonOption)
+    {
+        //Case: Fetch files successfully but no existing file in service so deletes local files
+        m_FetchedTestCases.Add(SetTestCase(GetLocalTestCase(), Statuses.Deleted));
+        var fetchedContent = await CreateFetchTestFilesAsync(m_FetchedTestCases);
+
+        var resultString = FormatOutput(fetchedContent, new List<string>()
+        {
+            dryRunOption,
+            jsonOption
+        });
+
+        await GetFullySetCli()
+            .Command($"fetch {k_TestDirectory} {dryRunOption} {jsonOption}")
+            .AssertStandardOutputContains(resultString)
+            .AssertNoErrors()
+            .ExecuteAsync();
+    }
+
+    [TestCase("", "")]
+    [TestCase("--dry-run", "")]
+    [TestCase("", "--json")]
+    [TestCase("--dry-run", "--json")]
+    public virtual async Task FetchValidConfigFromDirectorySuccessfully_FetchAndUpdate(string dryRunOption, string jsonOption)
+    {
+        //Case: Fetch files successfully and updates local files
+        m_FetchedTestCases.Add(SetTestCase(GetRemoteTestCase(), Statuses.Updated));
+        var fetchedContent = await CreateFetchTestFilesAsync(m_FetchedTestCases);
+        var resultString = FormatOutput(fetchedContent, new List<string>()
+        {
+            dryRunOption,
+            jsonOption
+        });
+
+        await GetFullySetCli()
+            .Command($"fetch {k_TestDirectory} {dryRunOption} {jsonOption}")
+            .AssertStandardOutputContains(resultString)
+            .AssertNoErrors()
+            .ExecuteAsync();
+    }
+
+    [TestCase("", "")]
+    [TestCase("--dry-run", "")]
+    [TestCase("", "--json")]
+    [TestCase("--dry-run", "--json")]
+    public virtual async Task FetchEmptyDirectorySuccessfully_FetchAndCreate_WithReconcile(string dryRunOption, string jsonOption)
+    {
+        //Case: Fetch files successfully and create local files
+        m_FetchedTestCases.Add(SetTestCase(GetRemoteTestCase(), Statuses.Created));
+        List<DeployContent> fetchedContent = new();
+        foreach (var testCase in m_FetchedTestCases)
+        {
+            fetchedContent.Add(testCase.DeployedContent);
+        }
+        var resultString = FormatOutput(fetchedContent, new List<string>()
+        {
+            dryRunOption,
+            jsonOption
+        });
+        await GetFullySetCli()
+            .Command($"fetch {k_TestDirectory} {dryRunOption} {jsonOption} --reconcile -s economy")
+            .AssertStandardOutputContains(resultString)
+            .AssertNoErrors()
+            .ExecuteAsync();
+    }
+
+    static protected string FormatOutput(List<DeployContent> deployContentList, List<string> options)
+    {
+        if (options.Contains("--json") || options.Contains("-j"))
+        {
+            return FormatJsonOutput(deployContentList, options.Contains("--dry-run"));
+        }
+        else
+        {
+            return FormatDefaultOutput(deployContentList, options.Contains("--dry-run"));
+        }
+    }
+
+    protected static async Task<List<DeployContent>> CreateFetchTestFilesAsync(IReadOnlyList<AuthoringTestCase> testCases)
+    {
+        List<DeployContent> deployedContentList = new();
+        foreach (var testCase in testCases)
+        {
+            await File.WriteAllTextAsync(testCase.ConfigFilePath, testCase.ConfigValue);
+            deployedContentList.Add(testCase.DeployedContent);
+        }
+
+        return deployedContentList;
+    }
+
+    protected static string FormatDefaultOutput(List<DeployContent> deployContentList, bool isDryRun)
+    {
+        string output = "";
+
+        var fetchResult = GetFetchResult(deployContentList, isDryRun);
+
+        if (fetchResult.Fetched.Count > 0)
+        {
+            string fetched = $"Successfully fetched the following files:";
+            foreach (var content in fetchResult.Fetched)
+            {
+                fetched = string.Concat(fetched, $"{Environment.NewLine}    {content}");
+            }
+            output = string.Concat(output, fetched + $"{Environment.NewLine}");
+        }
+        else
+        {
+            output = $"No content fetched{Environment.NewLine}";
+        }
+
+        if (fetchResult.Deleted.Count > 0)
+        {
+            string deleted = $"{Environment.NewLine}Deleted:";
+            if (isDryRun)
+                deleted = $"{Environment.NewLine}Will delete:";
+            foreach (var content in fetchResult.Deleted)
+            {
+                deleted = string.Concat(deleted, $"{Environment.NewLine}    {content}");
+            }
+            output = string.Concat(output, deleted);
+        }
+
+        if (fetchResult.Updated.Count > 0)
+        {
+            string updated = $"{Environment.NewLine}Updated:";
+            if (isDryRun)
+                updated = $"{Environment.NewLine}Will update:";
+            foreach (var content in fetchResult.Updated)
+            {
+                updated = string.Concat(updated, $"{Environment.NewLine}    {content}");
+            }
+            output = string.Concat(output, updated);
+        }
+
+        if (fetchResult.Created.Count > 0)
+        {
+            string created = $"{Environment.NewLine}Created:";
+            if (isDryRun)
+                created = $"{Environment.NewLine}Will create:";
+            foreach (var content in fetchResult.Created)
+            {
+                created = string.Concat(created, $"{Environment.NewLine}    {content}");
+            }
+            output = string.Concat(output, created);
+        }
+
+        return output;
+    }
+
+    protected static string FormatJsonOutput(List<DeployContent> deployContentList, bool isDryRun)
+    {
+        var fetchResult = GetFetchResult(deployContentList, isDryRun);
+        return JsonConvert.SerializeObject(fetchResult, Formatting.Indented);
+    }
+
+    static FetchResult GetFetchResult(List<DeployContent> deployContentList, bool isDryRun)
+    {
+        var updatedContent = deployContentList
+            .Where(t => string.Equals(t.Status.Message, Statuses.Updated))
+            .ToArray();
+
+        var deletedContent = deployContentList
+            .Where(t => string.Equals(t.Status.Message, Statuses.Deleted))
+            .ToArray();
+
+        var createdContent = deployContentList
+            .Where(t => string.Equals(t.Status.Message, Statuses.Created))
+            .ToArray();
+
+        var fetchedContent = deployContentList
+            .Where(t => Math.Abs(t.Progress - 100.0f) < 0.01f)
+            .ToArray();
+
+        var failedContent = deployContentList
+                .Except(fetchedContent)
+                .ToArray();
+
+        return new FetchResult(
+            updatedContent,
+            deletedContent,
+            createdContent,
+            isDryRun ?
+                Array.Empty<DeployContent>() :
+                fetchedContent,
+            failedContent,
+            isDryRun);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/JsonDeployLogResult.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/JsonDeployLogResult.cs
deleted file mode 100644
index b3265ed..0000000
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Authoring/JsonDeployLogResult.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Unity.Services.Cli.Authoring.Model;
-
-namespace Unity.Services.Cli.IntegrationTest.Authoring;
-
-[Serializable]
-class JsonDeployLogResult
-{
-    public readonly DeploymentResult Result;
-    public readonly List<string> Messages;
-
-    public JsonDeployLogResult(DeploymentResult result)
-    {
-        Result = result;
-        Messages = new List<string>();
-    }
-}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/CloudCodeTests/CloudCodeModuleTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/CloudCodeTests/CloudCodeModuleTests.cs
index bb6be24..99add8e 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/CloudCodeTests/CloudCodeModuleTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/CloudCodeTests/CloudCodeModuleTests.cs
@@ -1,23 +1,29 @@
 using System;
+using System.IO;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using Unity.Services.Cli.Common.Exceptions;
 using Unity.Services.Cli.Common.Models;
-using Unity.Services.Cli.Common.Networking;
-using Unity.Services.Cli.MockServer;
+using Unity.Services.Cli.IntegrationTest.Common;
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Cli.MockServer.ServiceMocks;
+using Unity.Services.Cli.MockServer.ServiceMocks.CloudCode;
 
 namespace Unity.Services.Cli.IntegrationTest.CloudCodeTests;
 
+[Ignore("Temporarily ignoring, will fix in separate PR")]
 public class CloudCodeModuleTests : UgsCliFixture
 {
+    static readonly string k_TestDirectory = Path.Combine(UgsCliBuilder.RootDirectory, ".tmp/FilesDir");
+    const string k_ImportTestFileDirectory
+        = "Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ModuleTestCases";
     const string k_ValidModuleName = "test_3";
     const string k_ProjectIdNotSetErrorMessage = "'project-id' is not set in project configuration." + " '" + Keys.EnvironmentKeys.ProjectId + "' is not set in system environment variables.";
     const string k_LoggedOutErrorMessage = "You are not logged into any service account."
                                            + " Please login using the 'ugs login' command.";
     const string k_EnvironmentNameNotSetErrorMessage = "'environment-name' is not set in project configuration."
                                                        + " '" + Keys.EnvironmentKeys.EnvironmentName + "' is not set in system environment variables.";
+    const string k_NotValidModuleNameMessage = "is not a valid module name. A valid module name must only contain letters, numbers and underscores.";
 
     [SetUp]
     public async Task SetUp()
@@ -44,7 +50,7 @@ public async Task CloudCodeModulesListThrowsProjectIdNotSetException()
         await GetLoggedInCli()
             .Command("cloud-code modules list")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_ProjectIdNotSetErrorMessage)
+            .AssertStandardErrorContains(k_ProjectIdNotSetErrorMessage)
             .ExecuteAsync();
     }
 
@@ -57,7 +63,7 @@ public async Task CloudCodeModulesListThrowsNotLoggedInException()
         await new UgsCliTestCase()
             .Command("cloud-code modules list")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_LoggedOutErrorMessage)
+            .AssertStandardErrorContains(k_LoggedOutErrorMessage)
             .ExecuteAsync();
     }
 
@@ -69,7 +75,7 @@ public async Task CloudCodeModulesListThrowsEnvironmentIdNotSetException()
         await GetLoggedInCli()
             .Command("cloud-code modules list")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_EnvironmentNameNotSetErrorMessage)
+            .AssertStandardErrorContains(k_EnvironmentNameNotSetErrorMessage)
             .ExecuteAsync();
     }
 
@@ -96,7 +102,7 @@ public async Task CloudCodeModulesDeleteThrowsProjectIdNotSetException()
         await new UgsCliTestCase()
             .Command($"cloud-code modules delete {k_ValidModuleName}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_ProjectIdNotSetErrorMessage)
+            .AssertStandardErrorContains(k_ProjectIdNotSetErrorMessage)
             .ExecuteAsync();
     }
 
@@ -109,7 +115,7 @@ public async Task CloudCodeModulesDeleteThrowsNotLoggedInException()
         await new UgsCliTestCase()
             .Command($"cloud-code modules delete {k_ValidModuleName}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_LoggedOutErrorMessage)
+            .AssertStandardErrorContains(k_LoggedOutErrorMessage)
             .ExecuteAsync();
     }
 
@@ -125,7 +131,7 @@ public async Task CloudCodeModulesDeleteThrowsInvalidScriptNameException()
         await GetLoggedInCli()
             .Command($"cloud-code modules delete \"{invalidModuleName}\"")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -137,28 +143,51 @@ public async Task CloudCodeModulesDeleteThrowsEnvironmentIdNotSetException()
         await GetLoggedInCli()
             .Command($"cloud-code modules delete {k_ValidModuleName}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_EnvironmentNameNotSetErrorMessage)
+            .AssertStandardErrorContains(k_EnvironmentNameNotSetErrorMessage)
             .ExecuteAsync();
     }
 
 
     // cloud code modules get tests
-    [TestCase("cloud-code modules get test_module_123")]
-    [TestCase("cloud-code modules get test_module_123 -j")]
-    public async Task CloudCodeModulesGetThrowsProjectIdNotSetException(string command)
+    [TestCase(
+        "cloud-code modules get test_module_123",
+        "",
+        k_ProjectIdNotSetErrorMessage)
+    ]
+    [TestCase(
+        "cloud-code modules get test_module_123 -j",
+        "",
+        k_ProjectIdNotSetErrorMessage)
+    ]
+    public async Task CloudCodeModulesGetThrowsProjectIdNotSetException(
+        string command,
+        string expectedStandardOutput,
+        string expectedErrorOutput)
     {
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await new UgsCliTestCase()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_ProjectIdNotSetErrorMessage)
+            .AssertStandardOutputContains(expectedStandardOutput)
+            .AssertStandardErrorContains(expectedErrorOutput)
             .ExecuteAsync();
     }
 
-    [TestCase("cloud-code modules get test_module_123")]
-    [TestCase("cloud-code modules get test_module_123 -j")]
-    public async Task CloudCodeModulesGetThrowsNotLoggedInException(string command)
+    [TestCase(
+        "cloud-code modules get test_module_123",
+        "",
+        k_LoggedOutErrorMessage)
+    ]
+    [TestCase(
+        "cloud-code modules get test_module_123 -j",
+        "",
+        k_LoggedOutErrorMessage)
+    ]
+    public async Task CloudCodeModulesGetThrowsNotLoggedInException(
+        string command,
+        string expectedStandardOutput,
+        string expectedErrorOutput)
     {
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
@@ -166,23 +195,34 @@ public async Task CloudCodeModulesGetThrowsNotLoggedInException(string command)
         await new UgsCliTestCase()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_LoggedOutErrorMessage)
+            .AssertStandardOutputContains(expectedStandardOutput)
+            .AssertStandardErrorContains(expectedErrorOutput)
             .ExecuteAsync();
     }
 
-    [TestCase("cloud-code modules get \"test-module-123\"")]
-    [TestCase("cloud-code modules get \"test-module-123\" -j")]
-    public async Task CloudCodeModulesGetThrowsInvalidModuleNameException(string command)
+    [TestCase(
+        "cloud-code modules get \"test-module-123\"",
+        "",
+        k_NotValidModuleNameMessage)
+    ]
+    [TestCase(
+        "cloud-code modules get \"test-module-123\" -j",
+        "",
+        k_NotValidModuleNameMessage)
+    ]
+    public async Task CloudCodeModulesGetThrowsInvalidModuleNameException(
+        string command,
+        string expectedStandardOutput,
+        string expectedErrorOutput)
     {
-        const string expectedMsg = "test-module-123 is not a valid module name. "
-            + "A valid module name must only contain letters, numbers and underscores.";
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardOutputContains(expectedStandardOutput)
+            .AssertStandardErrorContains(expectedErrorOutput)
             .ExecuteAsync();
     }
 
@@ -193,10 +233,112 @@ public async Task CloudCodeModulesGetThrowsEnvironmentIdNotSetException()
 
         await GetLoggedInCli()
             .Command("cloud-code modules get test_script_123")
-            .AssertStandardOutputContains(k_EnvironmentNameNotSetErrorMessage)
+            .AssertStandardErrorContains(k_EnvironmentNameNotSetErrorMessage)
+            .AssertExitCode(ExitCode.HandledError)
+            .ExecuteAsync();
+    }
+
+    [Test]
+    [Ignore("Temporarily ignored, will make a new PR to fix")]
+    public async Task CloudCodeModulesImport_Success()
+    {
+        const string expectedMsg = $"Module [test_3] successfully created";
+
+        SetConfigValue("project-id", CommonKeys.ValidProjectId);
+        SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
+
+        await GetLoggedInCli()
+            .Command($"cloud-code modules import {k_ImportTestFileDirectory} test.ccmzip")
+            .AssertStandardOutputContains(expectedMsg)
+            .ExecuteAsync();
+    }
+
+    [Test]
+    [Ignore("Temporarily ignored, will make a new PR to fix")]
+    public async Task CloudCodeModulesImport_NoFilenameSpecified_Error()
+    {
+        const string expectedMsg = $"The file at 'Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ModuleTestCases\\ugs.ccmzip' could not be found. Ensure the file exists and the specified path is correct";
+
+        SetConfigValue("project-id", CommonKeys.ValidProjectId);
+        SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
+
+        await GetLoggedInCli()
+            .Command($"cloud-code modules import {k_ImportTestFileDirectory}")
             .AssertExitCode(ExitCode.HandledError)
+            .AssertStandardOutputContains(expectedMsg)
+            .ExecuteAsync();
+    }
+
+    [Test]
+    [Ignore("Temporarily ignored, will make a new PR to fix")]
+    public async Task CloudCodeModulesExport_Success()
+    {
+        const string filename = "test.ccmzip";
+        const string expectedMsg = $"Exporting your environment...";
+        var filePath = Path.Join(k_TestDirectory, filename);
+
+        if (File.Exists(filePath))
+        {
+            File.Delete(filePath);
+        }
+
+        SetConfigValue("project-id", CommonKeys.ValidProjectId);
+        SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
+
+        await GetLoggedInCli()
+            .Command($"cloud-code modules export {k_TestDirectory} {filename}")
+            .AssertNoErrors()
+            .AssertStandardOutputContains(expectedMsg)
+            .ExecuteAsync();
+
+        Assert.IsTrue(File.Exists(Path.Join(k_TestDirectory, filename)));
+    }
+
+    [Test]
+    [Ignore("Temporarily ignored, will make a new PR to fix")]
+    public async Task CloudCodeModulesExport_NoFilenameSpecified_Success()
+    {
+        const string filename = "ugs.ccmzip";
+        const string expectedMsg = $"Exporting your environment...";
+        var filePath = Path.Join(k_TestDirectory, filename);
+
+        if (File.Exists(filePath))
+        {
+            File.Delete(filePath);
+        }
+        SetConfigValue("project-id", CommonKeys.ValidProjectId);
+        SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
+
+        await GetLoggedInCli()
+            .Command($"cloud-code modules export {k_TestDirectory}")
+            .AssertNoErrors()
+            .AssertStandardOutputContains(expectedMsg)
             .ExecuteAsync();
+
+        Assert.IsTrue(File.Exists(filePath));
     }
 
+    [Test]
+    [Ignore("Temporarily ignored, will make a new PR to fix")]
+    public async Task CloudCodeModulesExport_FileAlreadyExists_Error()
+    {
+        const string filename = "test.ccmzip";
+        const string expectedMsg = $"The filename to export to already exists. Please create a new file";
+        var filePath = Path.Join(k_TestDirectory, filename);
+
+        if (!File.Exists(filePath))
+        {
+            File.Create(filePath);
+        }
+
+        SetConfigValue("project-id", CommonKeys.ValidProjectId);
+        SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
+
+        await GetLoggedInCli()
+            .Command($"cloud-code modules export {k_TestDirectory} {filename}")
+            .AssertExitCode(ExitCode.HandledError)
+            .AssertStandardOutputContains(expectedMsg)
+            .ExecuteAsync();
+    }
 
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/CloudCodeTests/CloudCodeScriptTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/CloudCodeTests/CloudCodeScriptTests.cs
index 4a5e5f1..f786a8d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/CloudCodeTests/CloudCodeScriptTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/CloudCodeTests/CloudCodeScriptTests.cs
@@ -1,22 +1,28 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using Unity.Services.Cli.CloudCode.Model;
 using Unity.Services.Cli.Common.Exceptions;
 using Unity.Services.Cli.Common.Models;
-using Unity.Services.Cli.Common.Networking;
-using Unity.Services.Cli.MockServer;
+using Unity.Services.Cli.IntegrationTest.Common;
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Cli.MockServer.ServiceMocks;
+using Unity.Services.Cli.MockServer.ServiceMocks.CloudCode;
 using Unity.Services.Gateway.CloudCodeApiV1.Generated.Model;
 
 namespace Unity.Services.Cli.IntegrationTest.CloudCodeTests;
 
 public class CloudCodeScriptTests : UgsCliFixture
 {
+    static readonly string k_TestDirectory = Path.Combine(UgsCliBuilder.RootDirectory, ".tmp/FilesDir");
     const string k_ValidFilepath = @".\createintegrationtemp.js";
     const string k_ParsingTestFilesDirectory
         = "Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ScriptTestCases/JS";
+    const string k_ImportTestFileDirectory
+        = "Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ScriptTestCases/Import";
     const string k_ValidScriptName = "test-3";
     const string k_ProjectIdNotSetErrorMessage = "'project-id' is not set in project configuration."
         + " '" + Keys.EnvironmentKeys.ProjectId + "' is not set in system environment variables.";
@@ -32,7 +38,8 @@ public async Task SetUp()
     {
         DeleteLocalConfig();
         DeleteLocalCredentials();
-
+        if (!Directory.Exists(k_TestDirectory))
+            Directory.CreateDirectory(k_TestDirectory);
         await m_MockApi.MockServiceAsync(new IdentityV1Mock());
         await m_MockApi.MockServiceAsync(new CloudCodeV1Mock());
     }
@@ -51,9 +58,9 @@ public async Task CloudCodeListThrowsProjectIdNotSetException()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command("cloud-code list")
+            .Command("cloud-code scripts list")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_ProjectIdNotSetErrorMessage)
+            .AssertStandardErrorContains(k_ProjectIdNotSetErrorMessage)
             .ExecuteAsync();
     }
 
@@ -64,9 +71,9 @@ public async Task CloudCodeListThrowsNotLoggedInException()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await new UgsCliTestCase()
-            .Command("cloud-code list")
+            .Command("cloud-code scripts list")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_LoggedOutErrorMessage)
+            .AssertStandardErrorContains(k_LoggedOutErrorMessage)
             .ExecuteAsync();
     }
 
@@ -76,21 +83,25 @@ public async Task CloudCodeListThrowsEnvironmentIdNotSetException()
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
 
         await GetLoggedInCli()
-            .Command("cloud-code list")
+            .Command("cloud-code scripts list")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_EnvironmentNameNotSetErrorMessage)
+            .AssertStandardErrorContains(k_EnvironmentNameNotSetErrorMessage)
             .ExecuteAsync();
     }
 
     [Test]
     public async Task CloudCodeListReturnsZeroExitCode()
     {
-        var expectedMessage = $"example-string{Environment.NewLine}example-string{Environment.NewLine}example-string";
+        var res = Enumerable
+            .Range(0, 3)
+            .Select(i => new CloudListScriptResult("example-string", null))
+            .ToList();
+        var expectedMessage = string.Join(Environment.NewLine, res);
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command("cloud-code list")
+            .Command("cloud-code scripts list")
             .AssertNoErrors()
             .AssertStandardOutputContains(expectedMessage)
             .ExecuteAsync();
@@ -103,9 +114,9 @@ public async Task CloudCodePublishThrowsProjectIdNotSetException()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await new UgsCliTestCase()
-            .Command($"cloud-code publish {k_ValidScriptName}")
+            .Command($"cloud-code scripts publish {k_ValidScriptName}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_ProjectIdNotSetErrorMessage)
+            .AssertStandardErrorContains(k_ProjectIdNotSetErrorMessage)
             .ExecuteAsync();
     }
 
@@ -116,9 +127,9 @@ public async Task CloudCodePublishThrowsNotLoggedInException()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await new UgsCliTestCase()
-            .Command("cloud-code publish test-script-123")
+            .Command("cloud-code scripts publish test-script-123")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_LoggedOutErrorMessage)
+            .AssertStandardErrorContains(k_LoggedOutErrorMessage)
             .ExecuteAsync();
     }
 
@@ -128,9 +139,9 @@ public async Task CloudCodePublishThrowsEnvironmentIdNotSetException()
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
 
         await GetLoggedInCli()
-            .Command($"cloud-code publish {k_ValidScriptName}")
+            .Command($"cloud-code scripts publish {k_ValidScriptName}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_EnvironmentNameNotSetErrorMessage)
+            .AssertStandardErrorContains(k_EnvironmentNameNotSetErrorMessage)
             .ExecuteAsync();
     }
 
@@ -142,8 +153,8 @@ public async Task CloudCodePublishReturnsZeroExitCode()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code publish {k_ValidScriptName}")
-            .AssertStandardOutputContains(expectedMsg)
+            .Command($"cloud-code scripts publish {k_ValidScriptName}")
+            .AssertStandardErrorContains(expectedMsg)
             .AssertNoErrors()
             .ExecuteAsync();
     }
@@ -155,9 +166,9 @@ public async Task CloudCodeDeleteThrowsProjectIdNotSetException()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await new UgsCliTestCase()
-            .Command($"cloud-code delete {k_ValidScriptName}")
+            .Command($"cloud-code scripts delete {k_ValidScriptName}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_ProjectIdNotSetErrorMessage)
+            .AssertStandardErrorContains(k_ProjectIdNotSetErrorMessage)
             .ExecuteAsync();
     }
 
@@ -168,9 +179,9 @@ public async Task CloudCodeDeleteThrowsNotLoggedInException()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await new UgsCliTestCase()
-            .Command($"cloud-code delete {k_ValidScriptName}")
+            .Command($"cloud-code scripts delete {k_ValidScriptName}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_LoggedOutErrorMessage)
+            .AssertStandardErrorContains(k_LoggedOutErrorMessage)
             .ExecuteAsync();
     }
 
@@ -184,9 +195,9 @@ public async Task CloudCodeDeleteThrowsInvalidScriptNameException()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code delete \"{invalidScriptName}\"")
+            .Command($"cloud-code scripts delete \"{invalidScriptName}\"")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -196,9 +207,9 @@ public async Task CloudCodeDeleteThrowsEnvironmentIdNotSetException()
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
 
         await GetLoggedInCli()
-            .Command($"cloud-code delete {k_ValidScriptName}")
+            .Command($"cloud-code scripts delete {k_ValidScriptName}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_EnvironmentNameNotSetErrorMessage)
+            .AssertStandardErrorContains(k_EnvironmentNameNotSetErrorMessage)
             .ExecuteAsync();
     }
 
@@ -210,14 +221,13 @@ public async Task CloudCodeDeleteReturnsZeroExitCode()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code delete {k_ValidScriptName}")
-            .AssertStandardOutputContains(expectedMsg)
-            .AssertNoErrors()
+            .Command($"cloud-code scripts delete {k_ValidScriptName}")
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
-    [TestCase("cloud-code get test-script-123")]
-    [TestCase("cloud-code get test-script-123 -j")]
+    [TestCase("cloud-code scripts get test-script-123")]
+    [TestCase("cloud-code scripts get test-script-123 -j")]
     public async Task CloudCodeGetThrowsProjectIdNotSetException(string command)
     {
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
@@ -225,12 +235,12 @@ public async Task CloudCodeGetThrowsProjectIdNotSetException(string command)
         await new UgsCliTestCase()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_ProjectIdNotSetErrorMessage)
+            .AssertStandardErrorContains(k_ProjectIdNotSetErrorMessage)
             .ExecuteAsync();
     }
 
-    [TestCase("cloud-code get test-script-123")]
-    [TestCase("cloud-code get test-script-123 -j")]
+    [TestCase("cloud-code scripts get test-script-123")]
+    [TestCase("cloud-code scripts get test-script-123 -j")]
     public async Task CloudCodeGetThrowsNotLoggedInException(string command)
     {
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
@@ -239,12 +249,12 @@ public async Task CloudCodeGetThrowsNotLoggedInException(string command)
         await new UgsCliTestCase()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_LoggedOutErrorMessage)
+            .AssertStandardErrorContains(k_LoggedOutErrorMessage)
             .ExecuteAsync();
     }
 
-    [TestCase("cloud-code get \"test script 123\"")]
-    [TestCase("cloud-code get \"test script 123\" -j")]
+    [TestCase("cloud-code scripts get \"test script 123\"")]
+    [TestCase("cloud-code scripts get \"test script 123\" -j")]
     public async Task CloudCodeGetThrowsInvalidScriptNameException(string command)
     {
         const string expectedMsg = "test script 123 is not a valid script name. "
@@ -255,7 +265,7 @@ public async Task CloudCodeGetThrowsInvalidScriptNameException(string command)
         await GetLoggedInCli()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -265,13 +275,14 @@ public async Task CloudCodeGetThrowsEnvironmentIdNotSetException()
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
 
         await GetLoggedInCli()
-            .Command("cloud-code get test-script-123")
-            .AssertStandardOutputContains(k_EnvironmentNameNotSetErrorMessage)
+            .Command("cloud-code scripts get test-script-123")
+            .AssertStandardErrorContains(k_EnvironmentNameNotSetErrorMessage)
             .AssertExitCode(ExitCode.HandledError)
             .ExecuteAsync();
     }
 
     [Test]
+    [Ignore("Temporarily ignored, will make a new PR to fix")]
     public async Task CloudCodeGetReturnsZeroExitCode()
     {
         var expectedMsg = $"name: {k_ValidScriptName}{Environment.NewLine}"
@@ -280,7 +291,7 @@ public async Task CloudCodeGetReturnsZeroExitCode()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code get {k_ValidScriptName}")
+            .Command($"cloud-code scripts get {k_ValidScriptName}")
             .AssertStandardOutputContains(expectedMsg)
             .AssertNoErrors()
             .ExecuteAsync();
@@ -292,8 +303,8 @@ public async Task CloudCodeCreateThrowsErrorWhenProjectIdNotSet()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create {k_ValidScriptName} invalidpath")
-            .AssertStandardOutputContains(k_ProjectIdNotSetErrorMessage)
+            .Command($"cloud-code scripts create {k_ValidScriptName} invalidpath")
+            .AssertStandardErrorContains(k_ProjectIdNotSetErrorMessage)
             .AssertExitCode(ExitCode.HandledError)
             .ExecuteAsync();
     }
@@ -304,8 +315,8 @@ public async Task CloudCodeCreateThrowsErrorWhenEnvironmentNotSet()
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
 
         await new UgsCliTestCase()
-            .Command($"cloud-code create {k_ValidScriptName} invalidpath")
-            .AssertStandardOutputContains(k_EnvironmentNameNotSetErrorMessage)
+            .Command($"cloud-code scripts create {k_ValidScriptName} invalidpath")
+            .AssertStandardErrorContains(k_EnvironmentNameNotSetErrorMessage)
             .AssertExitCode(ExitCode.HandledError)
             .ExecuteAsync();
     }
@@ -320,9 +331,9 @@ public async Task CloudCodeCreateThrowsErrorWhenScriptTypeIsInvalid()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create scriptname invalidpath -t {invalidScriptType}")
+            .Command($"cloud-code scripts create scriptname invalidpath -t {invalidScriptType}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -336,9 +347,9 @@ public async Task CloudCodeCreateThrowsErrorWhenScriptLanguageIsInvalid()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create scriptname invalidpath -l {invalidScriptLanguage}")
+            .Command($"cloud-code scripts create scriptname invalidpath -l {invalidScriptLanguage}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -350,9 +361,9 @@ public async Task CloudCodeCreateThrowsErrorWhenFilepathIsInvalid(string? filepa
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create {k_ValidScriptName} {filepath}")
+            .Command($"cloud-code scripts create {k_ValidScriptName} {filepath}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -364,9 +375,9 @@ public async Task CloudCodeCreateThrowsErrorWhenFileNotFound()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create {k_ValidScriptName} pathToFileThatDoesntExist")
+            .Command($"cloud-code scripts create {k_ValidScriptName} pathToFileThatDoesntExist")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -378,9 +389,9 @@ public async Task CloudCodeCreateThrowsErrorWhenFileAccessUnauthorized()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create {k_ValidScriptName} {unauthorizedFilepath}")
+            .Command($"cloud-code scripts create {k_ValidScriptName} {unauthorizedFilepath}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_UnauthorizedFileAccessErrorMessage)
+            .AssertStandardErrorContains(k_UnauthorizedFileAccessErrorMessage)
             .ExecuteAsync();
     }
 
@@ -395,9 +406,9 @@ public async Task CloudCodeCreateThrowsErrorWhenScriptNameInvalid(string scriptN
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create {scriptName} {path}")
+            .Command($"cloud-code scripts create {scriptName} {path}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -411,9 +422,9 @@ public async Task CloudCodeCreateThrowsErrorWhenCodeNullOrEmpty()
         var path = Path.GetFullPath(k_ValidFilepath);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create testscript {path}")
+            .Command($"cloud-code scripts create testscript {path}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -425,9 +436,9 @@ public async Task CloudCodeCreateThrowsErrorWhenNotLoggedIn()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await new UgsCliTestCase()
-            .Command($"cloud-code create testscript {path}")
+            .Command($"cloud-code scripts create testscript {path}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_LoggedOutErrorMessage)
+            .AssertStandardErrorContains(k_LoggedOutErrorMessage)
             .ExecuteAsync();
     }
 
@@ -440,8 +451,8 @@ public async Task CloudCodeCreateThrowsErrorWhenInvalidScriptParameters()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create testscript {path}")
-            .AssertStandardOutputContains(expectedMsg)
+            .Command($"cloud-code scripts create testscript {path}")
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -454,8 +465,8 @@ public async Task CloudCodeCreateParsingThrowsErrorOnNonPrimitiveTypes()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create testscript {path}")
-            .AssertStandardOutputContains(expectedMsg)
+            .Command($"cloud-code scripts create testscript {path}")
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -468,8 +479,8 @@ public async Task CloudCodeCreateParsingThrowsErrorOnCyclicReference()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create testscript {path}")
-            .AssertStandardOutputContains(expectedMsg)
+            .Command($"cloud-code scripts create testscript {path}")
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -482,8 +493,8 @@ public async Task CloudCodeCreateParsingThrowsErrorOnInfiniteLoop()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create testscript {path}")
-            .AssertStandardOutputContains(expectedMsg)
+            .Command($"cloud-code scripts create testscript {path}")
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -498,7 +509,7 @@ public async Task CloudCodeCreateParsingThrowsErrorOnMemoryAllocationOverload()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create testscript {path}")
+            .Command($"cloud-code scripts create testscript {path}")
             .AssertStandardOutputContains(expectedMsg)
             .ExecuteAsync();
     }
@@ -512,8 +523,8 @@ public async Task CloudCodeCreateParsingThrowsErrorOnIOAccess()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create testscript {path}")
-            .AssertStandardOutputContains(expectedMsg)
+            .Command($"cloud-code scripts create testscript {path}")
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -525,8 +536,8 @@ public async Task CloudCodeCreateZeroExitCodeWithParamParsing()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create {k_ValidScriptName} {path}")
-            .AssertStandardOutputContains($"Script '{k_ValidScriptName}' created.")
+            .Command($"cloud-code scripts create {k_ValidScriptName} {path}")
+            .AssertStandardErrorContains($"Script '{k_ValidScriptName}' created.")
             .ExecuteAsync();
     }
 
@@ -538,8 +549,8 @@ public async Task CloudCodeCreateZeroExitCodeWithNoParamParsing()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code create {k_ValidScriptName} {path}")
-            .AssertStandardOutputContains($"Script '{k_ValidScriptName}' created.")
+            .Command($"cloud-code scripts create {k_ValidScriptName} {path}")
+            .AssertStandardErrorContains($"Script '{k_ValidScriptName}' created.")
             .ExecuteAsync();
     }
 
@@ -549,9 +560,9 @@ public async Task CloudCodeUpdateThrowsErrorWhenProjectIdNotSet()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await new UgsCliTestCase()
-            .Command($"cloud-code update {k_ValidScriptName} invalidpath")
+            .Command($"cloud-code scripts update {k_ValidScriptName} invalidpath")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_ProjectIdNotSetErrorMessage)
+            .AssertStandardErrorContains(k_ProjectIdNotSetErrorMessage)
             .ExecuteAsync();
     }
 
@@ -561,9 +572,9 @@ public async Task CloudCodeUpdateThrowsErrorWhenEnvironmentNotSet()
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
 
         await new UgsCliTestCase()
-            .Command($"cloud-code update {k_ValidScriptName} invalidpath")
+            .Command($"cloud-code scripts update {k_ValidScriptName} invalidpath")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_EnvironmentNameNotSetErrorMessage)
+            .AssertStandardErrorContains(k_EnvironmentNameNotSetErrorMessage)
             .ExecuteAsync();
     }
 
@@ -575,9 +586,9 @@ public async Task CloudCodeUpdateThrowsErrorWhenFilepathIsInvalid(string? filepa
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code update {k_ValidScriptName} {filepath}")
+            .Command($"cloud-code scripts update {k_ValidScriptName} {filepath}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -589,9 +600,9 @@ public async Task CloudCodeUpdateThrowsErrorWhenFileNotFound()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command("cloud-code update scriptname pathToFileThatDoesntExist")
+            .Command("cloud-code scripts update scriptname pathToFileThatDoesntExist")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -603,9 +614,9 @@ public async Task CloudCodeUpdateThrowsErrorWhenFileAccessUnauthorized()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code update scriptname {unauthorizedFilepath}")
+            .Command($"cloud-code scripts update scriptname {unauthorizedFilepath}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_UnauthorizedFileAccessErrorMessage)
+            .AssertStandardErrorContains(k_UnauthorizedFileAccessErrorMessage)
             .ExecuteAsync();
     }
 
@@ -620,9 +631,9 @@ public async Task CloudCodeUpdateThrowsErrorWhenScriptNameInvalid(string scriptN
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code update {scriptName} {path}")
+            .Command($"cloud-code scripts update {scriptName} {path}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -636,9 +647,9 @@ public async Task CloudCodeUpdateThrowsErrorWhenCodeNullOrEmpty()
         var path = Path.GetFullPath(k_ValidFilepath);
 
         await GetLoggedInCli()
-            .Command($"cloud-code update testscript {path}")
+            .Command($"cloud-code scripts update testscript {path}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -650,9 +661,9 @@ public async Task CloudCodeUpdateThrowsErrorWhenNotLoggedIn()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await new UgsCliTestCase()
-            .Command($"cloud-code update testscript {path}")
+            .Command($"cloud-code scripts update testscript {path}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_LoggedOutErrorMessage)
+            .AssertStandardErrorContains(k_LoggedOutErrorMessage)
             .ExecuteAsync();
     }
 
@@ -665,8 +676,8 @@ public async Task CloudCodeUpdateThrowsErrorWhenInvalidScriptParameters()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code update {k_ValidScriptName} {path}")
-            .AssertStandardOutputContains(expectedMsg)
+            .Command($"cloud-code scripts update {k_ValidScriptName} {path}")
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -679,8 +690,8 @@ public async Task CloudCodeUpdateZeroExitCodeWithParamParsing()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code update {k_ValidScriptName} {path}")
-            .AssertStandardOutputContains(expectedMsg)
+            .Command($"cloud-code scripts update {k_ValidScriptName} {path}")
+            .AssertStandardErrorContains(expectedMsg)
             .AssertNoErrors()
             .ExecuteAsync();
     }
@@ -694,9 +705,113 @@ public async Task CloudCodeUpdateZeroExitCodeWithNoParamParsing()
         SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
 
         await GetLoggedInCli()
-            .Command($"cloud-code update {k_ValidScriptName} {path}")
+            .Command($"cloud-code scripts update {k_ValidScriptName} {path}")
+            .AssertStandardErrorContains(expectedMsg)
+            .ExecuteAsync();
+    }
+
+    [Test]
+
+    [Ignore($"Banasco integration test WIP")]
+    public async Task CloudCodeImport_Success()
+    {
+        const string expectedMsg = $"Script [test-3] successfully updated";
+
+        SetConfigValue("project-id", CommonKeys.ValidProjectId);
+        SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
+
+        await GetLoggedInCli()
+            .Command($"cloud-code scripts import {k_ImportTestFileDirectory} test.jszip")
+            .AssertNoErrors()
+            .AssertStandardOutputContains(expectedMsg)
+            .ExecuteAsync();
+    }
+
+    [Test]
+    [Ignore($"Banasco integration test WIP")]
+    public async Task CloudCodeImport_NoFilenameSpecified_Error()
+    {
+        const string expectedMsg = $"The file at 'Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ScriptTestCases/Import\\ugs-cc-scripts.jszip' could not be found. Ensure the file exists and the specified path is correct";
+
+        SetConfigValue("project-id", CommonKeys.ValidProjectId);
+        SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
+
+        await GetLoggedInCli()
+            .Command($"cloud-code scripts import {k_ImportTestFileDirectory}")
+            .AssertExitCode(1)
+            .AssertStandardOutputContains(expectedMsg)
+            .ExecuteAsync();
+    }
+
+    [Test]
+    public async Task CloudCodeExport_Success()
+    {
+        const string filename = "test.jszip";
+        const string expectedMsg = $"Exporting your environment...";
+        var filePath = Path.Join(k_TestDirectory, filename);
+
+        if (File.Exists(filePath))
+        {
+            File.Delete(Path.Join(k_TestDirectory, filename));
+        }
+
+        SetConfigValue("project-id", CommonKeys.ValidProjectId);
+        SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
+
+        await GetLoggedInCli()
+            .Command($"cloud-code scripts export {k_TestDirectory} {filename}")
             .AssertNoErrors()
             .AssertStandardOutputContains(expectedMsg)
             .ExecuteAsync();
+
+        Assert.IsTrue(File.Exists(filePath));
+    }
+
+    [Test]
+    public async Task CloudCodeExport_NoFilenameSpecified_Success()
+    {
+        const string filename = "ugs-cc-scripts.jszip";
+        const string expectedMsg = $"Exporting your environment...";
+        var filePath = Path.Join(k_TestDirectory, filename);
+
+        if (File.Exists(filePath))
+        {
+            File.Delete(Path.Join(k_TestDirectory, filename));
+        }
+
+        SetConfigValue("project-id", CommonKeys.ValidProjectId);
+        SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
+
+        await GetLoggedInCli()
+            .Command($"cloud-code scripts export {k_TestDirectory}")
+            .AssertNoErrors()
+            .AssertStandardOutputContains(expectedMsg)
+            .ExecuteAsync();
+
+        Assert.IsTrue(File.Exists(Path.Join(k_TestDirectory, filename)));
+    }
+
+    [Test]
+    [Ignore($"Banasco integration test WIP")]
+    public async Task CloudCodeExport_FileAlreadyExists_Error()
+    {
+        const string filename = "test.jszip";
+        const string expectedMsg = $"The filename to export to already exists. Please create a new file";
+
+        var filePath = Path.Join(k_TestDirectory, filename);
+
+        if (!File.Exists(filePath))
+        {
+            File.Create(filePath);
+        }
+
+        SetConfigValue("project-id", CommonKeys.ValidProjectId);
+        SetConfigValue("environment-name", CommonKeys.ValidEnvironmentName);
+
+        await GetLoggedInCli()
+            .Command($"cloud-code scripts export {k_TestDirectory} {filename}")
+            .AssertExitCode(1)
+            .AssertStandardOutputContains(expectedMsg)
+            .ExecuteAsync();
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliBuilder.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliBuilder.cs
index 9930005..55ce118 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliBuilder.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliBuilder.cs
@@ -77,7 +77,7 @@ static IReadOnlyDictionary<string, string> GetCliBuildEnvironmentVariables()
             {
                 ["SKIP_MACOS_BUILD"] = "1",
                 ["SKIP_WINDOWS_BUILD"] = "1",
-                ["SKIP_ALPINE_LINUX_BUILD"] = "1",
+                ["SKIP_LINUX_MUSL_BUILD"] = "1",
             };
         }
 
@@ -87,7 +87,7 @@ static IReadOnlyDictionary<string, string> GetCliBuildEnvironmentVariables()
             {
                 ["SKIP_LINUX_BUILD"] = "1",
                 ["SKIP_WINDOWS_BUILD"] = "1",
-                ["SKIP_ALPINE_LINUX_BUILD"] = "1",
+                ["SKIP_LINUX_MUSL_BUILD"] = "1",
             };
         }
 
@@ -97,7 +97,7 @@ static IReadOnlyDictionary<string, string> GetCliBuildEnvironmentVariables()
             {
                 ["SKIP_LINUX_BUILD"] = "1",
                 ["SKIP_MACOS_BUILD"] = "1",
-                ["SKIP_ALPINE_LINUX_BUILD"] = "1",
+                ["SKIP_LINUX_MUSL_BUILD"] = "1",
             };
         }
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliFixture.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliFixture.cs
index 633d97b..570dc9f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliFixture.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliFixture.cs
@@ -2,6 +2,7 @@
 using System.Threading.Tasks;
 using NUnit.Framework;
 using Unity.Services.Cli.Common.Networking;
+using Unity.Services.Cli.IntegrationTest.Common;
 using Unity.Services.Cli.MockServer;
 using Unity.Services.Cli.MockServer.Common;
 
@@ -10,7 +11,7 @@ namespace Unity.Services.Cli.IntegrationTest;
 /// <summary>
 /// A test fixture to facilitate integration testing
 /// </summary>
-[TestFixture]
+[TestFixture, Timeout(5 * 60 * 1000)]
 public abstract class UgsCliFixture
 {
 #if DISABLE_CLI_REBUILD
@@ -32,9 +33,9 @@ public abstract class UgsCliFixture
     /// </summary>
     protected string CredentialsFile => m_IntegrationConfig.CredentialsFile;
 
-    protected readonly MockApi m_MockApi = new (NetworkTargetEndpoints.MockServer);
+    protected readonly MockApi m_MockApi = new(NetworkTargetEndpoints.MockServer);
 
-    readonly IntegrationConfig m_IntegrationConfig = new ();
+    readonly IntegrationConfig m_IntegrationConfig = new();
 
     [OneTimeTearDown]
     public void DisposeMockServer()
@@ -91,4 +92,10 @@ protected static UgsCliTestCase GetLoggedInCli()
             .Command($"login --service-key-id {CommonKeys.ValidServiceAccKeyId} --secret-key-stdin")
             .StandardInputWriteLine(CommonKeys.ValidServiceAccSecretKey);
     }
+
+    protected UgsCliTestCase GetFullySetCli()
+    {
+        SetupProjectAndEnvironment();
+        return GetLoggedInCli();
+    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.ExternalProcess.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.ExternalProcess.cs
new file mode 100644
index 0000000..f3e5c2b
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.ExternalProcess.cs
@@ -0,0 +1,42 @@
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Unity.Services.Cli.IntegrationTest.Common;
+
+public partial class UgsCliTestCase
+{
+    class ExternalProcess : IProcess
+    {
+        public ExternalProcess(Process innerProcess)
+        {
+            InnerProcess = innerProcess;
+        }
+
+        public Process InnerProcess { get; }
+
+        public bool HasExited => InnerProcess.HasExited;
+        public Task WaitForExitAsync(CancellationToken cancellationToken = default)
+        {
+            return InnerProcess.WaitForExitAsync(cancellationToken);
+        }
+
+        public int ExitCode => InnerProcess.ExitCode;
+
+        public ProcessStartInfo StartInfo => InnerProcess.StartInfo;
+        public bool Start()
+        {
+            return InnerProcess.Start();
+        }
+
+        public void Dispose()
+        {
+            InnerProcess.Dispose();
+        }
+
+        public StreamWriter StandardInput => InnerProcess.StandardInput;
+        public StreamReader StandardOutput => InnerProcess.StandardOutput;
+        public StreamReader StandardError => InnerProcess.StandardError;
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.IProcess.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.IProcess.cs
new file mode 100644
index 0000000..e8003b3
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.IProcess.cs
@@ -0,0 +1,22 @@
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Unity.Services.Cli.IntegrationTest.Common;
+
+public partial class UgsCliTestCase
+{
+    interface IProcess
+    {
+        bool HasExited { get; }
+        Task WaitForExitAsync(CancellationToken cancellationToken = default);
+        StreamWriter StandardInput { get; }
+        public StreamReader StandardOutput { get; }
+        public StreamReader StandardError { get; }
+        int ExitCode { get; }
+        ProcessStartInfo StartInfo { get; }
+        bool Start();
+        void Dispose();
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.LocalProcess.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.LocalProcess.cs
new file mode 100644
index 0000000..7030846
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.LocalProcess.cs
@@ -0,0 +1,88 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Unity.Services.Cli.Common.Logging;
+
+namespace Unity.Services.Cli.IntegrationTest.Common;
+
+public partial class UgsCliTestCase
+{
+    class LocalProcess : IProcess
+    {
+        Task<int>? m_InnerTask;
+        MemoryStream m_StdOutWriter;
+        MemoryStream m_StdErrWriter;
+
+        public LocalProcess(ProcessStartInfo info)
+        {
+            StartInfo = info;
+            StandardError = null!;
+            StandardOutput = null!;
+            m_StdOutWriter = null!;
+            m_StdErrWriter = null!;
+        }
+
+        public bool HasExited { get; private set; }
+        public async Task WaitForExitAsync(CancellationToken cancellationToken = default)
+        {
+            if (m_InnerTask == null)
+                throw new InvalidOperationException("Local 'Main' has not been started");
+            if (HasExited)
+                return;
+            ExitCode = await m_InnerTask!;
+            await m_StdErrWriter.FlushAsync(cancellationToken);
+            await m_StdOutWriter.FlushAsync(cancellationToken);
+
+            m_StdErrWriter.Position = 0;
+            m_StdOutWriter.Position = 0;
+            HasExited = true;
+        }
+
+        public int ExitCode { get; private set; }
+
+        public ProcessStartInfo StartInfo { get; }
+
+        public bool Start()
+        {
+            if (m_InnerTask != null)
+                throw new InvalidOperationException("Local process was already started");
+
+            //This split method does not account for \" at the moment
+            var args = StartInfo.Arguments.Split(
+                ' ',
+                StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+
+            Environment.CurrentDirectory = UgsCliBuilder.RootDirectory;
+
+            m_StdOutWriter= new MemoryStream(32*1024);
+            m_StdErrWriter = new MemoryStream(32*1024);
+
+            var stdOutWrite = new StreamWriter(m_StdOutWriter) { AutoFlush = true };
+            var stdErrWrite = new StreamWriter(m_StdErrWriter){ AutoFlush = true };
+            var logger = new Logger
+            {
+                StdOut = stdOutWrite,
+                StdErr = stdErrWrite
+            };
+
+            StandardOutput = new StreamReader(m_StdOutWriter);
+            StandardError = new StreamReader(m_StdErrWriter);
+
+            m_InnerTask = Program.InternalMain(args, logger);
+            return true;
+        }
+
+        public void Dispose()
+        {
+            StandardOutput.Dispose();
+            StandardInput.Dispose();
+        }
+
+        public StreamWriter StandardInput
+            => throw new NotSupportedException("stdin is not currently supported for local process");
+        public StreamReader StandardOutput { get; private set; }
+        public StreamReader StandardError { get; private set; }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.cs
index e349893..9fef259 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Common/UgsCliTestCase.cs
@@ -6,17 +6,20 @@
 using System.Threading.Tasks;
 using NUnit.Framework;
 using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Common.Networking;
 
-namespace Unity.Services.Cli.IntegrationTest;
+namespace Unity.Services.Cli.IntegrationTest.Common;
 
 /// <summary>
 /// A fluent API class to enable integration tests
 /// </summary>
-public class UgsCliTestCase
+public partial class UgsCliTestCase
 {
     IDictionary<string, string>? m_EnvironmentVariables;
-    Process? m_LastProcess;
-    readonly IDictionary<Process, bool> m_ProcessStartState = new Dictionary<Process, bool>();
+
+    IProcess? m_LastProcess;
+
+    readonly IDictionary<IProcess, bool> m_ProcessStartState = new Dictionary<IProcess, bool>();
     readonly List<Func<CancellationToken, Task>> m_Tasks = new();
     const string k_CliName = "ugs ";
 
@@ -24,6 +27,7 @@ public class UgsCliTestCase
     /// Adds a command to be executed to the queue.
     /// </summary>
     /// <param name="arguments">the arguments passed to the `ugs` cli</param>
+    /// <param name="debugLocally">Run Test in the same process for debugging purposes only</param>
     /// <returns>Instance of the test case</returns>
     /// <remarks>
     /// Note that the command name (`ugs`) is omitted. Only pass the arguments.
@@ -31,38 +35,65 @@ public class UgsCliTestCase
     /// </remarks>
     public UgsCliTestCase Command(string arguments)
     {
-        if (arguments.StartsWith(k_CliName))
+        var processStartInfo = GetProcessStartInfo(arguments);
+        var process = new Process
         {
-            throw new ArgumentException($"{nameof(arguments)} should not start with `ugs`.\n" +
-                "only pass the arguments, without the command name `ugs`", nameof(arguments));
-        }
-        m_Tasks.Add(async cancellationToken =>
-        {
-            var process = new Process
+            StartInfo = processStartInfo,
+            EnableRaisingEvents = true,
+        };
+        var wrapper = new ExternalProcess(process);
+        return Command(wrapper);
+    }
+
+    public UgsCliTestCase DebugCommand(string arguments)
+    {
+        NetworkTargetEndpoints.UseMockEndpoints = true;
+        var processStartInfo = GetProcessStartInfo(arguments);
+        var process = new LocalProcess(processStartInfo);
+        return Command(process);
+    }
+
+    UgsCliTestCase Command(IProcess process)
+    {
+        m_Tasks.Add(
+            async cancellationToken =>
             {
-                StartInfo = new ProcessStartInfo
+                m_ProcessStartState[process] = false;
+                if (m_LastProcess != null)
                 {
-                    FileName = UgsCliBuilder.CliPath,
-                    Arguments = arguments,
-                    WorkingDirectory = UgsCliBuilder.RootDirectory,
-                    RedirectStandardOutput = true,
-                    RedirectStandardError = true,
-                    RedirectStandardInput = true,
-                    UseShellExecute = false,
-                },
-                EnableRaisingEvents = true,
-            };
-            m_ProcessStartState[process] = false;
-            if (m_LastProcess != null)
-            {
-                EnsureProcessStarted();
-                await m_LastProcess!.WaitForExitAsync(cancellationToken);
-            }
-            m_LastProcess = process;
-        });
+                    EnsureProcessStarted();
+                    await m_LastProcess!.WaitForExitAsync(cancellationToken);
+                }
+
+                m_LastProcess = process;
+            });
+
         return this;
     }
 
+    static ProcessStartInfo GetProcessStartInfo(string arguments)
+    {
+        if (arguments.StartsWith(k_CliName))
+        {
+            throw new ArgumentException(
+                $"{nameof(arguments)} should not start with `ugs`.\n" +
+                "only pass the arguments, without the command name `ugs`",
+                nameof(arguments));
+        }
+
+        var processStartInfo = new ProcessStartInfo
+        {
+            FileName = UgsCliBuilder.CliPath,
+            Arguments = arguments,
+            WorkingDirectory = UgsCliBuilder.RootDirectory,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            RedirectStandardInput = true,
+            UseShellExecute = false,
+        };
+        return processStartInfo;
+    }
+
     /// <summary>
     /// Set environment variables to be used when running commands
     /// </summary>
@@ -167,7 +198,7 @@ public UgsCliTestCase AssertStandardOutputContains(string expectedOutput)
             EnsureProcessStarted();
             await m_LastProcess!.WaitForExitAsync(cancellationToken);
             var output = await m_LastProcess.StandardOutput.ReadToEndAsync();
-            StringAssert.Contains(expectedOutput, output);
+            StringAssert.Contains(expectedOutput, output, "stdout is not as expected");
         });
         return this;
     }
@@ -210,7 +241,7 @@ public UgsCliTestCase AssertStandardErrorContains(string expectedError)
             EnsureProcessStarted();
             await m_LastProcess!.WaitForExitAsync(cancellationToken);
             var output = await m_LastProcess.StandardError.ReadToEndAsync();
-            StringAssert.Contains(expectedError, output);
+            StringAssert.Contains(expectedError, output, "stderr is not as expected");
         });
         return this;
     }
@@ -256,7 +287,14 @@ public async Task ExecuteAsync(CancellationToken cancellationToken = default)
 
         if (m_LastProcess != null && m_ProcessStartState[m_LastProcess] && !m_LastProcess.HasExited)
         {
-            await m_LastProcess!.WaitForExitAsync(cancellationToken);
+            try
+            {
+                await m_LastProcess!.WaitForExitAsync(cancellationToken);
+            }
+            finally
+            {
+                m_LastProcess!.Dispose();
+            }
         }
     }
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/ConfigTests/ConfigTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/ConfigTests/ConfigTests.cs
index 64fc73d..a5ff4b3 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/ConfigTests/ConfigTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/ConfigTests/ConfigTests.cs
@@ -8,6 +8,7 @@
 using Unity.Services.Cli.Common.Input;
 using Unity.Services.Cli.Common.Models;
 using Unity.Services.Cli.Common.Validator;
+using Unity.Services.Cli.IntegrationTest.Common;
 
 namespace Unity.Services.Cli.IntegrationTest.ConfigTests;
 
@@ -30,7 +31,6 @@ public async Task ConfigSetSavesToConfigFile()
     {
         await new UgsCliTestCase()
             .Command("config set environment-name test-123")
-            .AssertNoErrors()
             .WaitForExit(() => AssertConfigValue("environment-name", "test-123"))
             .ExecuteAsync();
     }
@@ -50,15 +50,11 @@ public async Task ConfigGetReadsFromConfigFile()
     [Test]
     public async Task ConfigGetJsonReturnsJson()
     {
-        var expected = JsonConvert.SerializeObject(new
-        {
-            Result = "some-value",
-            Messages = Array.Empty<string>()
-        }, Formatting.Indented);
+        var expected = JsonConvert.SerializeObject( "some-value");
         await new UgsCliTestCase()
             .Command("config set environment-name some-value")
             .Command("config get environment-name -j")
-            .AssertNoErrors()
+            .AssertStandardErrorContains(string.Empty)
             .AssertStandardOutputContains(expected)
             .ExecuteAsync();
     }
@@ -71,7 +67,7 @@ public async Task ConfigSetEnvironmentFails()
         await new UgsCliTestCase()
             .Command("config set environment-name test@")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedError)
+            .AssertStandardErrorContains(expectedError)
             .ExecuteAsync();
     }
 
@@ -81,7 +77,7 @@ public async Task ConfigSetProjectIdFails()
         await new UgsCliTestCase()
             .Command("config set project-id 1")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains("Your project-id is not valid. Valid input should have characters 0-9, a-f, A-F and follow the format XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.")
+            .AssertStandardErrorContains("Your project-id is not valid. Valid input should have characters 0-9, a-f, A-F and follow the format XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.")
             .ExecuteAsync();
     }
 
@@ -105,7 +101,7 @@ public async Task ConfigGetUnsetValueReturnsError()
 
         await new UgsCliTestCase()
             .Command("config get project-id")
-            .AssertStandardOutput(output => StringAssert.Contains(expectedError, output))
+            .AssertStandardError(output => StringAssert.Contains(expectedError, output))
             .AssertExitCode(ExitCode.HandledError)
             .ExecuteAsync();
     }
@@ -138,8 +134,7 @@ public async Task ConfigDeleteSpecificKeySavesToConfigFile()
 
         await new UgsCliTestCase()
             .Command($"config delete -k {Keys.ConfigKeys.EnvironmentName} -f")
-            .AssertNoErrors()
-            .AssertStandardOutputContains(expectedError)
+            .AssertStandardErrorContains(expectedError)
             .WaitForExit(() => AssertConfigValue(Keys.ConfigKeys.EnvironmentName, null))
             .ExecuteAsync();
     }
@@ -152,8 +147,7 @@ public async Task ConfigDeleteAllKeysSavesToConfigFile()
 
         await new UgsCliTestCase()
             .Command("config delete -a -f")
-            .AssertNoErrors()
-            .AssertStandardOutputContains(expectedError)
+            .AssertStandardErrorContains(expectedError)
             .WaitForExit(() => AssertConfigValue(Keys.ConfigKeys.EnvironmentName, null))
             .ExecuteAsync();
     }
@@ -166,7 +160,7 @@ public async Task ConfigDeleteWithInvalidKeyErrorsOut()
         await new UgsCliTestCase()
             .Command("config delete -k invalid-key -f")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedError)
+            .AssertStandardErrorContains(expectedError)
             .ExecuteAsync();
     }
 
@@ -179,7 +173,7 @@ public async Task ConfigDeleteSpecifyingAllKeysWithSpecificKeysErrorsOut()
         await new UgsCliTestCase()
             .Command($"config delete -k {Keys.ConfigKeys.EnvironmentName} -a -f")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedError)
+            .AssertStandardErrorContains(expectedError)
             .ExecuteAsync();
     }
 
@@ -193,7 +187,7 @@ public async Task ConfigDeleteNoValidOptionErrorsOut()
         await new UgsCliTestCase()
             .Command("config delete")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedError)
+            .AssertStandardErrorContains(expectedError)
             .ExecuteAsync();
     }
 
@@ -205,7 +199,7 @@ public async Task ConfigDeleteNoForceOptionErrorsOut()
         await new UgsCliTestCase()
             .Command($"config delete -k {Keys.ConfigKeys.EnvironmentName}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedError)
+            .AssertStandardErrorContains(expectedError)
             .ExecuteAsync();
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/EnvTests/EnvTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/EnvTests/EnvTests.cs
index 45c7cad..8e76463 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/EnvTests/EnvTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/EnvTests/EnvTests.cs
@@ -4,6 +4,7 @@
 using Unity.Services.Cli.Common.Exceptions;
 using Unity.Services.Cli.Common.Networking;
 using Unity.Services.Cli.Common.Validator;
+using Unity.Services.Cli.IntegrationTest.Common;
 using Unity.Services.Cli.MockServer;
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Cli.MockServer.ServiceMocks;
@@ -36,7 +37,7 @@ public async Task EnvironmentListThrowsProjectIdNotSetException()
         await GetLoggedInCli()
             .Command("env list")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutput(output => Assert.IsTrue(output.Contains(expectedMsg)))
+            .AssertStandardError(output => Assert.IsTrue(output.Contains(expectedMsg)))
             .ExecuteAsync();
     }
 
@@ -47,7 +48,7 @@ public async Task EnvironmentListThrowsNotLoggedInException()
         await new UgsCliTestCase()
             .Command("env list")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_NotLoggedInMessage)
+            .AssertStandardErrorContains(k_NotLoggedInMessage)
             .ExecuteAsync();
     }
 
@@ -60,7 +61,6 @@ public async Task EnvironmentListReturnsZeroExitCode()
         await GetLoggedInCli()
             .Command("env list")
             .AssertStandardOutputContains(expectedReturn)
-            .AssertNoErrors()
             .ExecuteAsync();
     }
 
@@ -89,7 +89,7 @@ public async Task EnvironmentAdditionThrowsProjectIdNotSetException()
         await new UgsCliTestCase()
             .Command("env add 1")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -100,7 +100,7 @@ public async Task EnvironmentAdditionThrowsNotLoggedInException()
         await new UgsCliTestCase()
             .Command($"env add test1")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_NotLoggedInMessage)
+            .AssertStandardErrorContains(k_NotLoggedInMessage)
             .ExecuteAsync();
     }
 
@@ -111,7 +111,7 @@ public async Task EnvironmentAdditionThrowsInvalidEnvironmentFormatException()
         await GetLoggedInCli()
             .Command("env add test@")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_InvalidEnvNameMsg)
+            .AssertStandardErrorContains(k_InvalidEnvNameMsg)
             .ExecuteAsync();
     }
 
@@ -123,7 +123,7 @@ public async Task EnvironmentAdditionReturnsZeroExitCode()
 
         await GetLoggedInCli()
             .Command("env add test-env-123")
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .AssertNoErrors()
             .ExecuteAsync();
     }
@@ -138,7 +138,7 @@ public async Task EnvironmentDeleteThrowsProjectIdNotSetException()
         await new UgsCliTestCase()
             .Command("env delete test-env-123")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -149,7 +149,7 @@ public async Task EnvironmentDeleteThrowsNotLoggedInException()
         await new UgsCliTestCase()
             .Command("env delete test-env-123")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_NotLoggedInMessage)
+            .AssertStandardErrorContains(k_NotLoggedInMessage)
             .ExecuteAsync();
     }
 
@@ -160,7 +160,7 @@ public async Task EnvironmentDeleteThrowsInvalidEnvironmentFormatException()
         await GetLoggedInCli()
             .Command("env delete test@")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_InvalidEnvNameMsg)
+            .AssertStandardErrorContains(k_InvalidEnvNameMsg)
             .ExecuteAsync();
     }
 
@@ -172,7 +172,7 @@ public async Task EnvironmentDeleteReturnsZeroExitCode()
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
         await GetLoggedInCli()
             .Command($"env delete \"{CommonKeys.ValidEnvironmentName}\"")
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .AssertNoErrors()
             .ExecuteAsync();
     }
@@ -184,7 +184,7 @@ public async Task EnvironmentUseThrowsInvalidEnvironmentFormatException()
         await new UgsCliTestCase()
             .Command("env use test@")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_InvalidEnvNameMsg)
+            .AssertStandardErrorContains(k_InvalidEnvNameMsg)
             .ExecuteAsync();
     }
 
@@ -193,7 +193,6 @@ public async Task EnvironmentUseReturnsZeroExitCode()
     {
         await new UgsCliTestCase()
             .Command("env use 123")
-            .AssertNoErrors()
             .ExecuteAsync();
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LeaderboardTests/LeaderboardSetupFailureTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LeaderboardTests/LeaderboardSetupFailureTests.cs
index f21d15f..af70617 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LeaderboardTests/LeaderboardSetupFailureTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LeaderboardTests/LeaderboardSetupFailureTests.cs
@@ -3,6 +3,7 @@
 using Unity.Services.Cli.Common.Exceptions;
 using Unity.Services.Cli.Common.Models;
 using Unity.Services.Cli.Common.Networking;
+using Unity.Services.Cli.IntegrationTest.Common;
 using Unity.Services.Cli.MockServer;
 using Unity.Services.Cli.MockServer.Common;
 
@@ -37,7 +38,7 @@ public async Task LeaderboardThrowsProjectIdNotSetException(string command)
         await GetLoggedInCli()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_ProjectIdNotSetErrorMessage)
+            .AssertStandardErrorContains(k_ProjectIdNotSetErrorMessage)
             .ExecuteAsync();
     }
 
@@ -55,7 +56,7 @@ public async Task LeaderboardListThrowsNotLoggedInException(string command)
         await new UgsCliTestCase()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_LoggedOutErrorMessage)
+            .AssertStandardErrorContains(k_LoggedOutErrorMessage)
             .ExecuteAsync();
     }
 
@@ -72,7 +73,7 @@ public async Task LeaderboardListThrowsEnvironmentIdNotSetException(string comma
         await GetLoggedInCli()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_EnvironmentNameNotSetErrorMessage)
+            .AssertStandardErrorContains(k_EnvironmentNameNotSetErrorMessage)
             .ExecuteAsync();
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LeaderboardTests/LeaderboardTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LeaderboardTests/LeaderboardTests.cs
index d197643..0387de0 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LeaderboardTests/LeaderboardTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LeaderboardTests/LeaderboardTests.cs
@@ -15,11 +15,12 @@ namespace Unity.Services.Cli.IntegrationTest.LeaderboardTests;
 public class LeaderboardTests : UgsCliFixture
 {
     static readonly string k_TestDirectory = Path.Combine(UgsCliBuilder.RootDirectory, ".tmp/FilesDir");
-    private static readonly string k_LeaderboardFileName = "foo";
-    static readonly string k_LearedboardDefaultZipFileName = "ugs";
-    private static readonly string k_LeaderboardZipFileName = "test_name";
-    private static readonly string k_MissingFieldLeaderboardFileName = "missing";
-    private static readonly string k_brokenFile = "broken";
+    static readonly string k_LeaderboardFileName = "foo";
+    static readonly string k_MissingFieldLeaderboardFileName = "missing";
+    static readonly string k_brokenFile = "broken";
+
+    static readonly string k_defaultFileName = "ugs.lbzip";
+    static readonly string k_alternateFileName = "other.lbzip";
 
     [OneTimeTearDown]
     public void OneTimeTearDown()
@@ -42,13 +43,9 @@ public async Task SetUp()
             Directory.Delete(k_TestDirectory, true);
         }
         Directory.CreateDirectory(k_TestDirectory);
-        await File.WriteAllTextAsync(k_TestDirectory + "/" + k_LeaderboardFileName, JsonConvert.SerializeObject(LeaderboardApiMock.Leaderboard1));
-        await File.WriteAllTextAsync(k_TestDirectory + "/" + k_MissingFieldLeaderboardFileName, "{ \"id\": \"lb1\", \"name\": \"leaderboard 1\" }");
-        await File.WriteAllTextAsync(k_TestDirectory + "/" + k_brokenFile, "{");
-
-        ZipArchiver<UpdatedLeaderboardConfig> m_zipArchiver = new ZipArchiver<UpdatedLeaderboardConfig>();
-        m_zipArchiver.Zip(k_TestDirectory + "/" + k_LearedboardDefaultZipFileName, k_LearedboardDefaultZipFileName, "test", "lbzip", new[] { LeaderboardApiMock.Leaderboard1 });
-        m_zipArchiver.Zip(k_TestDirectory + "/" + k_LeaderboardZipFileName, k_LearedboardDefaultZipFileName, "test", "lbzip", new[] { LeaderboardApiMock.Leaderboard1 });
+        await File.WriteAllTextAsync(Path.Join(k_TestDirectory, k_LeaderboardFileName), JsonConvert.SerializeObject(LeaderboardApiMock.Leaderboard1));
+        await File.WriteAllTextAsync(Path.Join(k_TestDirectory, k_MissingFieldLeaderboardFileName), "{ \"id\": \"lb1\", \"name\": \"leaderboard 1\" }");
+        await File.WriteAllTextAsync(Path.Join(k_TestDirectory, k_brokenFile), "{");
 
         m_MockApi.Server?.ResetMappings();
         await m_MockApi.MockServiceAsync(new IdentityV1Mock());
@@ -58,7 +55,7 @@ public async Task SetUp()
     [Test]
     public async Task LeaderboardListSucceed()
     {
-        var expectedMessage = @"Fetching leaderboard list...
+        var expectedResult = @"Fetching leaderboard list...
 [
   {
     ""Id"": ""lb1"",
@@ -68,31 +65,26 @@ public async Task LeaderboardListSucceed()
     ""Id"": ""lb2"",
     ""Name"": ""leaderboard 2""
   }
-]
-";
-        await AssertSuccess("leaderboards list", expectedMessage);
+]";
+        await AssertSuccess("leaderboards list", expectedResult: expectedResult);
     }
 
     [Test]
     public async Task LeaderboardListSucceedJson()
     {
-        var expectedMessage = @"{
-  ""Result"": {
-    ""Leaderboards"": [
-      {
-        ""Id"": ""lb1"",
-        ""Name"": ""leaderboard 1""
-      },
-      {
-        ""Id"": ""lb2"",
-        ""Name"": ""leaderboard 2""
-      }
-    ]
-  },
-  ""Messages"": []
-}
-";
-        await AssertSuccess("leaderboards list -j", expectedMessage);
+        var expectedResult = @"{
+  ""Leaderboards"": [
+    {
+      ""Id"": ""lb1"",
+      ""Name"": ""leaderboard 1""
+    },
+    {
+      ""Id"": ""lb2"",
+      ""Name"": ""leaderboard 2""
+    }
+  ]
+}";
+        await AssertSuccess("leaderboards list -j", expectedResult: expectedResult);
     }
 
     [Test]
@@ -101,7 +93,7 @@ public async Task LeaderboardListSucceedWithOption()
         DeleteLocalConfig();
         DeleteLocalCredentials();
 
-        var expectedMessage = @"Fetching leaderboard list...
+        var expectedResult = @"Fetching leaderboard list...
 [
   {
     ""Id"": ""lb1"",
@@ -113,14 +105,15 @@ public async Task LeaderboardListSucceedWithOption()
   }
 ]
 ";
-        await AssertSuccess($"leaderboards list -p {CommonKeys.ValidProjectId} -e {CommonKeys.ValidEnvironmentName}", expectedMessage);
+        await AssertSuccess($"leaderboards list -p {CommonKeys.ValidProjectId} -e {CommonKeys.ValidEnvironmentName}", expectedResult: expectedResult);
     }
 
     [Test]
     public async Task LeaderboardGetSucceed()
     {
-        var expectedMessage =
-            @"sortOrder: Asc
+        var expectedResult =
+            @"Fetching leaderboard info...
+sortOrder: Asc
 updateType: Aggregate
 id: lb1
 name: leaderboard 1
@@ -138,42 +131,38 @@ public async Task LeaderboardGetSucceed()
 created: 0001-01-01T00:00:00.0000000
 lastReset: 0001-01-01T00:00:00.0000000
 versions: []";
-        await AssertSuccess("leaderboards get lb1", expectedMessage);
+        await AssertSuccess("leaderboards get lb1", expectedResult: expectedResult);
     }
 
     [Test]
     public async Task LeaderboardGetSucceedJSon()
     {
-        var expectedMessage = @"{
-  ""Result"": {
-    ""SortOrder"": ""asc"",
-    ""UpdateType"": ""aggregate"",
-    ""Id"": ""lb1"",
-    ""Name"": ""leaderboard 1"",
-    ""BucketSize"": 10.0,
-    ""ResetConfig"": {
-      ""start"": ""2023-01-01T00:00:00"",
-      ""schedule"": ""@1d"",
-      ""archive"": true
-    },
-    ""TieringConfig"": {
-      ""strategy"": ""percent"",
-      ""tiers"": [
-        {
-          ""id"": ""tier1"",
-          ""cutoff"": 2.0
-        }
-      ]
-    },
-    ""Updated"": ""0001-01-01T00:00:00"",
-    ""Created"": ""0001-01-01T00:00:00"",
-    ""LastReset"": ""0001-01-01T00:00:00"",
-    ""Versions"": []
+        var expectedResult = @"{
+  ""SortOrder"": ""asc"",
+  ""UpdateType"": ""aggregate"",
+  ""Id"": ""lb1"",
+  ""Name"": ""leaderboard 1"",
+  ""BucketSize"": 10.0,
+  ""ResetConfig"": {
+    ""start"": ""2023-01-01T00:00:00"",
+    ""schedule"": ""@1d"",
+    ""archive"": true
   },
-  ""Messages"": []
-}
-";
-        await AssertSuccess("leaderboards get lb1 -j", expectedMessage);
+  ""TieringConfig"": {
+    ""strategy"": ""percent"",
+    ""tiers"": [
+      {
+        ""id"": ""tier1"",
+        ""cutoff"": 2.0
+      }
+    ]
+  },
+  ""Updated"": ""0001-01-01T00:00:00"",
+  ""Created"": ""0001-01-01T00:00:00"",
+  ""LastReset"": ""0001-01-01T00:00:00"",
+  ""Versions"": []
+}";
+        await AssertSuccess("leaderboards get lb1 -j", expectedResult: expectedResult);
     }
 
     [Test]
@@ -205,6 +194,52 @@ public async Task LeaderboardUpdateSucceed()
         await AssertSuccess($"leaderboards update lb1 {k_TestDirectory}/{k_LeaderboardFileName}", expectedMessage);
     }
 
+    [Test]
+    public async Task LeaderboardImportSucceed()
+    {
+        ZipArchiver m_zipArchiver = new ZipArchiver();
+        await m_zipArchiver.ZipAsync(Path.Join(k_TestDirectory, k_defaultFileName), "test", new[]
+            {  LeaderboardApiMock.Leaderboard1, LeaderboardApiMock.Leaderboard2, LeaderboardApiMock.Leaderboard3,
+                LeaderboardApiMock.Leaderboard4, LeaderboardApiMock.Leaderboard5, LeaderboardApiMock.Leaderboard6,
+                LeaderboardApiMock.Leaderboard7, LeaderboardApiMock.Leaderboard8, LeaderboardApiMock.Leaderboard9,
+                LeaderboardApiMock.Leaderboard10, LeaderboardApiMock.Leaderboard11, LeaderboardApiMock.Leaderboard12 });
+
+        var expectedMessage = "Importing configs...";
+        await AssertSuccess($"leaderboards import {k_TestDirectory}", expectedResult: expectedMessage);
+    }
+
+    [Test]
+    public async Task LeaderboardImportWithNameSucceed()
+    {
+        ZipArchiver m_zipArchiver = new ZipArchiver();
+        await m_zipArchiver.ZipAsync(Path.Join(k_TestDirectory, k_alternateFileName), "test", new[] { LeaderboardApiMock.Leaderboard1, LeaderboardApiMock.Leaderboard2, LeaderboardApiMock.Leaderboard3, LeaderboardApiMock.Leaderboard4, LeaderboardApiMock.Leaderboard5, LeaderboardApiMock.Leaderboard6, LeaderboardApiMock.Leaderboard7, LeaderboardApiMock.Leaderboard8, LeaderboardApiMock.Leaderboard9, LeaderboardApiMock.Leaderboard10, LeaderboardApiMock.Leaderboard11, LeaderboardApiMock.Leaderboard12 });
+
+        var expectedMessage = "Importing configs...";
+        await AssertSuccess($"leaderboards import {k_TestDirectory} {k_alternateFileName}", expectedResult: expectedMessage);
+    }
+
+    [Test]
+    public async Task LeaderboardExportSucceed()
+    {
+        var expectedMessage = "Exporting your environment...";
+        await AssertSuccess($"leaderboards export {k_TestDirectory}", expectedResult: expectedMessage);
+    }
+
+    [Test]
+    public async Task LeaderboardExportWithNameSucceed()
+    {
+        var expectedMessage = "Exporting your environment...";
+        await AssertSuccess($"leaderboards export {k_TestDirectory} {k_alternateFileName}", expectedResult: expectedMessage);
+    }
+
+    [Test]
+    public async Task LeaderboardExportWithSameNameSucceed()
+    {
+        var expectedMessage = "Exporting your environment...";
+        await AssertSuccess($"leaderboards export {k_TestDirectory} {k_alternateFileName}", expectedResult: expectedMessage);
+        var errorMessage = "The filename to export to already exists. Please create a new file";
+        await AssertException($"leaderboards export {k_TestDirectory} {k_alternateFileName}", errorMessage);
+    }
 
     [TestCase("create")]
     [TestCase("update foo")]
@@ -230,30 +265,28 @@ public async Task LeaderboardCreateMissingRequiredField()
 
     }
 
-    private static async Task AssertSuccess(string command, string expectedMessage)
+    static async Task AssertSuccess(string command, string? expectedMessage = null, string? expectedResult = null)
     {
-        await GetLoggedInCli()
-            .Command(command)
-            .AssertNoErrors()
-            .AssertStandardOutputContains(expectedMessage)
-            .ExecuteAsync();
-    }
+        var test = GetLoggedInCli()
+            .Command(command);
+        if (expectedMessage != null)
+        {
+            test = test.AssertStandardErrorContains(expectedMessage.ReplaceLineEndings());
+        }
 
-    private static async Task AssertApiException(string command)
-    {
-        await GetLoggedInCli()
-            .Command(command)
-            .AssertExitCode(ExitCode.HandledError)
-            .ExecuteAsync();
+        if (expectedResult != null)
+        {
+            test = test.AssertStandardOutputContains(expectedResult.ReplaceLineEndings());
+        }
+        await test.ExecuteAsync();
     }
 
-    private static async Task AssertException(string command, string expectedMessage)
+    static async Task AssertException(string command, string expectedMessage)
     {
         await GetLoggedInCli()
             .Command(command)
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMessage)
+            .AssertStandardErrorContains(expectedMessage)
             .ExecuteAsync();
     }
 }
-
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LobbyTests/LobbyTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LobbyTests/LobbyTests.cs
index 1917c05..ceece06 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LobbyTests/LobbyTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/LobbyTests/LobbyTests.cs
@@ -5,6 +5,7 @@
 using NUnit.Framework;
 using Unity.Services.Cli.Common.Exceptions;
 using Unity.Services.Cli.Common.Networking;
+using Unity.Services.Cli.IntegrationTest.Common;
 using Unity.Services.Cli.MockServer;
 using Unity.Services.Cli.MockServer.Common;
 using Unity.Services.Cli.MockServer.ServiceMocks;
@@ -64,7 +65,7 @@ public async Task CommandThrowsIfServiceIdIsEmpty()
         await AuthenticatedCommand()
             .Command("lobby query --service-id \"\"")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -78,7 +79,7 @@ public async Task CommandThrowsIfProjectIdIsMissing()
         await new UgsCliTestCase()
             .Command($"lobby get {k_LobbyId} {k_DefaultOptions}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -89,7 +90,7 @@ public async Task CommandThrowsIfEnvironmentNameIsMissing()
         await new UgsCliTestCase()
             .Command($"lobby get {k_LobbyId} {k_DefaultOptions}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -119,7 +120,7 @@ public async Task BulkUpdate_ThrowsIfRequestBodyIsInvalid()
         await AuthenticatedCommand()
             .Command($"lobby bulk-update {k_LobbyId} {k_InvalidJson} {k_DefaultOptions}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_FailedToDeserialize)
+            .AssertStandardErrorContains(k_FailedToDeserialize)
             .ExecuteAsync();
     }
 
@@ -164,7 +165,7 @@ public async Task Create_ThrowsIfRequestBodyIsInvalid()
         await AuthenticatedCommand()
             .Command($"lobby create {k_InvalidJson} {k_DefaultOptions}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_FailedToDeserialize)
+            .AssertStandardErrorContains(k_FailedToDeserialize)
             .ExecuteAsync();
     }
 
@@ -183,8 +184,8 @@ public async Task Delete_SucceedsWithValidInput()
     {
         await AuthenticatedCommand()
             .Command($"lobby delete {k_LobbyId} {k_DefaultOptions}")
-            .AssertStandardOutputContains("Lobby successfully deleted")
-            .AssertNoErrors()
+            .AssertStandardOutputContains(string.Empty)
+            .AssertStandardErrorContains("Lobby successfully deleted")
             .ExecuteAsync();
     }
 
@@ -262,7 +263,7 @@ public async Task Join_ThrowsIfIdAndCodeAreBothMissing()
         await AuthenticatedCommand()
             .Command($"lobby join {playerString} {k_DefaultOptions}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains("Either lobby ID or lobby code must be provided to join a lobby.")
+            .AssertStandardErrorContains("Either lobby ID or lobby code must be provided to join a lobby.")
             .ExecuteAsync();
     }
 
@@ -272,7 +273,7 @@ public async Task Join_ThrowsIfRequestBodyIsInvalid()
         await AuthenticatedCommand()
             .Command($"lobby join {k_InvalidJson} {k_DefaultOptions} --lobby-id {k_LobbyId}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_FailedToDeserialize)
+            .AssertStandardErrorContains(k_FailedToDeserialize)
             .ExecuteAsync();
     }
 
@@ -353,7 +354,7 @@ public async Task QuickJoin_ThrowsIfRequestBodyIsInvalid()
         await AuthenticatedCommand()
             .Command($"lobby quickjoin {k_InvalidJson} {k_InvalidJson} {k_DefaultOptions}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_FailedToDeserialize)
+            .AssertStandardErrorContains(k_FailedToDeserialize)
             .ExecuteAsync();
     }
 
@@ -395,8 +396,8 @@ public async Task RemovePlayer_SucceedsWithValidInput()
     {
         await AuthenticatedCommand()
             .Command($"lobby player remove {k_LobbyId} {k_PlayerId} {k_DefaultOptions}")
-            .AssertStandardOutputContains("Player successfully removed")
-            .AssertNoErrors()
+            .AssertStandardOutputContains(string.Empty)
+            .AssertStandardErrorContains("Player successfully removed")
             .ExecuteAsync();
     }
 
@@ -436,7 +437,7 @@ public async Task UpdatePlayer_ThrowsIfRequestBodyIsInvalid()
         await AuthenticatedCommand()
             .Command($"lobby player update {k_LobbyId} {k_PlayerId} {k_InvalidJson} {k_DefaultOptions}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_FailedToDeserialize)
+            .AssertStandardErrorContains(k_FailedToDeserialize)
             .ExecuteAsync();
     }
 
@@ -478,7 +479,7 @@ public async Task UpdateLobby_ThrowsIfRequestBodyIsInvalid()
         await AuthenticatedCommand()
             .Command($"lobby update {k_LobbyId} {k_InvalidJson} {k_DefaultOptions}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(k_FailedToDeserialize)
+            .AssertStandardErrorContains(k_FailedToDeserialize)
             .ExecuteAsync();
     }
 
@@ -509,8 +510,8 @@ public async Task HeartbeatLobby_SucceedsWithValidInput()
     {
         await AuthenticatedCommand()
             .Command($"lobby heartbeat {k_LobbyId} {k_DefaultOptions}")
-            .AssertStandardOutputContains("Lobby successfully heartbeated")
-            .AssertNoErrors()
+            .AssertStandardOutputContains(string.Empty)
+            .AssertStandardErrorContains("Lobby successfully heartbeated")
             .ExecuteAsync();
     }
 
@@ -589,7 +590,7 @@ public async Task UpdateConfig_ThrowsIfRequestBodyIsInvalid()
         await AuthenticatedCommand()
             .Command($"lobby config update {k_ConfigId} ''")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains("Failed to deserialize config update request body.")
+            .AssertStandardErrorContains("Empty config request body")
             .ExecuteAsync();
     }
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/MainTests/HelpTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/MainTests/HelpTests.cs
index 3f813db..e038664 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/MainTests/HelpTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/MainTests/HelpTests.cs
@@ -2,6 +2,7 @@
 using System.Threading.Tasks;
 using NUnit.Framework;
 using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.IntegrationTest.Common;
 
 namespace Unity.Services.Cli.IntegrationTest;
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/NewFile/NewFileTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/NewFile/NewFileTests.cs
index fefc79c..04dc9c9 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/NewFile/NewFileTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/NewFile/NewFileTests.cs
@@ -2,6 +2,7 @@
 using System.IO;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using Unity.Services.Cli.IntegrationTest.Common;
 
 namespace Unity.Services.Cli.IntegrationTest.NewFile;
 
@@ -15,32 +16,31 @@ public class NewFileTests : UgsCliFixture
     [TearDown]
     public void TearDown()
     {
-        if (File.Exists($"{k_NewFileBaseName}{k_RemoteConfigFileExtension}"))
+        if (File.Exists(Path.Combine(UgsCliBuilder.RootDirectory, $"{k_NewFileBaseName}{k_RemoteConfigFileExtension}")))
         {
-            File.Delete($"{k_NewFileBaseName}{k_RemoteConfigFileExtension}");
+            File.Delete(Path.Combine(UgsCliBuilder.RootDirectory, $"{k_NewFileBaseName}{k_RemoteConfigFileExtension}"));
         }
 
-        if (File.Exists($"{k_NewFileBaseName}{k_CloudCodeFileExtension}"))
+        if (File.Exists(Path.Combine(UgsCliBuilder.RootDirectory, $"{k_NewFileBaseName}{k_CloudCodeFileExtension}")))
         {
-            File.Delete($"{k_NewFileBaseName}{k_CloudCodeFileExtension}");
+            File.Delete(Path.Combine(UgsCliBuilder.RootDirectory, $"{k_NewFileBaseName}{k_CloudCodeFileExtension}"));
         }
 
-        if (File.Exists($"{k_NewFileBaseName}{k_EconomyFileExtension}"))
+        if (File.Exists(Path.Combine(UgsCliBuilder.RootDirectory, $"{k_NewFileBaseName}{k_EconomyFileExtension}")))
         {
-            File.Delete($"{k_NewFileBaseName}{k_EconomyFileExtension}");
+            File.Delete(Path.Combine(UgsCliBuilder.RootDirectory, $"{k_NewFileBaseName}{k_EconomyFileExtension}"));
         }
     }
 
     [TestCase("remote-config", k_RemoteConfigFileExtension)]
-    [TestCase("cloud-code", k_CloudCodeFileExtension)]
-    public async Task NewFileCreatedWithNoErrorsAndCorrectOutput(string serviceAlias, string serviceExtension)
+    [TestCase("cloud-code scripts", k_CloudCodeFileExtension)]
+    public async Task NewFileCreatedWithNoErrorsAndCorrectOutput(string fullParentCommand, string serviceExtension)
     {
         var newFileOutPutString = $"[Information]: {Environment.NewLine}    Config file {k_NewFileBaseName}{serviceExtension} created successfully!{Environment.NewLine}";
 
         await new UgsCliTestCase()
-            .Command($"{serviceAlias} new-file")
-            .AssertStandardOutputContains(newFileOutPutString)
-            .AssertNoErrors()
+            .Command($"{fullParentCommand} new-file")
+            .AssertStandardErrorContains(newFileOutPutString)
             .ExecuteAsync();
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/PlayerTests/PlayerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/PlayerTests/PlayerTests.cs
index c1a90a5..cbd4753 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/PlayerTests/PlayerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/PlayerTests/PlayerTests.cs
@@ -5,6 +5,7 @@
 using NUnit.Framework;
 using Unity.Services.Cli.Common.Exceptions;
 using Unity.Services.Cli.Common.Networking;
+using Unity.Services.Cli.IntegrationTest.Common;
 using Unity.Services.Cli.MockServer;
 using Unity.Services.Gateway.PlayerAdminApiV3.Generated.Model;
 using Unity.Services.Cli.MockServer.Common;
@@ -38,7 +39,7 @@ public async Task CreatePlayer_Throws_NotAuthenticated()
         await new UgsCliTestCase()
             .Command("player create")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -50,7 +51,7 @@ public async Task CreatePlayer_Throws_NoProjectId()
         await GetLoggedInCli()
             .Command("player create")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -61,7 +62,6 @@ public async Task CreatePlayer_Succeeds()
 
         await GetLoggedInCli()
             .Command("player create")
-            .AssertNoErrors()
             .ExecuteAsync();
     }
 
@@ -73,7 +73,7 @@ public async Task DeletePlayer_Throws_NotAuthenticated()
         await new UgsCliTestCase()
             .Command($"player delete {PlayerApiMock.PlayerId}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -85,7 +85,7 @@ public async Task DeletePlayer_Throws_NoProjectId()
         await GetLoggedInCli()
             .Command($"player delete {PlayerApiMock.PlayerId}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -108,7 +108,6 @@ public async Task DeletePlayer_Succeeds()
 
         await GetLoggedInCli()
             .Command($"player delete {PlayerApiMock.PlayerId}")
-            .AssertNoErrors()
             .ExecuteAsync();
     }
 
@@ -120,7 +119,7 @@ public async Task DisablePlayer_Throws_NotAuthenticated()
         await new UgsCliTestCase()
             .Command($"player disable {PlayerApiMock.PlayerId}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -132,7 +131,7 @@ public async Task DisablePlayer_Throws_NoProjectId()
         await GetLoggedInCli()
             .Command($"player disable {PlayerApiMock.PlayerId}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -155,7 +154,6 @@ public async Task DisablePlayer_Succeeds()
 
         await GetLoggedInCli()
             .Command($"player disable {PlayerApiMock.PlayerId}")
-            .AssertNoErrors()
             .ExecuteAsync();
     }
 
@@ -167,7 +165,7 @@ public async Task EnablePlayer_Throws_NotAuthenticated()
         await new UgsCliTestCase()
             .Command($"player enable {PlayerApiMock.PlayerId}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -179,7 +177,7 @@ public async Task EnablePlayer_Throws_NoProjectId()
         await GetLoggedInCli()
             .Command($"player enable {PlayerApiMock.PlayerId}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -202,7 +200,6 @@ public async Task EnablePlayer_Succeeds()
 
         await GetLoggedInCli()
             .Command($"player disable {PlayerApiMock.PlayerId}")
-            .AssertNoErrors()
             .ExecuteAsync();
     }
 
@@ -214,7 +211,7 @@ public async Task GetPlayer_Throws_NotAuthenticated()
         await new UgsCliTestCase()
             .Command($"player get {PlayerApiMock.PlayerId}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -226,7 +223,7 @@ public async Task GetPlayer_Throws_NoProjectId()
         await GetLoggedInCli()
             .Command($"player get {PlayerApiMock.PlayerId}")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -258,16 +255,9 @@ public async Task GetPlayer_SucceedsReturnsJson()
     {
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
 
-        var logResult = new
-        {
-            Result = new PlayerAuthPlayerProjectResponse(),
-            Messages = Array.Empty<string>()
-        };
-
         await GetLoggedInCli()
             .Command($"player get {PlayerApiMock.PlayerId} -j")
-            .AssertNoErrors()
-            .AssertStandardOutputContains(JsonConvert.SerializeObject(logResult, Formatting.Indented))
+            .AssertStandardOutputContains(JsonConvert.SerializeObject(new PlayerAuthPlayerProjectResponse(), Formatting.Indented))
             .ExecuteAsync();
     }
 
@@ -279,7 +269,7 @@ public async Task ListPlayer_Throws_NotAuthenticated()
         await new UgsCliTestCase()
             .Command($"player list")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -291,7 +281,7 @@ public async Task ListPlayer_Throws_NoProjectId()
         await GetLoggedInCli()
             .Command($"player list")
             .AssertExitCode(ExitCode.HandledError)
-            .AssertStandardOutputContains(expectedMsg)
+            .AssertStandardErrorContains(expectedMsg)
             .ExecuteAsync();
     }
 
@@ -314,16 +304,9 @@ public async Task ListPlayer_SucceedsReturnsJson()
     {
         SetConfigValue("project-id", CommonKeys.ValidProjectId);
 
-        var logResult = new
-        {
-            Result = new PlayerListResponseResult(PlayerApiMock.GetPlayerListMock()),
-            Messages = Array.Empty<string>()
-        };
-
         await GetLoggedInCli()
             .Command($"player list -j")
-            .AssertNoErrors()
-            .AssertStandardOutputContains(JsonConvert.SerializeObject(logResult, Formatting.Indented))
+            .AssertStandardOutputContains(JsonConvert.SerializeObject(new PlayerListResponseResult(PlayerApiMock.GetPlayerListMock()), Formatting.Indented))
             .ExecuteAsync();
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Unity.Services.Cli.IntegrationTest.csproj b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Unity.Services.Cli.IntegrationTest.csproj
index bbad6f3..0f00004 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Unity.Services.Cli.IntegrationTest.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.IntegrationTest/Unity.Services.Cli.IntegrationTest.csproj
@@ -6,18 +6,18 @@
     <IsPackable>false</IsPackable>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <DefineConstants>TRACE;</DefineConstants>
+    <DefineConstants>TRACE;FEATURE_LEADERBOARDS_IMPORT_EXPORT</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
-    <DefineConstants>TRACE;</DefineConstants>
+    <DefineConstants>TRACE;FEATURE_LEADERBOARDS_IMPORT_EXPORT</DefineConstants>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
     <PackageReference Include="NUnit" Version="3.13.3" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.4.2" />
     <PackageReference Include="coverlet.collector" Version="3.2.0" />
-    <PackageReference Include="Unity.Services.Gateway.LeaderboardApiV1.Generated" Version="1.0.5-beta" />
-    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.1.0" />
+    <PackageReference Include="Unity.Services.Gateway.CloudCodeApiV1.Generated" Version="1.2.0" />
+    <PackageReference Include="Unity.Services.Gateway.LeaderboardApiV1.Generated" Version="1.0.7-beta" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Unity.Services.Cli.Common\Unity.Services.Cli.Common.csproj" />
@@ -25,5 +25,6 @@
     <ProjectReference Include="..\Unity.Services.Cli.Integration.MockServer\Unity.Services.Cli.Integration.MockServer.csproj" />
     <ProjectReference Include="..\Unity.Services.Cli.Player\Unity.Services.Cli.Player.csproj" />
     <ProjectReference Include="..\Unity.Services.Cli.RemoteConfig\Unity.Services.Cli.RemoteConfig.csproj" />
+    <ProjectReference Include="..\Unity.Services.Cli\Unity.Services.Cli.csproj" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/CreateLeaderboardHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/CreateLeaderboardHandlerTests.cs
index fa65d1e..1b498cf 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/CreateLeaderboardHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/CreateLeaderboardHandlerTests.cs
@@ -22,7 +22,7 @@ class CreateLeaderboardHandlerTests
     readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
     readonly Mock<ILeaderboardsService> m_MockLeaderboard = new();
     readonly Mock<ILogger> m_MockLogger = new();
-    private string leaderboardPath = null!;
+    string leaderboardPath = null!;
 
     [SetUp]
     public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/DeleteLeaderboardHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/DeleteLeaderboardHandlerTests.cs
index 9e30dab..3dd674c 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/DeleteLeaderboardHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/DeleteLeaderboardHandlerTests.cs
@@ -22,7 +22,7 @@ class DeleteLeaderboardHandlerTests
     readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
     readonly Mock<ILeaderboardsService> m_MockLeaderboard = new();
     readonly Mock<ILogger> m_MockLogger = new();
-    private const string leaderboardId = "lb1";
+    const string leaderboardId = "lb1";
 
     [SetUp]
     public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/ExportHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/ExportHandlerTests.cs
new file mode 100644
index 0000000..e5f650a
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/ExportHandlerTests.cs
@@ -0,0 +1,219 @@
+using System.IO.Abstractions;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Spectre.Console;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Leaderboards.Handlers.ImportExport;
+using Unity.Services.Cli.Leaderboards.Input;
+using Unity.Services.Cli.Leaderboards.Service;
+using Unity.Services.Cli.Leaderboards.UnitTest.Utils;
+using Unity.Services.Gateway.LeaderboardApiV1.Generated.Model;
+
+namespace Unity.Services.Cli.Leaderboards.UnitTest.Handlers;
+
+[TestFixture]
+class ExportHandlerTests
+{
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<ILeaderboardsService> m_MockLeaderboardsService = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IZipArchiver> m_MockArchiver = new();
+    readonly Mock<IFileSystem> m_FileSystemMock = new();
+    readonly Mock<ILoadingIndicator> m_MockLoadingIndicator = new();
+    readonly IEnumerable<UpdatedLeaderboardConfig> m_Configs = new List<UpdatedLeaderboardConfig>()
+    {
+        new ("id_1", "name_2")
+    };
+    LeaderboardExporter? m_LeaderboardExporter;
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_MockUnityEnvironment.Reset();
+        m_MockLeaderboardsService.Reset();
+        m_MockLogger.Reset();
+        m_FileSystemMock.Reset();
+        m_LeaderboardExporter = new(m_MockLeaderboardsService.Object,
+            m_MockArchiver.Object,
+            m_MockUnityEnvironment.Object,
+            m_FileSystemMock.Object,
+            m_MockLogger.Object);
+    }
+
+    [Test]
+    public async Task ExportAsync_CallsLoadingIndicator()
+    {
+        var exportInput = new ExportInput()
+        {
+            OutputDirectory = "mock_output_directory"
+        };
+
+        await ExportHandler.ExportAsync
+        (
+            null!,
+            exportInput,
+            m_MockLogger.Object,
+            m_LeaderboardExporter,
+            m_MockLoadingIndicator.Object,
+            CancellationToken.None
+        );
+
+        m_MockLoadingIndicator.Verify(li => li.StartLoadingAsync(ExportHandler.k_LoadingIndicatorMessage,
+            It.IsAny<Func<StatusContext?, Task>>()));
+    }
+
+    [Test]
+    public async Task ExportAsync_ExportsAndZips()
+    {
+        var exportInput = new ExportInput()
+        {
+            OutputDirectory = "mock_output_directory"
+        };
+        var input = new ListLeaderboardInput()
+        {
+            CloudProjectId = TestValues.ValidProjectId,
+            Cursor = TestValues.Cursor,
+            Limit = TestValues.Limit
+        };
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        m_MockLeaderboardsService.Setup(
+                ls => ls.GetLeaderboardsAsync(It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<int>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(m_Configs));
+
+        m_FileSystemMock.Setup(
+            e => e
+                .Directory
+                .CreateDirectory(It.IsAny<string>()));
+        m_FileSystemMock.Setup(
+                e => e
+                    .Path
+                    .Join(It.IsAny<string?>(), It.IsAny<string?>()))
+            .Returns(Path.Join(exportInput.OutputDirectory, LeaderboardConstants.ZipName));
+
+        m_FileSystemMock.Setup(
+                e => e
+                    .File
+                    .Exists(It.IsAny<string>()))
+            .Returns<string>((path) => false);
+
+        m_LeaderboardExporter!.ListLeaderboardInput = input;
+        await m_LeaderboardExporter.ExportAsync(exportInput, CancellationToken.None);
+
+        var archivePath = Path.Join(exportInput.OutputDirectory, LeaderboardConstants.ZipName);
+
+        m_MockLeaderboardsService.Verify(
+            ls => ls.GetLeaderboardsAsync(It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<int>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+        m_MockArchiver.Verify(za => za.ZipAsync(
+            archivePath,
+            LeaderboardConstants.EntryName,
+            m_Configs,
+            It.IsAny<CancellationToken>()));
+    }
+
+    [Test]
+    public async Task ExportAsync_ExportsAndZipsWithFileName()
+    {
+        var fileName = "other.lbzip";
+
+        var exportInput = new ExportInput()
+        {
+            OutputDirectory = "mock_output_directory",
+            FileName = fileName
+        };
+        var input = new ListLeaderboardInput()
+        {
+            CloudProjectId = TestValues.ValidProjectId,
+            Cursor = TestValues.Cursor,
+            Limit = TestValues.Limit
+        };
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        m_MockLeaderboardsService.Setup(
+                ls => ls.GetLeaderboardsAsync(It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<int>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(m_Configs));
+
+        var archivePath = Path.Join(exportInput.OutputDirectory, fileName);
+
+        m_FileSystemMock.Setup(
+            e => e
+                .Directory
+                .CreateDirectory(It.IsAny<string>()));
+        m_FileSystemMock.Setup(
+                e => e
+                    .Path
+                    .Join(It.IsAny<string?>(), It.IsAny<string?>()))
+            .Returns(archivePath);
+
+        m_FileSystemMock.Setup(
+                e => e
+                    .File
+                    .Exists(It.IsAny<string>()))
+            .Returns<string>((path) => false);
+
+        m_LeaderboardExporter!.ListLeaderboardInput = input;
+        await m_LeaderboardExporter.ExportAsync(exportInput, CancellationToken.None);
+
+        m_MockLeaderboardsService.Verify(
+            ls => ls.GetLeaderboardsAsync(It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<int>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+        m_MockArchiver.Verify(za => za.ZipAsync(
+            archivePath,
+            LeaderboardConstants.EntryName,
+            m_Configs,
+            It.IsAny<CancellationToken>()));
+    }
+
+    [Test]
+    public void ExportAsync_FailsWithInvalidExtension()
+    {
+        var fileName = "other.zip";
+
+        var exportInput = new ExportInput()
+        {
+            OutputDirectory = "mock_output_directory",
+            FileName = fileName
+        };
+
+        var input = new ListLeaderboardInput()
+        {
+            CloudProjectId = TestValues.ValidProjectId,
+            Cursor = TestValues.Cursor,
+            Limit = TestValues.Limit
+        };
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        m_LeaderboardExporter!.ListLeaderboardInput = input;
+        var exception = Assert.ThrowsAsync<CliException>(async () =>
+        {
+            await m_LeaderboardExporter.ExportAsync(exportInput, CancellationToken.None);
+        });
+
+        Assert.That(exception!.Message, Is.EqualTo("The file-name argument must have the extension '.lbzip'."));
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/GetLeaderboardHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/GetLeaderboardHandlerTests.cs
index 929506f..4224c8b 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/GetLeaderboardHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/GetLeaderboardHandlerTests.cs
@@ -43,7 +43,7 @@ public void SetUp()
                     updateType: UpdateType.Aggregate,
                     bucketSize: Decimal.One,
                     resetConfig: new ResetConfig(),
-                    tieringConfig: new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>()),
+                    tieringConfig: new TieringConfig(TieringConfig.StrategyEnum.Percent, new List<TieringConfigTiersInner>(){new TieringConfigTiersInner("tier1", 2)}),
                     updated: DateTime.Today,
                     created: DateTime.Now,
                     lastReset: DateTime.Today,
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/ImportHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/ImportHandlerTests.cs
new file mode 100644
index 0000000..3a5dc58
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/ImportHandlerTests.cs
@@ -0,0 +1,363 @@
+using System.Net;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Spectre.Console;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.Leaderboards.Handlers.ImportExport;
+using Unity.Services.Cli.Leaderboards.Service;
+using Unity.Services.Cli.Leaderboards.UnitTest.Utils;
+using Unity.Services.Gateway.LeaderboardApiV1.Generated.Client;
+using Unity.Services.Gateway.LeaderboardApiV1.Generated.Model;
+
+namespace Unity.Services.Cli.Leaderboards.UnitTest.Handlers;
+
+enum ApiCallType
+{
+    Create,
+    Update,
+    Delete,
+    Get,
+    List
+}
+
+[TestFixture]
+class ImportHandlerTests
+{
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<ILeaderboardsService> m_MockLeaderboardsService = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IZipArchiver> m_MockArchiver = new();
+    readonly Mock<ILoadingIndicator> m_MockLoadingIndicator = new();
+
+    readonly List<UpdatedLeaderboardConfig> m_MockConfigs = new List<UpdatedLeaderboardConfig>()
+    {
+        new("mock_id_1", "mock_name_1"),
+    };
+
+    LeaderboardImporter? m_LeaderboardImporter;
+
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_MockUnityEnvironment.Reset();
+        m_MockLeaderboardsService.Reset();
+        m_MockLogger.Reset();
+
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<UpdatedLeaderboardConfig>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult((IEnumerable<UpdatedLeaderboardConfig>)m_MockConfigs));
+
+        m_LeaderboardImporter = new LeaderboardImporter(
+            m_MockLeaderboardsService.Object,
+            m_MockArchiver.Object,
+            m_MockUnityEnvironment.Object,
+            m_MockLogger.Object);
+    }
+
+    [Test]
+    public async Task ImportAsync_CallsLoadingIndicator()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory"
+        };
+
+        await ImportHandler.ImportAsync(
+            importInput,
+            m_MockLogger.Object,
+            m_LeaderboardImporter,
+            m_MockLoadingIndicator.Object,
+            CancellationToken.None
+        );
+
+        m_MockLoadingIndicator.Verify(li => li.StartLoadingAsync(ImportHandler.k_LoadingIndicatorMessage,
+            It.IsAny<Func<StatusContext?, Task>>()));
+    }
+
+    [Test]
+    public async Task ImportAsync_Unzips()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            DryRun = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        await ImportInternalAsync(importInput);
+
+        var archivePath = Path.Join(importInput.InputDirectory, LeaderboardConstants.ZipName);
+
+        m_MockArchiver.Verify(za => za.UnzipAsync<UpdatedLeaderboardConfig>(
+            archivePath,
+            LeaderboardConstants.EntryName,
+            It.IsAny<CancellationToken>()));
+    }
+
+    [Test]
+    public async Task ImportAsync_UnzipsWithFileName()
+    {
+        var fileName = "other.lbzip";
+
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            FileName = fileName,
+            DryRun = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        await ImportInternalAsync(importInput);
+
+        var archivePath = Path.Join(importInput.InputDirectory, fileName);
+
+        m_MockArchiver.Verify(za => za.UnzipAsync<UpdatedLeaderboardConfig>(
+            archivePath,
+            LeaderboardConstants.EntryName,
+            It.IsAny<CancellationToken>()));
+    }
+
+    [Test]
+    public void ImportAsync_FailsWithInvalidExtension()
+    {
+        var fileName = "other.zip";
+
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            FileName = fileName,
+            DryRun = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        var exception = Assert.ThrowsAsync<CliException>(async () =>
+        {
+            await ImportInternalAsync(importInput);
+        });
+        Assert.That(exception!.Message, Is.EqualTo("The file-name argument must have the extension '.lbzip'."));
+    }
+
+    [Test]
+    public async Task ImportAsync_DryRunDoesNotImport()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            DryRun = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ApiCallType>
+        {
+            ApiCallType.List
+        });
+    }
+
+    [Test]
+    public async Task ConfigExists_Updates()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        SetupList(m_MockConfigs);
+        SetupUpdate();
+
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ApiCallType>()
+        {
+            ApiCallType.List,
+            ApiCallType.Update
+        });
+    }
+
+    [Test]
+    public async Task ConfigDoesNotExist_Creates()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        SetupGet(null!, true);
+        SetupCreate();
+
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ApiCallType>()
+        {
+            ApiCallType.Create,
+            ApiCallType.List
+        });
+    }
+
+    [Test]
+    public async Task Reconcile_Deletes()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            Reconcile = true
+        };
+
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestValues.ValidEnvironmentId);
+        SetupList(new List<UpdatedLeaderboardConfig>()
+        {
+            new("remote_id",
+                "remote_name")
+        });
+        SetupDelete();
+        SetupList(new List<UpdatedLeaderboardConfig>() {new ("to_delete", "to_delete")});
+        SetupCreate();
+
+        await ImportInternalAsync(importInput);
+
+        VerifyApiCalls(new List<ApiCallType>()
+        {
+            ApiCallType.List,
+            ApiCallType.Delete,
+            ApiCallType.Create
+        });
+    }
+
+    async Task ImportInternalAsync(ImportInput importInput)
+    {
+        await m_LeaderboardImporter!.ImportAsync(importInput, CancellationToken.None);
+    }
+
+    void SetupCreate()
+    {
+        m_MockLeaderboardsService.Setup(
+                ls => ls.CreateLeaderboardAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(new ApiResponse<object>(HttpStatusCode.Created, new object())));
+    }
+
+    void SetupUpdate()
+    {
+        m_MockLeaderboardsService.Setup(
+                ls => ls.UpdateLeaderboardAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(new ApiResponse<object>(HttpStatusCode.NoContent, new object())));
+    }
+
+    void SetupGet(UpdatedLeaderboardConfig result, bool throws = false)
+    {
+        var setup = m_MockLeaderboardsService.Setup(lb => lb.GetLeaderboardAsync(
+            It.IsAny<string>(),
+            It.IsAny<string>(),
+            It.IsAny<string>(),
+            It.IsAny<CancellationToken>()));
+
+        if (throws)
+        {
+            setup.Throws(new Exception("mock exception"));
+        }
+    }
+
+    void SetupList(IEnumerable<UpdatedLeaderboardConfig> result)
+    {
+        m_MockLeaderboardsService.Setup(
+                ls => ls.GetLeaderboardsAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string?>(),
+                    It.IsAny<int?>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(result));
+    }
+
+    void SetupDelete()
+    {
+        m_MockLeaderboardsService.Setup(
+                ls => ls.DeleteLeaderboardAsync(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(new ApiResponse<object>(HttpStatusCode.NoContent, new object())));
+    }
+
+    void VerifyApiCalls(List<ApiCallType> apiCallTypes)
+    {
+        var getTimes = apiCallTypes.Contains(ApiCallType.Get) ? Times.Once() : Times.Never();
+        m_MockLeaderboardsService.Verify(
+            ls => ls.GetLeaderboardAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            getTimes);
+
+        var listTimes = apiCallTypes.Contains(ApiCallType.List) ? Times.Once() : Times.Never();
+        m_MockLeaderboardsService.Verify(
+            ls => ls.GetLeaderboardsAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string?>(),
+                It.IsAny<int?>(),
+                It.IsAny<CancellationToken>()),
+            listTimes);
+
+        var createTimes = apiCallTypes.Contains(ApiCallType.Create) ? Times.Once() : Times.Never();
+        m_MockLeaderboardsService.Verify(
+            ls => ls.CreateLeaderboardAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            createTimes);
+
+        var updateTimes = apiCallTypes.Contains(ApiCallType.Update) ? Times.Once() : Times.Never();
+        m_MockLeaderboardsService.Verify(
+            ls => ls.UpdateLeaderboardAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            updateTimes);
+
+        var deleteTimes = apiCallTypes.Contains(ApiCallType.Delete) ? Times.Once() : Times.Never();
+        m_MockLeaderboardsService.Verify(
+            ls => ls.DeleteLeaderboardAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            deleteTimes);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/ResetLeaderboardHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/ResetLeaderboardHandlerTests.cs
index 7282930..a4bf983 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/ResetLeaderboardHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/ResetLeaderboardHandlerTests.cs
@@ -23,7 +23,7 @@ class ResetLeaderboardHandlerTests
     readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
     readonly Mock<ILeaderboardsService> m_MockLeaderboard = new();
     readonly Mock<ILogger> m_MockLogger = new();
-    private const string leaderboardId = "lb1";
+    const string leaderboardId = "lb1";
 
     [SetUp]
     public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/UpdateLeaderboardHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/UpdateLeaderboardHandlerTests.cs
index 3a43758..23faedf 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/UpdateLeaderboardHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Handlers/UpdateLeaderboardHandlerTests.cs
@@ -22,8 +22,8 @@ class UpdateLeaderboardHandlerTests
     readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
     readonly Mock<ILeaderboardsService> m_MockLeaderboard = new();
     readonly Mock<ILogger> m_MockLogger = new();
-    private const string leaderboardId = "lb1";
-    private string leaderboardPath = null!;
+    const string leaderboardId = "lb1";
+    string leaderboardPath = null!;
 
     [SetUp]
     public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/LeaderboardsModuleTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/LeaderboardsModuleTests.cs
index 473a37e..9930e34 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/LeaderboardsModuleTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/LeaderboardsModuleTests.cs
@@ -13,7 +13,7 @@
 namespace Unity.Services.Cli.Leaderboards.UnitTest;
 
 [TestFixture]
-internal class LeaderboardModuleTests
+class LeaderboardModuleTests
 {
     [Test]
     public void ListCommandWithInput()
@@ -40,4 +40,17 @@ public void ConfigureLeaderboardRegistersExpectedServices(Type serviceType)
         LeaderboardsModule.RegisterServices(new HostBuilderContext(new Dictionary<object, object>()), collection);
         Assert.That(collection.FirstOrDefault(c => c.ServiceType == serviceType), Is.Not.Null);
     }
+
+    [Test]
+
+    public void RetryAfterSleepDuration()
+    {
+        var response = new RestSharp.RestResponse();
+        response.Headers = new List<RestSharp.HeaderParameter>()
+        {
+            new ("Retry-After", "1")
+        };
+        Polly.DelegateResult<RestSharp.RestResponse> res = new Polly.DelegateResult<RestSharp.RestResponse>(response);
+        Assert.AreEqual(TimeSpan.FromSeconds(2), LeaderboardsModule.RetryAfterSleepDuration(2, res, new Polly.Context()));
+    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Mock/LeaderboardApiV1AsyncMock.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Mock/LeaderboardApiV1AsyncMock.cs
index 24a48ca..ee5c888 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Mock/LeaderboardApiV1AsyncMock.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Mock/LeaderboardApiV1AsyncMock.cs
@@ -46,7 +46,7 @@ public void SetUp()
                     It.IsAny<Guid>(),
                     It.IsAny<Guid>(),
                     It.IsAny<string>(),
-                    It.IsAny<LeaderboardConfig>(),
+                    It.IsAny<LeaderboardPatchConfig>(),
                     It.IsAny<int>(),
                     CancellationToken.None))
             .ReturnsAsync(new ApiResponse<object>(statusCode: HttpStatusCode.NoContent, data: null!));
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Results/DryRunResultTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Results/DryRunResultTests.cs
deleted file mode 100644
index 50c7909..0000000
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Results/DryRunResultTests.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-using NUnit.Framework;
-using Unity.Services.Cli.Authoring.Model;
-
-namespace Unity.Services.Cli.Leaderboards.UnitTest.Results;
-
-[TestFixture]
-class DryRunResultTests
-{
-    [Test]
-    public void DryRunResult_ToStringMatches()
-    {
-        var expectedResult = $"Legend:{System.Environment.NewLine}[name_1 : id_1]{System.Environment.NewLine}[name_2 : id_2]{System.Environment.NewLine}";
-        var testObjects = new List<TestObject>()
-        {
-            new() { Name = "name_1", Id = "id_1", IrrelevantProperty = 1 },
-            new () { Name = "name_2", Id = "id_2", IrrelevantProperty = 1 }
-        };
-        var dryRunResult = new DryRunResult<TestObject>("Legend:", testObjects,
-            testObject => $"[{testObject.Name} : {testObject.Id}]");
-
-        Assert.AreEqual(dryRunResult.ToString(), expectedResult);
-    }
-}
-
-class TestObject
-{
-    public string? Name { get; set; }
-    public string? Id { get; set; }
-    public int IrrelevantProperty { get; set; }
-}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Service/LeaderboardsServiceTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Service/LeaderboardsServiceTests.cs
index 1e46942..3841965 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Service/LeaderboardsServiceTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards.UnitTest/Service/LeaderboardsServiceTests.cs
@@ -180,8 +180,8 @@ public void UpdateAsync_Succeeded()
                     "{\"id\": \"lb1\", \"name\": \"lb_name_1\", \"sortOrder\": \"asc\", \"updateType\": \"aggregate\", \"bucketSize\": 10}",
                     CancellationToken.None));
 
-        var config = new LeaderboardConfig(name: "lb_name_1", sortOrder: SortOrder.Asc,
-            updateType: UpdateType.Aggregate, bucketSize: 10);
+        var config = new LeaderboardPatchConfig(name: "lb_name_1", sortOrder: SortOrder.Asc,
+            updateType: UpdateType.Aggregate);
 
         m_LeaderboardApiV1AsyncMock.DefaultApiAsyncObject.Verify(
             ex => ex.UpdateLeaderboardConfigWithHttpInfoAsync(
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/ExportHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/ExportHandler.cs
new file mode 100644
index 0000000..d37a97c
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/ExportHandler.cs
@@ -0,0 +1,31 @@
+using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Leaderboards.Input;
+
+namespace Unity.Services.Cli.Leaderboards.Handlers.ImportExport;
+
+static class ExportHandler
+{
+    internal const string k_LoadingIndicatorMessage = "Exporting your environment...";
+    internal const string k_CompleteIndicatorMessage = "Export complete.";
+
+    public static async Task ExportAsync(
+        ListLeaderboardInput listLeaderboardInput,
+        ExportInput exportInput,
+        ILogger logger,
+        LeaderboardExporter? leaderboardExporter,
+        ILoadingIndicator loadingIndicator,
+        CancellationToken cancellationToken)
+    {
+        await loadingIndicator.StartLoadingAsync(
+            k_LoadingIndicatorMessage,
+            _ =>
+            {
+                leaderboardExporter!.ListLeaderboardInput = listLeaderboardInput;
+                return leaderboardExporter.ExportAsync(exportInput, cancellationToken);
+            }
+        );
+        logger.LogInformation(k_CompleteIndicatorMessage);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/ImportExportUtils.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/ImportExportUtils.cs
new file mode 100644
index 0000000..d2abcf3
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/ImportExportUtils.cs
@@ -0,0 +1,14 @@
+using System.Text.Json;
+using Unity.Services.Cli.Common.Input;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Gateway.LeaderboardApiV1.Generated.Model;
+
+namespace Unity.Services.Cli.Leaderboards.Handlers.ImportExport;
+
+static class ImportExportUtils
+{
+    public static string ToRequestBody(this UpdatedLeaderboardConfig config)
+    {
+        return JsonSerializer.Serialize(config);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/ImportHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/ImportHandler.cs
new file mode 100644
index 0000000..e38e384
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/ImportHandler.cs
@@ -0,0 +1,25 @@
+using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Authoring.Import.Input;
+
+namespace Unity.Services.Cli.Leaderboards.Handlers.ImportExport;
+
+static class ImportHandler
+{
+    internal const string k_LoadingIndicatorMessage = "Importing configs...";
+    internal const string k_CompleteIndicatorMessage = "Import complete.";
+
+    public static async Task ImportAsync(
+        ImportInput importInput,
+        ILogger logger,
+        LeaderboardImporter? leaderboardImporter,
+        ILoadingIndicator loadingIndicator,
+        CancellationToken cancellationToken
+    )
+    {
+        await loadingIndicator.StartLoadingAsync(
+            k_LoadingIndicatorMessage,
+            _ => leaderboardImporter!.ImportAsync(importInput, cancellationToken));
+        logger.LogInformation(k_CompleteIndicatorMessage);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/LeaderboardsConstants.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/LeaderboardsConstants.cs
new file mode 100644
index 0000000..e2d127d
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/LeaderboardsConstants.cs
@@ -0,0 +1,9 @@
+using Unity.Services.Cli.Common.Telemetry;
+
+namespace Unity.Services.Cli.Leaderboards.Handlers.ImportExport;
+
+static class LeaderboardConstants
+{
+    internal const string ZipName = "ugs.lbzip";
+    internal const string EntryName = "leaderboards";
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/LeaderboardsExporter.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/LeaderboardsExporter.cs
new file mode 100644
index 0000000..3f9f7ec
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/LeaderboardsExporter.cs
@@ -0,0 +1,51 @@
+using System.IO.Abstractions;
+using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.Leaderboards.Input;
+using Unity.Services.Cli.Leaderboards.Service;
+using Unity.Services.Gateway.LeaderboardApiV1.Generated.Model;
+
+namespace Unity.Services.Cli.Leaderboards.Handlers.ImportExport;
+
+class LeaderboardExporter : BaseExporter<UpdatedLeaderboardConfig>
+{
+    readonly ILeaderboardsService m_LeaderboardsService;
+
+    public LeaderboardExporter(
+        ILeaderboardsService leaderboardsService,
+        IZipArchiver zipArchiver,
+        IUnityEnvironment unityEnvironment,
+        IFileSystem fileSystem,
+        ILogger logger)
+        : base(
+        zipArchiver,
+        unityEnvironment,
+        fileSystem,
+        logger)
+    {
+        m_LeaderboardsService = leaderboardsService;
+    }
+
+    protected override string FileName => LeaderboardConstants.ZipName;
+    protected override string EntryName => LeaderboardConstants.EntryName;
+
+    public ListLeaderboardInput ListLeaderboardInput { get; set; } = null!;
+
+    protected override async Task<IEnumerable<UpdatedLeaderboardConfig>> ListConfigsAsync(string projectId, string environmentId, CancellationToken cancellationToken)
+    {
+        return await m_LeaderboardsService.GetLeaderboardsAsync(
+            projectId,
+            environmentId,
+            ListLeaderboardInput.Cursor,
+            ListLeaderboardInput.Limit,
+            cancellationToken);
+    }
+
+    protected override ImportExportEntry<UpdatedLeaderboardConfig> ToImportExportEntry(UpdatedLeaderboardConfig value)
+    {
+        return new ImportExportEntry<UpdatedLeaderboardConfig>(value.Id.GetHashCode(), $"[{value.Name} : {value.Id}]", value);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/LeaderboardsImporter.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/LeaderboardsImporter.cs
new file mode 100644
index 0000000..e170582
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/ImportExport/LeaderboardsImporter.cs
@@ -0,0 +1,119 @@
+using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Import;
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.Leaderboards.Service;
+using Unity.Services.Gateway.LeaderboardApiV1.Generated.Client;
+using Unity.Services.Gateway.LeaderboardApiV1.Generated.Model;
+
+namespace Unity.Services.Cli.Leaderboards.Handlers.ImportExport;
+
+class LeaderboardImporter : BaseImporter<UpdatedLeaderboardConfig>
+{
+    readonly ILeaderboardsService m_LeaderboardsService;
+
+    public LeaderboardImporter(
+        ILeaderboardsService leaderboardsService,
+        IZipArchiver zipArchiver,
+        IUnityEnvironment unityEnvironment,
+        ILogger logger)
+        : base(
+        zipArchiver,
+        unityEnvironment,
+        logger)
+    {
+        m_LeaderboardsService = leaderboardsService;
+    }
+
+    protected override string FileName => LeaderboardConstants.ZipName;
+
+    protected override string EntryName => LeaderboardConstants.EntryName;
+
+    protected override async Task DeleteConfigAsync(
+        string projectId,
+        string environmentId,
+        UpdatedLeaderboardConfig configToDelete,
+        CancellationToken cancellationToken)
+    {
+        ValidateResponse(
+            await m_LeaderboardsService.DeleteLeaderboardAsync(
+                projectId,
+                environmentId,
+                configToDelete.Id,
+                cancellationToken
+            ),
+            () => m_Logger.LogInformation("[{Name} : {Id}] successfully deleted", configToDelete.Name, configToDelete.Id),
+            errorMsg => m_Logger.LogError("Failed to delete [{Name} : {Id}]. Error: {ErrorMsg}", configToDelete.Name, configToDelete.Id, errorMsg));
+    }
+
+    protected override async Task<IEnumerable<UpdatedLeaderboardConfig>> ListConfigsAsync(
+        string cloudProjectId,
+        string environmentId,
+        CancellationToken cancellationToken)
+    {
+        var configsOnRemote = await m_LeaderboardsService.GetLeaderboardsAsync(
+            cloudProjectId,
+            environmentId,
+            null,
+            int.MaxValue,
+            cancellationToken
+        );
+
+        return configsOnRemote;
+    }
+
+    protected override async Task CreateConfigAsync(
+        string projectId,
+        string environmentId,
+        UpdatedLeaderboardConfig config,
+        CancellationToken cancellationToken)
+    {
+        ValidateResponse(await m_LeaderboardsService.CreateLeaderboardAsync(
+                projectId,
+                environmentId,
+                config.ToRequestBody(),
+                cancellationToken
+            ),
+            () => m_Logger.LogInformation("Leaderboard [{ConfigName} : {ConfigId}] successfully created", config.Name, config.Id),
+            (errorMsg) => m_Logger.LogError("Failed to create [{ConfigName} : {ConfigId}]. Error: {ErrorMsg}", config.Name, config.Id, errorMsg));
+    }
+
+    protected override async Task UpdateConfigAsync(
+        string projectId,
+        string environmentId,
+        UpdatedLeaderboardConfig config,
+        CancellationToken cancellationToken)
+    {
+        ValidateResponse(await m_LeaderboardsService.UpdateLeaderboardAsync(
+                projectId,
+                environmentId,
+                config.Id,
+                config.ToRequestBody(),
+                cancellationToken),
+            () => m_Logger.LogInformation("Leaderboard [{ConfigName} : {ConfigId}] successfully updated", config.Name, config.Id),
+            (errorMsg) => m_Logger.LogError("Failed to update [{ConfigName} : {ConfigId}]. Error: {ErrorMsg}", config.Name, config.Id, errorMsg));
+    }
+
+    protected override ImportExportEntry<UpdatedLeaderboardConfig> ToImportExportEntry(UpdatedLeaderboardConfig value)
+    {
+        return new ImportExportEntry<UpdatedLeaderboardConfig>(value.Id.GetHashCode(), $"[{value.Name} : {value.Id}]", value);
+    }
+
+    static void ValidateResponse<T>(
+        ApiResponse<T> response,
+        Action onSuccess,
+        Action<string> onError)
+    {
+        var intStatusCode = (int)response.StatusCode;
+        if (intStatusCode is >= 200 and < 300)
+        {
+            onSuccess();
+            return;
+        }
+
+        onError(response.ErrorText);
+        throw new HttpRequestException(response.ErrorText, null, response.StatusCode);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/RequestBodyHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/RequestBodyHandler.cs
index 96317ed..efc369c 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/RequestBodyHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Handlers/RequestBodyHandler.cs
@@ -2,7 +2,7 @@
 
 namespace Unity.Services.Cli.Leaderboards.Handlers;
 
-internal class RequestBodyHandler
+class RequestBodyHandler
 {
     public static async Task<string> GetRequestBodyAsync(string? input)
     {
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/CreateInput.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/CreateInput.cs
index 7190c7b..62e9565 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/CreateInput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/CreateInput.cs
@@ -3,9 +3,9 @@
 
 namespace Unity.Services.Cli.Leaderboards.Input;
 
-internal class CreateInput : LeaderboardIdInput
+class CreateInput : LeaderboardIdInput
 {
-    private const string k_JsonBodyDescription =
+    const string k_JsonBodyDescription =
         "Json file path of the leadeboard config, \n" +
         "Payload example: https://services.docs.unity.com/leaderboards-admin/v1/#tag/Leaderboards/operation/createLeaderboard";
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/LeaderboardIdInput.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/LeaderboardIdInput.cs
index bb742f6..e383076 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/LeaderboardIdInput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/LeaderboardIdInput.cs
@@ -3,9 +3,9 @@
 
 namespace Unity.Services.Cli.Leaderboards.Input;
 
-internal class LeaderboardIdInput : CommonInput
+class LeaderboardIdInput : CommonInput
 {
-    private const string k_JsonLeaderboardIdDescription = "leaderboard id to update";
+    const string k_JsonLeaderboardIdDescription = "leaderboard id to fetch or update";
 
     public static readonly Argument<string> RequestLeaderboardIdArgument = new("leaderboard-id", k_JsonLeaderboardIdDescription);
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/ListLeaderboardInput.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/ListLeaderboardInput.cs
index e714c06..1f746f0 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/ListLeaderboardInput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/ListLeaderboardInput.cs
@@ -3,7 +3,7 @@
 
 namespace Unity.Services.Cli.Leaderboards.Input;
 
-internal class ListLeaderboardInput : CommonInput
+class ListLeaderboardInput : CommonInput
 {
     public static readonly Option<string?> CursorOption = new Option<string?>("--cursor", "The ID of the leaderboard that listing should start after, i.e. the last leaderboard returned from the previous page when paging");
     [InputBinding(nameof(CursorOption))]
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/ResetInput.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/ResetInput.cs
index 2237a7c..0c62774 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/ResetInput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/ResetInput.cs
@@ -3,9 +3,9 @@
 
 namespace Unity.Services.Cli.Leaderboards.Input;
 
-internal class ResetInput : LeaderboardIdInput
+class ResetInput : LeaderboardIdInput
 {
-    private const string k_ArchiveDescription =
+    const string k_ArchiveDescription =
         "Whether or not to archive the current set of scores before resetting the leaderboard. ";
     public static readonly Option<bool> ResetArchiveArgument = new(new[]
     {
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/UpdateInput.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/UpdateInput.cs
index 4b367e4..26ed462 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/UpdateInput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Input/UpdateInput.cs
@@ -3,9 +3,9 @@
 
 namespace Unity.Services.Cli.Leaderboards.Input;
 
-internal class UpdateInput : LeaderboardIdInput
+class UpdateInput : LeaderboardIdInput
 {
-    private const string k_JsonBodyDescription =
+    const string k_JsonBodyDescription =
         "Json file path of the leadeboard config \n" +
         "Payload example: https://services.docs.unity.com/leaderboards-admin/v1/#tag/Leaderboards/operation/updateLeaderboardConfig";
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/LeaderboardsModule.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/LeaderboardsModule.cs
index 29d4f27..3a5c8b5 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/LeaderboardsModule.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/LeaderboardsModule.cs
@@ -1,7 +1,10 @@
 using System.CommandLine;
+using System.Net;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
+using Polly;
+using RestSharp;
 using Unity.Services.Cli.Common;
 using Unity.Services.Cli.Common.Console;
 using Unity.Services.Cli.Common.Input;
@@ -12,6 +15,8 @@
 using Unity.Services.Cli.Authoring.Export.Input;
 using Unity.Services.Cli.Authoring.Import.Input;
 using Unity.Services.Cli.Authoring.Service;
+using System.IO.Abstractions;
+using Unity.Services.Cli.Leaderboards.Handlers.ImportExport;
 using Unity.Services.Cli.Leaderboards.Handlers;
 using Unity.Services.Cli.Leaderboards.Input;
 using Unity.Services.Cli.Leaderboards.Service;
@@ -23,6 +28,8 @@ namespace Unity.Services.Cli.Leaderboards;
 
 public class LeaderboardsModule : ICommandModule
 {
+    internal Command ExportCommand { get; }
+    internal Command ImportCommand { get; }
     internal Command ListLeaderboardsCommand { get; }
     internal Command GetLeaderboardCommand { get; }
     internal Command CreateLeaderboardCommand { get; }
@@ -50,6 +57,40 @@ public LeaderboardsModule()
             CancellationToken>(
             GetLeaderboardConfigsHandler.GetLeaderboardConfigsAsync);
 
+        ExportCommand = new Command("export", "Export leaderboard configs.")
+        {
+            CommonInput.CloudProjectIdOption,
+            CommonInput.EnvironmentNameOption,
+            ListLeaderboardInput.CursorOption,
+            ListLeaderboardInput.LimitOption,
+            ExportInput.OutputDirectoryArgument,
+            ExportInput.DryRunOption,
+            ExportInput.FileNameArgument
+        };
+        ExportCommand.SetHandler<
+            ListLeaderboardInput,
+            ExportInput,
+            ILogger,
+            LeaderboardExporter,
+            ILoadingIndicator,
+            CancellationToken>(ExportHandler.ExportAsync);
+
+        ImportCommand = new Command("import", "Import leaderboard configs.")
+        {
+            CommonInput.CloudProjectIdOption,
+            CommonInput.EnvironmentNameOption,
+            ImportInput.InputDirectoryArgument,
+            ImportInput.DryRunOption,
+            ImportInput.ReconcileOption,
+            ImportInput.FileNameArgument
+        };
+        ImportCommand.SetHandler<
+            ImportInput,
+            ILogger,
+            LeaderboardImporter,
+            ILoadingIndicator,
+            CancellationToken>(
+            ImportHandler.ImportAsync);
 
         GetLeaderboardCommand = new Command("get", "Get detailed leaderboard info.")
         {
@@ -130,10 +171,22 @@ public LeaderboardsModule()
             UpdateLeaderboardCommand,
             ListLeaderboardsCommand,
             ResetLeaderboardCommand,
+            ExportCommand,
+            ImportCommand
         };
         ModuleRootCommand.AddAlias("lb");
     }
 
+    public static TimeSpan RetryAfterSleepDuration(int retryCount, DelegateResult<RestResponse> result, Context ctx)
+    {
+        const string retryAfter = "Retry-After";
+        var header = result.Result.Headers!.First(x => x.Name!.Equals(retryAfter));
+        var retryValue = header.Value?.ToString();
+        var retryValueInt = int.Parse(retryValue!);
+        var time = 2 * retryValueInt;
+        return TimeSpan.FromSeconds(time);
+    }
+
     public static void RegisterServices(HostBuilderContext hostBuilderContext, IServiceCollection serviceCollection)
     {
         var config = new Gateway.LeaderboardApiV1.Generated.Client.Configuration
@@ -141,11 +194,22 @@ public static void RegisterServices(HostBuilderContext hostBuilderContext, IServ
             BasePath = EndpointHelper.GetCurrentEndpointFor<LeaderboardEndpoints>()
         };
         config.DefaultHeaders.SetXClientIdHeader();
-
+        AsyncPolicy<RestResponse> retryAfterPolicy = Policy
+            .HandleResult<RestResponse>(r => r.StatusCode == HttpStatusCode.TooManyRequests && r.Headers != null)
+            .WaitAndRetryAsync(
+                retryCount: 3,
+                sleepDurationProvider: RetryAfterSleepDuration,
+                onRetryAsync: (_, _, _, _) => Task.CompletedTask);
+        Gateway.LeaderboardApiV1.Generated.Client.RetryConfiguration.AsyncRetryPolicy = retryAfterPolicy;
         serviceCollection.AddTransient<ILeaderboardsApiAsync>(_ => new LeaderboardsApi(config));
         serviceCollection.AddTransient<IConfigurationValidator, ConfigurationValidator>();
-        serviceCollection.AddTransient<IZipArchiver<UpdatedLeaderboardConfig>, ZipArchiver<UpdatedLeaderboardConfig>>();
+        // TODO: Move this service registration into the common ImportExportModule in the
+        // authoring project once it exists.
+        serviceCollection.AddTransient<IZipArchiver, ZipArchiver>();
         serviceCollection.AddSingleton<ILeaderboardsService, LeaderboardsService>();
+        serviceCollection.AddTransient<LeaderboardImporter, LeaderboardImporter>();
+        serviceCollection.AddTransient<LeaderboardExporter, LeaderboardExporter>();
+        serviceCollection.AddTransient<IFileSystem, FileSystem>();
 
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Model/GetLeaderboardConfigsResponseOutput.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Model/GetLeaderboardConfigsResponseOutput.cs
index c0d9dad..225a176 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Model/GetLeaderboardConfigsResponseOutput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Model/GetLeaderboardConfigsResponseOutput.cs
@@ -6,7 +6,7 @@
 
 namespace Unity.Services.Cli.Leaderboards.Model;
 
-internal class GetLeaderboardConfigsResponseOutput
+class GetLeaderboardConfigsResponseOutput
 {
     public List<LeaderboardConfigInner> Leaderboards;
     public GetLeaderboardConfigsResponseOutput(IEnumerable<UpdatedLeaderboardConfig> leaderboards)
@@ -22,7 +22,7 @@ public override string ToString()
 
 }
 
-internal class LeaderboardConfigInner
+class LeaderboardConfigInner
 {
     public string Id { get; set; }
     public string Name { get; set; }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Model/GetLeaderboardResponseOutput.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Model/GetLeaderboardResponseOutput.cs
index 0d9a038..91760d9 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Model/GetLeaderboardResponseOutput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Model/GetLeaderboardResponseOutput.cs
@@ -4,7 +4,7 @@
 
 namespace Unity.Services.Cli.Leaderboards.Model;
 
-internal class GetLeaderboardResponseOutput
+class GetLeaderboardResponseOutput
 {
     public SortOrder SortOrder { get; set; }
     public UpdateType UpdateType { get; set; }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Service/LeaderboardsService.cs b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Service/LeaderboardsService.cs
index 284c26b..f6fbf6d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Service/LeaderboardsService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Service/LeaderboardsService.cs
@@ -73,7 +73,7 @@ public async Task<ApiResponse<object>> UpdateLeaderboardAsync(string projectId,
         await AuthorizeServiceAsync(cancellationToken);
         ValidateProjectIdAndEnvironmentId(projectId, environmentId);
 
-        var updateRequest = DeserializeBody<LeaderboardConfig>(body);
+        var updateRequest = DeserializeBody<LeaderboardPatchConfig>(body);
         var response = await m_LeaderboardsApiAsync.UpdateLeaderboardConfigWithHttpInfoAsync(
             Guid.Parse(projectId),
             Guid.Parse(environmentId),
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Unity.Services.Cli.Leaderboards.csproj b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Unity.Services.Cli.Leaderboards.csproj
index 922cb06..810a254 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Unity.Services.Cli.Leaderboards.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.Leaderboards/Unity.Services.Cli.Leaderboards.csproj
@@ -7,10 +7,10 @@
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <DefineConstants>TRACE;</DefineConstants>
+    <DefineConstants>TRACE;FEATURE_LEADERBOARDS_IMPORT_EXPORT</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
-    <DefineConstants>TRACE;</DefineConstants>
+    <DefineConstants>TRACE;FEATURE_LEADERBOARDS_IMPORT_EXPORT</DefineConstants>
   </PropertyGroup>
   <ItemGroup>
     <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
@@ -26,7 +26,7 @@
     <ProjectReference Include="..\Unity.Services.Cli.ServiceAccountAuthentication\Unity.Services.Cli.ServiceAccountAuthentication.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Unity.Services.Gateway.LeaderboardApiV1.Generated" Version="1.0.5-beta" />
-    <PackageReference Include="YamlDotNet" Version="13.0.2" />
+    <PackageReference Include="Unity.Services.Gateway.LeaderboardApiV1.Generated" Version="1.0.7-beta" />
+    <PackageReference Include="YamlDotNet" Version="13.1.0" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/BulkUpdateLobbyHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/BulkUpdateLobbyHandlerTests.cs
index 64bc692..dacf2e1 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/BulkUpdateLobbyHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/BulkUpdateLobbyHandlerTests.cs
@@ -18,7 +18,7 @@ class BulkUpdateLobbyHandlerTests
 {
     Mock<ILogger> m_MockLogger = new();
     Mock<ILobbyService> m_MockLobby = new();
-    private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
     [SetUp]
     public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ConfigGetHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ConfigGetHandlerTests.cs
index 5f702b1..cb5c73b 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ConfigGetHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ConfigGetHandlerTests.cs
@@ -11,11 +11,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class ConfigGetHandlerTests
+    class ConfigGetHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<IRemoteConfigService> m_MockRemoteConfig = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ConfigUpdateHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ConfigUpdateHandlerTests.cs
index 15fc29f..dfb93d5 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ConfigUpdateHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ConfigUpdateHandlerTests.cs
@@ -9,7 +9,7 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class ConfigUpdateHandlerTests
+    class ConfigUpdateHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<IRemoteConfigService> m_MockRemoteConfig = new();
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/CreateLobbyHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/CreateLobbyHandlerTests.cs
index 8d00040..266f8a4 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/CreateLobbyHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/CreateLobbyHandlerTests.cs
@@ -13,11 +13,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class CreateLobbyHandlerTests
+    class CreateLobbyHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/DeleteLobbyHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/DeleteLobbyHandlerTests.cs
index 765f8d9..acf1b6d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/DeleteLobbyHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/DeleteLobbyHandlerTests.cs
@@ -9,11 +9,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class DeleteLobbyHandlerTests
+    class DeleteLobbyHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ExportHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ExportHandlerTests.cs
new file mode 100644
index 0000000..ae81ea5
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ExportHandlerTests.cs
@@ -0,0 +1,183 @@
+using System.IO.Abstractions;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Spectre.Console;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Lobby.Handlers.ImportExport;
+using Unity.Services.Cli.RemoteConfig.Service;
+using Unity.Services.Cli.Lobby.Handlers;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Unity.Services.Cli.Lobby.UnitTest.Handlers;
+
+[TestFixture]
+class ExportHandlerTests
+{
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<IRemoteConfigService> m_MockRemoteConfigService = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IZipArchiver> m_MockArchiver = new();
+    readonly Mock<IFileSystem> m_MockFileSystem = new();
+    readonly Mock<ILoadingIndicator> m_MockLoadingIndicator = new();
+
+    LobbyConfig m_Config = new()
+    {
+        Id = "mock_id",
+        Config = JsonConvert.DeserializeObject<JObject>("{ \"mock_key\": \"mock_value\" }")
+    };
+
+    LobbyExporter m_LobbyExporter = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_MockUnityEnvironment.Reset();
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(Guid.NewGuid().ToString());
+
+        m_MockRemoteConfigService.Reset();
+
+        var configJson = JsonConvert.SerializeObject(m_Config);
+        var configElement = JsonConvert.DeserializeObject<JObject>(configJson);
+
+        m_MockRemoteConfigService.Setup(
+            rc => rc.GetAllConfigsFromEnvironmentAsync(It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(() => {
+                return JsonConvert.SerializeObject(new RemoteConfigResponse
+                {
+                    Configs = new List<RemoteConfigResponse.Config>{
+                        new RemoteConfigResponse.Config{
+                            Id = m_Config.Id,
+                            Type = LobbyConstants.ConfigType,
+                            Value = new List<RemoteConfigResponse.ConfigValue>{
+                                new RemoteConfigResponse.ConfigValue{
+                                    Key = LobbyConstants.ConfigKey,
+                                    Value = configElement,
+                                }
+                            },
+                        }
+                    }
+                });
+            });
+
+        m_MockArchiver.Reset();
+        m_MockLogger.Reset();
+        m_MockFileSystem.Reset();
+        m_MockFileSystem.Setup(
+            e => e
+                .Directory
+                .CreateDirectory(It.IsAny<string>()));
+        m_MockFileSystem.Setup(
+                e => e
+                    .File
+                    .Exists(It.IsAny<string>()))
+            .Returns<string>((path) => false);
+
+        m_LobbyExporter = new(m_MockRemoteConfigService.Object,
+            m_MockArchiver.Object,
+            m_MockUnityEnvironment.Object,
+            m_MockFileSystem.Object,
+            m_MockLogger.Object);
+    }
+
+    [Test]
+    public async Task ExportAsync_CallsLoadingIndicator()
+    {
+        var exportInput = new ExportInput()
+        {
+            OutputDirectory = "mock_output_directory"
+        };
+
+        await ExportHandler.ExportAsync
+        (
+            exportInput,
+            m_LobbyExporter,
+            m_MockLoadingIndicator.Object,
+            CancellationToken.None
+        );
+
+        m_MockLoadingIndicator.Verify(li => li.StartLoadingAsync(ExportHandler.LoadingIndicatorMessage,
+            It.IsAny<Func<StatusContext?, Task>>()));
+    }
+
+    [Test]
+    public async Task ExportAsync_ExportsAndZips()
+    {
+        var exportInput = new ExportInput()
+        {
+            OutputDirectory = "mock_output_directory"
+        };
+
+        await m_LobbyExporter.ExportAsync(exportInput, CancellationToken.None);
+
+        var archivePath = Path.Join(exportInput.OutputDirectory, LobbyConstants.ZipName);
+
+        m_MockRemoteConfigService.Verify(
+            rc => rc.GetAllConfigsFromEnvironmentAsync(It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+        m_MockArchiver.Verify(za => za.ZipAsync(
+            archivePath,
+            LobbyConstants.EntryName,
+            It.IsAny<IEnumerable<LobbyConfig>>(),
+            It.IsAny<CancellationToken>()));
+    }
+
+    [Test]
+    public async Task ExportAsync_ExportsAndZipsWithFileName()
+    {
+        var fileName = "other.lozip";
+
+        var exportInput = new ExportInput()
+        {
+            OutputDirectory = "mock_output_directory",
+            FileName = fileName
+        };
+
+        await m_LobbyExporter.ExportAsync(exportInput, CancellationToken.None);
+
+        var archivePath = Path.Join(exportInput.OutputDirectory, fileName);
+
+        m_MockRemoteConfigService.Verify(
+            rc => rc.GetAllConfigsFromEnvironmentAsync(It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+        m_MockArchiver.Verify(za => za.ZipAsync(
+            archivePath,
+            LobbyConstants.EntryName,
+            It.IsAny<IEnumerable<LobbyConfig>>(),
+            It.IsAny<CancellationToken>()));
+    }
+
+    [Test]
+    public void ExportAsync_FailsWithInvalidExtension()
+    {
+        var fileName = "other.zip";
+
+        var exportInput = new ExportInput()
+        {
+            OutputDirectory = "mock_output_directory",
+            FileName = fileName
+        };
+
+        var exception = Assert.ThrowsAsync<CliException>(async () =>
+        {
+            await m_LobbyExporter.ExportAsync(exportInput, CancellationToken.None);
+        });
+
+        Assert.That(exception!.Message, Is.EqualTo("The file-name argument must have the extension '.lozip'."));
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetHostedLobbiesHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetHostedLobbiesHandlerTests.cs
index b1b8e22..be3ffaa 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetHostedLobbiesHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetHostedLobbiesHandlerTests.cs
@@ -10,11 +10,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class GetHostedLobbiesHandlerTests
+    class GetHostedLobbiesHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetJoinedLobbiesHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetJoinedLobbiesHandlerTests.cs
index f725bbb..7c23c83 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetJoinedLobbiesHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetJoinedLobbiesHandlerTests.cs
@@ -10,11 +10,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class GetJoinedLobbiesHandlerTests
+    class GetJoinedLobbiesHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetLobbyHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetLobbyHandlerTests.cs
index 94e5ded..c55488b 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetLobbyHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/GetLobbyHandlerTests.cs
@@ -10,11 +10,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class GetLobbyHandlerTests
+    class GetLobbyHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/HeartbeatHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/HeartbeatHandlerTests.cs
index 7841e2b..6b12d5a 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/HeartbeatHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/HeartbeatHandlerTests.cs
@@ -9,11 +9,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class HeartbeatLobbyHandlerTests
+    class HeartbeatLobbyHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ImportHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ImportHandlerTests.cs
new file mode 100644
index 0000000..cc0676e
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ImportHandlerTests.cs
@@ -0,0 +1,287 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using Spectre.Console;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.RemoteConfig.Service;
+using Unity.Services.Cli.Lobby.Handlers;
+using Unity.Services.Cli.Lobby.Handlers.ImportExport;
+using Unity.Services.Cli.RemoteConfig.Types;
+
+namespace Unity.Services.Cli.Lobby.UnitTest.Handlers;
+
+[TestFixture]
+class ImportHandlerTests
+{
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<IRemoteConfigService> m_MockRemoteConfigService = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IZipArchiver> m_MockArchiver = new();
+    readonly Mock<ILoadingIndicator> m_MockLoadingIndicator = new();
+
+    LobbyConfig m_Config = null!;
+
+    LobbyImporter m_LobbyImporter = null!;
+
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_Config = JsonConvert.DeserializeObject<LobbyConfig>(
+            "{ \"Id\": \"mock_id\", \"Config\": { \"mock_key\": \"mock_value\" } }"
+        )!;
+
+        m_MockUnityEnvironment.Reset();
+        m_MockRemoteConfigService.Reset();
+        m_MockUnityEnvironment.Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(Guid.NewGuid().ToString());
+
+        m_MockLogger.Reset();
+
+        m_MockArchiver.Reset();
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<LobbyConfig>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult<IEnumerable<LobbyConfig>>(new List<LobbyConfig>{ m_Config }));
+
+        m_LobbyImporter = new LobbyImporter(
+            m_MockRemoteConfigService.Object,
+            m_MockArchiver.Object,
+            m_MockUnityEnvironment.Object,
+            m_MockLogger.Object);
+    }
+
+    [Test]
+    public async Task ImportAsync_CallsLoadingIndicator()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory"
+        };
+
+        await ImportHandler.ImportAsync(
+            importInput,
+            m_LobbyImporter,
+            m_MockLoadingIndicator.Object,
+            CancellationToken.None
+        );
+
+        m_MockLoadingIndicator.Verify(li => li.StartLoadingAsync(ImportHandler.LoadingIndicatorMessage,
+            It.IsAny<Func<StatusContext?, Task>>()));
+    }
+
+    [Test]
+    public async Task ImportAsync_Unzips()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            DryRun = true
+        };
+
+        SetupExistingConfig(m_Config);
+
+        await m_LobbyImporter.ImportAsync(importInput, CancellationToken.None);
+
+        var archivePath = Path.Join(importInput.InputDirectory, LobbyConstants.ZipName);
+
+        m_MockArchiver.Verify(za => za.UnzipAsync<LobbyConfig>(
+            archivePath,
+            LobbyConstants.EntryName,
+            It.IsAny<CancellationToken>()));
+    }
+
+    [Test]
+    public async Task ImportAsync_UnzipsWithFileName()
+    {
+        var fileName = "other.lozip";
+
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            FileName = fileName,
+            DryRun = true
+        };
+
+        SetupExistingConfig(m_Config);
+
+        await m_LobbyImporter.ImportAsync(importInput, CancellationToken.None);
+
+        var archivePath = Path.Join(importInput.InputDirectory, fileName);
+
+        m_MockArchiver.Verify(za => za.UnzipAsync<LobbyConfig>(
+            archivePath,
+            LobbyConstants.EntryName,
+            It.IsAny<CancellationToken>()));
+    }
+
+    [Test]
+    public void ImportAsync_FailsWithInvalidExtension()
+    {
+        var fileName = "other.zip";
+
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            FileName = fileName,
+            DryRun = true
+        };
+
+        var exception = Assert.ThrowsAsync<CliException>(async () =>
+        {
+            await m_LobbyImporter.ImportAsync(importInput, CancellationToken.None);
+        });
+        Assert.That(exception!.Message, Is.EqualTo("The file-name argument must have the extension '.lozip'."));
+    }
+
+    [Test]
+    public async Task ImportAsync_DryRunDoesNotImport()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            DryRun = true
+        };
+
+        SetupExistingConfig(m_Config);
+
+        await m_LobbyImporter.ImportAsync(importInput, CancellationToken.None);
+
+        m_MockRemoteConfigService.Verify(
+            rcs => rcs.UpdateConfigAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string?>(),
+                It.IsAny<IEnumerable<ConfigValue>>(),
+                It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    [Test]
+    public async Task ConfigExists_Updates()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+        };
+
+        SetupExistingConfig(m_Config);
+
+        await m_LobbyImporter.ImportAsync(importInput, CancellationToken.None);
+
+        m_MockRemoteConfigService.Verify(
+            rcs => rcs.UpdateConfigAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+        m_MockRemoteConfigService.Verify(
+            rcs => rcs.CreateConfigAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<IEnumerable<ConfigValue>>(),
+                It.IsAny<CancellationToken>()),
+            Times.Never);
+    }
+
+    [Test]
+    public async Task ConfigDoesNotExist_CreatesAndAppliesSchema()
+    {
+        m_Config = new();
+
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+        };
+
+        await m_LobbyImporter.ImportAsync(importInput, CancellationToken.None);
+
+        m_MockRemoteConfigService.Verify(
+            rcs => rcs.CreateConfigAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<IEnumerable<ConfigValue>>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+        m_MockRemoteConfigService.Verify(
+            rcs => rcs.ApplySchemaAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+        m_MockRemoteConfigService.Verify(
+            rcs => rcs.UpdateConfigAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    [Test]
+    public async Task Reconcile_Updates()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory",
+            Reconcile = true
+        };
+
+        SetupExistingConfig(m_Config);
+
+        await m_LobbyImporter.ImportAsync(importInput, CancellationToken.None);
+
+        m_MockRemoteConfigService.Verify(
+            rcs => rcs.CreateConfigAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<IEnumerable<ConfigValue>>(),
+                It.IsAny<CancellationToken>()),
+            Times.Never);
+        m_MockRemoteConfigService.Verify(
+            rcs => rcs.UpdateConfigAsync(
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+    }
+
+    void SetupExistingConfig(LobbyConfig config)
+    {
+        m_MockRemoteConfigService.Setup(
+            rc => rc.GetAllConfigsFromEnvironmentAsync(It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<string>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(() => {
+                return JsonConvert.SerializeObject(new RemoteConfigResponse
+                {
+                    Configs = new List<RemoteConfigResponse.Config>{
+                        new RemoteConfigResponse.Config{
+                            Id = config.Id,
+                            Type = LobbyConstants.ConfigType,
+                            Value = new List<RemoteConfigResponse.ConfigValue>{
+                                new RemoteConfigResponse.ConfigValue{
+                                    Key = LobbyConstants.ConfigKey,
+                                    Value = config.Config,
+                                }
+                            },
+                        }
+                    }
+                });
+            });
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/JoinLobbyHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/JoinLobbyHandlerTests.cs
index ac8fee6..821dae2 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/JoinLobbyHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/JoinLobbyHandlerTests.cs
@@ -13,11 +13,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class JoinLobbyHandlerTests
+    class JoinLobbyHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/LobbyConfigTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/LobbyConfigTests.cs
new file mode 100644
index 0000000..4ce091b
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/LobbyConfigTests.cs
@@ -0,0 +1,116 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+using NUnit.Framework;
+using Unity.Services.Cli.Lobby.Handlers;
+using Unity.Services.Cli.Lobby.Handlers.ImportExport;
+
+namespace Unity.Services.Cli.Lobby.UnitTest.Handlers;
+
+[TestFixture]
+public class LobbyConfigTests
+{
+    const string k_TimestampFormat = "yyyy-MM-ddThh:mm:ttZ";
+    const string k_DefaultStringSetting = "string-setting";
+    const int k_DefaultIntSetting = 1;
+
+    [Test]
+    public void TryParse_SucceedsWithValidConfig()
+    {
+        var configResponse = NewDefaultConfig();
+        var json = JsonConvert.SerializeObject(
+            configResponse,
+            new JsonSerializerSettings
+            {
+                ContractResolver = new CamelCasePropertyNamesContractResolver()
+            });
+
+        var success = LobbyConfig.TryParse(json, out var lobbyConfig);
+        Assert.True(success);
+        Assert.NotNull(lobbyConfig);
+        Assert.AreEqual(lobbyConfig.Id, configResponse.Configs.First().Id);
+        Assert.AreEqual(2, lobbyConfig.Config.Count);
+        Assert.True(lobbyConfig.Config.ContainsKey(nameof(MockLobbyConfig.StringSetting)));
+        Assert.AreEqual(k_DefaultStringSetting,
+            lobbyConfig.Config.GetValue(nameof(MockLobbyConfig.StringSetting)).Value<string>());
+        Assert.True(lobbyConfig.Config.ContainsKey(nameof(MockLobbyConfig.IntSetting)));
+        Assert.AreEqual(k_DefaultIntSetting,
+            lobbyConfig.Config.GetValue(nameof(MockLobbyConfig.IntSetting)).Value<int>());
+    }
+
+    [Test]
+    public void TryParse_FailsWithNoLobbyConfigValue()
+    {
+        var configResponse = NewDefaultConfig(includeMockConfig: false);
+        var json = JsonConvert.SerializeObject(
+            configResponse,
+            new JsonSerializerSettings
+            {
+                ContractResolver = new CamelCasePropertyNamesContractResolver()
+            });
+
+        var success = LobbyConfig.TryParse(json, out var lobbyConfig);
+        Assert.False(success);
+        Assert.Null(lobbyConfig);
+    }
+
+    [Test]
+    public void TryParse_FailsWithNoConfigs()
+    {
+        var configResponse = new List<RemoteConfigResponse.Config>();
+        var json = JsonConvert.SerializeObject(
+            configResponse,
+            new JsonSerializerSettings
+            {
+                ContractResolver = new CamelCasePropertyNamesContractResolver()
+            });
+
+        var success = LobbyConfig.TryParse(json, out var lobbyConfig);
+        Assert.False(success);
+        Assert.Null(lobbyConfig);
+    }
+
+    static RemoteConfigResponse NewDefaultConfig(bool includeMockConfig = true)
+    {
+        var mockConfigJson = includeMockConfig ? JsonConvert.SerializeObject(
+             new MockLobbyConfig()
+            {
+                StringSetting = k_DefaultStringSetting,
+                IntSetting = k_DefaultIntSetting,
+            }) : "{}";
+
+        var now = DateTime.Now.ToString(k_TimestampFormat);
+        var config = new RemoteConfigResponse.Config
+        {
+            ProjectId = Guid.NewGuid().ToString(),
+            EnvironmentId = Guid.NewGuid().ToString(),
+            Id = Guid.NewGuid().ToString(),
+            Type = LobbyConstants.ConfigType,
+            CreatedAt = now,
+            UpdatedAt = now,
+            Value = new List<RemoteConfigResponse.ConfigValue>
+            {
+                new RemoteConfigResponse.ConfigValue{
+                    Key = LobbyConstants.ConfigKey,
+                    Type = RemoteConfig.Types.ValueType.Json.ToString().ToLower(),
+                    SchemaId = LobbyConstants.ConfigType,
+                    Value = JObject.Parse(mockConfigJson)
+                }
+            }
+        };
+
+        return new RemoteConfigResponse
+        {
+            Configs = new List<RemoteConfigResponse.Config>
+            {
+                config
+            }
+        };
+    }
+
+    class MockLobbyConfig
+    {
+        public string StringSetting { get; set; }
+        public int IntSetting { get; set; }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/QueryLobbiesHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/QueryLobbiesHandlerTests.cs
index 5a34d57..36d8c6a 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/QueryLobbiesHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/QueryLobbiesHandlerTests.cs
@@ -11,11 +11,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class QueryLobbiesHandlerTests
+    class QueryLobbiesHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/QuickJoinHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/QuickJoinHandlerTests.cs
index 4822a21..40813bd 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/QuickJoinHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/QuickJoinHandlerTests.cs
@@ -13,11 +13,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class QuickJoinHandlerTests
+    class QuickJoinHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ReconnectHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ReconnectHandlerTests.cs
index 195d86d..602441f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ReconnectHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/ReconnectHandlerTests.cs
@@ -10,11 +10,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class ReconnectHandlerTests
+    class ReconnectHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/RemovePlayerHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/RemovePlayerHandlerTests.cs
index b753c15..21f764e 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/RemovePlayerHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/RemovePlayerHandlerTests.cs
@@ -9,11 +9,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class RemovePlayerHandlerTests
+    class RemovePlayerHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/RequestTokenHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/RequestTokenHandlerTests.cs
index 3c8d13f..1561bcb 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/RequestTokenHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/RequestTokenHandlerTests.cs
@@ -11,11 +11,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class RequestTokenHandlerTests
+    class RequestTokenHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/UpdateLobbyHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/UpdateLobbyHandlerTests.cs
index 2b48f1d..86537b9 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/UpdateLobbyHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/UpdateLobbyHandlerTests.cs
@@ -13,11 +13,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class UpdateLobbyHandlerTests
+    class UpdateLobbyHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/UpdatePlayerHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/UpdatePlayerHandlerTests.cs
index 1d8fb45..94f3c2b 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/UpdatePlayerHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Handlers/UpdatePlayerHandlerTests.cs
@@ -13,11 +13,11 @@
 
 namespace Unity.Services.Cli.Lobby.UnitTest.Handlers
 {
-    internal class UpdatePlayerHandlerTests
+    class UpdatePlayerHandlerTests
     {
         Mock<ILogger> m_MockLogger = new();
         Mock<ILobbyService> m_MockLobby = new();
-        private Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+        Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
 
         [SetUp]
         public void SetUp()
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/LobbyModuleTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/LobbyModuleTests.cs
index 0de027f..e363c8f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/LobbyModuleTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/LobbyModuleTests.cs
@@ -3,6 +3,8 @@
 using Microsoft.Extensions.DependencyInjection;
 using Moq;
 using NUnit.Framework;
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Authoring.Import.Input;
 using Unity.Services.Cli.Common;
 using Unity.Services.Cli.Common.Input;
 using Unity.Services.Cli.Lobby.Input;
@@ -49,18 +51,6 @@ public CommandTestCase(string name, List<Argument> arguments, List<Option> optio
         new CommandTestCase("bulk-update",
             new List<Argument>() { CommonLobbyInput.LobbyIdArgument, RequiredBodyInput.RequestBodyArgument },
             new List<Option>(ServiceIdOptionList)),
-        new CommandTestCase("config",
-            new List<Argument>(),
-            new List<Option>(),
-            new List<CommandTestCase>() {
-                new CommandTestCase("get",
-                    new List<Argument>(),
-                    new List<Option>(){ CommonInput.CloudProjectIdOption, CommonInput.EnvironmentNameOption }),
-                new CommandTestCase("update",
-                    new List<Argument>() { LobbyConfigUpdateInput.ConfigIdArgument, RequiredBodyInput.RequestBodyArgument },
-                    new List<Option>(){ CommonInput.CloudProjectIdOption }),
-            }
-        ),
         new CommandTestCase("create",
             new List<Argument>() { RequiredBodyInput.RequestBodyArgument },
             new List<Option>(ServiceIdOptionList) { CommonLobbyInput.PlayerIdOption }),
@@ -108,6 +98,24 @@ public CommandTestCase(string name, List<Argument> arguments, List<Option> optio
         new CommandTestCase("update",
             new List<Argument>() { CommonLobbyInput.LobbyIdArgument, RequiredBodyInput.RequestBodyArgument },
             new List<Option>(ServiceIdOptionList) { CommonLobbyInput.PlayerIdOption }),
+        new CommandTestCase("config",
+            new List<Argument>(),
+            new List<Option>(),
+            new List<CommandTestCase>() {
+                new CommandTestCase("get",
+                    new List<Argument>(),
+                    new List<Option>(){ CommonInput.CloudProjectIdOption, CommonInput.EnvironmentNameOption }),
+                new CommandTestCase("update",
+                    new List<Argument>() { LobbyConfigUpdateInput.ConfigIdArgument, RequiredBodyInput.RequestBodyArgument },
+                    new List<Option>(){ CommonInput.CloudProjectIdOption }),
+            }
+        ),
+        new CommandTestCase("import",
+            new List<Argument>() { ImportInput.InputDirectoryArgument, ImportInput.FileNameArgument },
+            new List<Option>() { CommonInput.CloudProjectIdOption, CommonInput.EnvironmentNameOption, ImportInput.DryRunOption, ImportInput.ReconcileOption }),
+        new CommandTestCase("export",
+            new List<Argument>() { ExportInput.OutputDirectoryArgument, ExportInput.FileNameArgument },
+            new List<Option>() { CommonInput.CloudProjectIdOption, CommonInput.EnvironmentNameOption, ImportInput.DryRunOption }),
     };
 
     [Test]
@@ -150,11 +158,11 @@ public void ConfigureLobbyRegistersExpectedServices()
         var hostBuilder = TestsHelper.CreateAndSetupMockHostBuilder(services);
         hostBuilder.ConfigureServices(LobbyModule.RegisterServices);
 
-        Assert.AreEqual(2, services.Count);
+        Assert.AreEqual(4, services.Count);
         TestsHelper.AssertHasServiceSingleton<ILobbyService, LobbyService>(services);
     }
 
-    private void VerifyCommand(Command parentCommand, CommandTestCase testCase)
+    static void VerifyCommand(Command parentCommand, CommandTestCase testCase)
     {
         TestsHelper.AssertContainsCommand(parentCommand, testCase.Name, out var command);
         CollectionAssert.AreEqual(testCase.Arguments, command.Arguments, $"Expected Arguments do not match for \"{parentCommand.Name} {testCase.Name}\"");
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Mock/LobbyApiV1AsyncMock.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Mock/LobbyApiV1AsyncMock.cs
index ccba4fe..7e915b1 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Mock/LobbyApiV1AsyncMock.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby.UnitTest/Mock/LobbyApiV1AsyncMock.cs
@@ -9,7 +9,7 @@ class LobbyApiV1AsyncMock
 {
     public Mock<ILobbyApiAsync> DefaultLobbyClient = new();
 
-    private List<LobbyModel> m_TestLobbies = new List<LobbyModel>()
+    List<LobbyModel> m_TestLobbies = new List<LobbyModel>()
     {
         new LobbyModel(id: "test-lobby-1", lobbyCode: "code-1", maxPlayers: 8, hostId: "test-service-id", players: new List<Player>()),
         new LobbyModel(id: "test-lobby-2", lobbyCode: "code-2", maxPlayers: 8, hostId: "test-service-id", players: new List<Player>(){new Player(id: "test-player")}),
@@ -34,7 +34,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string lobbyId, string _, string _, BulkUpdateRequest bulkUpdateRequest, int _, CancellationToken _) => {
+            .Returns((string _, string _, string lobbyId, string _, string _, BulkUpdateRequest bulkUpdateRequest, int _, CancellationToken _) =>
+            {
                 var lobby = GetTestLobbyById(lobbyId);
                 if (lobby is null)
                 {
@@ -57,7 +58,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string serviceId, string _, CreateRequest createRequest, int _, CancellationToken _) => {
+            .Returns((string _, string _, string serviceId, string _, CreateRequest createRequest, int _, CancellationToken _) =>
+            {
                 var lobby = new LobbyModel(
                     id: createRequest.Name,
                     name: createRequest.Name,
@@ -78,7 +80,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string lobbyId, string _, string _, int _, CancellationToken _) => {
+            .Returns((string _, string _, string lobbyId, string _, string _, int _, CancellationToken _) =>
+            {
                 var lobby = GetTestLobbyById(lobbyId);
                 if (lobby is null)
                 {
@@ -97,7 +100,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string _, string impersonatedUserId, int _, CancellationToken _) => {
+            .Returns((string _, string _, string _, string impersonatedUserId, int _, CancellationToken _) =>
+            {
                 var lobbies = new List<string>();
                 foreach (var lobby in m_TestLobbies)
                 {
@@ -123,7 +127,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string serviceId, string _, int _, CancellationToken _) => {
+            .Returns((string _, string _, string serviceId, string _, int _, CancellationToken _) =>
+            {
                 return Task.FromResult(m_TestLobbies.Where(l => l.HostId.Equals(serviceId)).Select(l => l.Id).ToList());
             });
 
@@ -138,7 +143,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string lobbyId, string _, string _, string _, int _, CancellationToken _) => {
+            .Returns((string _, string _, string lobbyId, string _, string _, string _, int _, CancellationToken _) =>
+            {
                 var lobby = GetTestLobbyById(lobbyId);
                 if (lobby is null)
                 {
@@ -159,7 +165,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string lobbyId, string _, string _, JoinLobbyByIdRequest joinLobbyByIdRequest, int _, CancellationToken _) => {
+            .Returns((string _, string _, string lobbyId, string _, string _, JoinLobbyByIdRequest joinLobbyByIdRequest, int _, CancellationToken _) =>
+            {
                 var lobby = GetTestLobbyById(lobbyId);
                 if (lobby is null)
                 {
@@ -180,7 +187,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string _, string _, JoinByCodeRequest joinByCodeRequest, int _, CancellationToken _) => {
+            .Returns((string _, string _, string _, string _, JoinByCodeRequest joinByCodeRequest, int _, CancellationToken _) =>
+            {
                 var lobby = m_TestLobbies.Where(l => l.LobbyCode.Equals(joinByCodeRequest.LobbyCode)).FirstOrDefault();
                 if (lobby is null)
                 {
@@ -202,7 +210,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string lobbyId, string _, string impersonatedUserId, object _, int _, CancellationToken _) => {
+            .Returns((string _, string _, string lobbyId, string _, string impersonatedUserId, object _, int _, CancellationToken _) =>
+            {
                 var lobby = GetTestLobbyById(lobbyId);
                 if (lobby is null)
                 {
@@ -253,7 +262,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string lobbyId, string playerId, string _, string _, int _, CancellationToken _) => {
+            .Returns((string _, string _, string lobbyId, string playerId, string _, string _, int _, CancellationToken _) =>
+            {
                 var lobby = GetTestLobbyById(lobbyId);
                 if (lobby is null)
                 {
@@ -282,7 +292,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string lobbyId, string playerId, string _, string _, PlayerUpdateRequest playerUpdateRequest, int _, CancellationToken _) => {
+            .Returns((string _, string _, string lobbyId, string playerId, string _, string _, PlayerUpdateRequest playerUpdateRequest, int _, CancellationToken _) =>
+            {
                 var lobby = GetTestLobbyById(lobbyId);
                 if (lobby is null)
                 {
@@ -313,7 +324,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string lobbyId, string _, string _, UpdateRequest updateRequest, int _, CancellationToken _) => {
+            .Returns((string _, string _, string lobbyId, string _, string _, UpdateRequest updateRequest, int _, CancellationToken _) =>
+            {
                 var lobby = GetTestLobbyById(lobbyId);
                 if (lobby is null)
                 {
@@ -336,7 +348,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string lobbyId, string _, string _, object _, int _, CancellationToken _) => {
+            .Returns((string _, string _, string lobbyId, string _, string _, object _, int _, CancellationToken _) =>
+            {
                 var lobby = GetTestLobbyById(lobbyId);
                 return lobby is not null ? Task.CompletedTask : throw new HttpRequestException();
             });
@@ -352,7 +365,8 @@ public void SetUp()
                     0,
                     CancellationToken.None
                 ))
-            .Returns((string _, string _, string lobbyId, List<TokenRequest> _, string _, string _, int _, CancellationToken _) => {
+            .Returns((string _, string _, string lobbyId, List<TokenRequest> _, string _, string _, int _, CancellationToken _) =>
+            {
                 var lobby = GetTestLobbyById(lobbyId);
                 if (lobby is null)
                 {
@@ -363,12 +377,12 @@ public void SetUp()
             });
     }
 
-    private LobbyModel? GetTestLobbyById(string id)
+    LobbyModel? GetTestLobbyById(string id)
     {
         return m_TestLobbies.Where(l => l.Id.Equals(id)).FirstOrDefault();
     }
 
-    private static Player? GetPlayerInLobby(LobbyModel lobby, string playerId)
+    static Player? GetPlayerInLobby(LobbyModel lobby, string playerId)
     {
         var matchingPlayers = lobby.Players.Where(p => p.Id.Equals(playerId));
         return matchingPlayers.Any() ? matchingPlayers.First() : null;
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/Config/ConfigSchema.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/Config/ConfigSchema.cs
new file mode 100644
index 0000000..6cc56de
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/Config/ConfigSchema.cs
@@ -0,0 +1,15 @@
+using System.Reflection;
+using Unity.Services.Cli.Authoring.Templates;
+using Unity.Services.Cli.Common.Utils;
+
+namespace Unity.Services.Cli.Lobby.Handlers.Config;
+
+public class ConfigSchema : IFileTemplate
+{
+    const string k_EmbeddedConfigSchema = "Unity.Services.Cli.Lobby.Handlers.Config.lobby-config-schema.json";
+
+    public string Extension => ".json";
+
+    public string FileBodyText => ResourceFileHelper
+        .ReadResourceFileAsync(Assembly.GetExecutingAssembly(), k_EmbeddedConfigSchema).Result;
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/Config/lobby-config-schema.json b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/Config/lobby-config-schema.json
new file mode 100644
index 0000000..ecc1295
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/Config/lobby-config-schema.json
@@ -0,0 +1,45 @@
+{
+  "title": "Lobby Project Config",
+  "$id": "resource:/lobby",
+  "description": "The schema for a Lobby project's configuration.",
+  "type": "object",
+  "properties": {
+    "activeLifespanSeconds": {
+      "type": "integer",
+      "minimum": 10,
+      "maximum": 3600,
+      "description":
+        "The minimum amount of time, in seconds, that must pass before a lobby is considered inactive."
+    },
+    "disconnectRemovalTimeSeconds": {
+      "type": "integer",
+      "minimum": 10,
+      "maximum": 3600,
+      "description":
+        "The minimum amount of time, in seconds, that must pass before a disconnected player is removed from the lobby."
+    },
+    "playerSlots": {
+      "type": "object",
+      "properties": {
+        "minimum": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 100
+        },
+        "maximum": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 100
+        }
+      },
+      "required": ["minimum", "maximum"],
+      "description": "The minimum and maximum allowed values for a lobby's \"MaxPlayers\" property."
+    },
+    "socialProfilesEnabled": {
+      "type": "boolean",
+      "description": "Whether or not to inject profiles from Social Profile data in lobby responses.",
+      "default": false
+    }
+  },
+  "required": ["activeLifespanSeconds", "disconnectRemovalTimeSeconds", "playerSlots"]
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ConfigGetHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ConfigGetHandler.cs
index bc404ab..8852a50 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ConfigGetHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ConfigGetHandler.cs
@@ -10,13 +10,11 @@ namespace Unity.Services.Cli.Lobby.Handlers
 {
     static class ConfigGetHandler
     {
-        private const string k_LobbyConfigType = "lobby";
-
-        private const string k_EnvironmentNotFoundMsg = $"The value of option '{Keys.ConfigKeys.EnvironmentName}' fed as " +
-                                                        "direct input, found in configuration or fetched from " +
-                                                        "environment variables does not correspond to an environment " +
-                                                        "that exists. Command will proceed without a specific " +
-                                                        $"{Keys.ConfigKeys.EnvironmentName}.";
+        const string k_EnvironmentNotFoundMsg = $"The value of option '{Keys.ConfigKeys.EnvironmentName}' fed as " +
+                                                "direct input, found in configuration or fetched from " +
+                                                "environment variables does not correspond to an environment " +
+                                                "that exists. Command will proceed without a specific " +
+                                                $"{Keys.ConfigKeys.EnvironmentName}.";
 
         /// <param name="input">
         /// Lobby input automatically parsed. So developer does not need to retrieve from ParseResult.
@@ -53,10 +51,10 @@ public static async Task ConfigGetAsync(CommonInput input, IUnityEnvironment uni
                 logger.LogWarning(k_EnvironmentNotFoundMsg);
             }
 
-            var result = await service.GetAllConfigsFromEnvironmentAsync(
+            string result = await service.GetAllConfigsFromEnvironmentAsync(
                 projectId,
                 environmentId,
-                k_LobbyConfigType,
+                LobbyConstants.ConfigType,
                 cancellationToken);
             logger.LogResultValue(result);
         }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/ExportHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/ExportHandler.cs
new file mode 100644
index 0000000..dae6437
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/ExportHandler.cs
@@ -0,0 +1,24 @@
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Authoring.Export.Input;
+
+namespace Unity.Services.Cli.Lobby.Handlers.ImportExport;
+
+static class ExportHandler
+{
+    internal const string LoadingIndicatorMessage = "Exporting your environment...";
+
+    public static async Task ExportAsync(
+        ExportInput exportInput,
+        LobbyExporter? lobbyExporter,
+        ILoadingIndicator loadingIndicator,
+        CancellationToken cancellationToken)
+    {
+        await loadingIndicator.StartLoadingAsync(
+            LoadingIndicatorMessage,
+            _ =>
+            {
+                return lobbyExporter!.ExportAsync(exportInput, cancellationToken);
+            }
+        );
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/ImportHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/ImportHandler.cs
new file mode 100644
index 0000000..3ba7560
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/ImportHandler.cs
@@ -0,0 +1,21 @@
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Authoring.Import.Input;
+
+namespace Unity.Services.Cli.Lobby.Handlers.ImportExport;
+
+static class ImportHandler
+{
+    internal const string LoadingIndicatorMessage = "Importing configs...";
+
+    public static async Task ImportAsync(
+        ImportInput importInput,
+        LobbyImporter? lobbyImporter,
+        ILoadingIndicator loadingIndicator,
+        CancellationToken cancellationToken
+    )
+    {
+        await loadingIndicator.StartLoadingAsync(
+            LoadingIndicatorMessage,
+            _ => lobbyImporter!.ImportAsync(importInput, cancellationToken));
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/LobbyConfig.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/LobbyConfig.cs
new file mode 100644
index 0000000..f5f41ee
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/LobbyConfig.cs
@@ -0,0 +1,88 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Unity.Services.Cli.Common.Exceptions;
+
+namespace Unity.Services.Cli.Lobby.Handlers.ImportExport;
+
+public class LobbyConfig
+{
+    public string Id { get; set; }
+
+    public JObject Config { get; set; }
+
+    public LobbyConfig()
+    {
+        Id = "";
+        Config = new JObject();
+    }
+
+    public static LobbyConfig Parse(string response)
+    {
+        if (string.IsNullOrWhiteSpace(response))
+        {
+            throw new ArgumentNullException(nameof(response));
+        }
+
+        var configResponse = JsonConvert.DeserializeObject<RemoteConfigResponse>(response);
+        if (configResponse.Configs == null || configResponse.Configs.Count == 0)
+        {
+            throw new CliException($"There is no lobby configuration available in this environment.", ExitCode.HandledError);
+        }
+
+        var lobbyConfig = configResponse.Configs.First(c => c.Type == LobbyConstants.ConfigType);
+        var lobbyConfigValue = lobbyConfig.Value.First(c => c.Key == LobbyConstants.ConfigKey);
+
+        var lobbyConfigData = lobbyConfigValue.Value;
+        if (lobbyConfigData == null || lobbyConfigData.Count == 0)
+        {
+            throw new CliException($"There is no lobby configuration available in this environment.", ExitCode.HandledError);
+        }
+
+        return new LobbyConfig
+        {
+            Id = lobbyConfig.Id,
+            Config = lobbyConfigData
+        };
+    }
+
+    public static bool TryParse(string response, out LobbyConfig? config)
+    {
+        try
+        {
+            config = Parse(response);
+            return true;
+        }
+        catch
+        {
+            config = null;
+            return false;
+        }
+    }
+}
+
+
+public struct RemoteConfigResponse
+{
+    public List<Config> Configs { get; set; }
+
+    public struct Config
+    {
+        public string ProjectId { get; set; }
+        public string EnvironmentId { get; set; }
+        public string Type { get; set; }
+        public string Id { get; set; }
+        public string Version { get; set; }
+        public string CreatedAt { get; set; }
+        public string UpdatedAt { get; set; }
+
+        public List<ConfigValue> Value { get; set; }
+    }
+
+    public struct ConfigValue
+    {
+        public string Key { get; set; }
+        public string Type { get; set; }
+        public string SchemaId { get; set; }
+        public JObject Value { get; set; }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/LobbyExporter.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/LobbyExporter.cs
new file mode 100644
index 0000000..2c05c76
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/LobbyExporter.cs
@@ -0,0 +1,54 @@
+using System.IO.Abstractions;
+using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.RemoteConfig.Service;
+
+namespace Unity.Services.Cli.Lobby.Handlers.ImportExport;
+
+class LobbyExporter : BaseExporter<LobbyConfig>
+{
+    readonly IRemoteConfigService m_RemoteConfigService;
+
+    public LobbyExporter(
+        IRemoteConfigService remoteConfigService,
+        IZipArchiver zipArchiver,
+        IUnityEnvironment unityEnvironment,
+        IFileSystem fileSystem,
+        ILogger logger)
+        : base(
+        zipArchiver,
+        unityEnvironment,
+        fileSystem,
+        logger)
+    {
+        m_RemoteConfigService = remoteConfigService;
+    }
+
+    protected override string FileName => LobbyConstants.ZipName;
+    protected override string EntryName => LobbyConstants.EntryName;
+    protected override async Task<IEnumerable<LobbyConfig>> ListConfigsAsync(string projectId, string environmentId, CancellationToken cancellationToken)
+    {
+        string response = await m_RemoteConfigService.GetAllConfigsFromEnvironmentAsync(
+            projectId,
+            environmentId,
+            LobbyConstants.ConfigType,
+            cancellationToken);
+
+        LobbyConfig.TryParse(response, out LobbyConfig? config);
+
+        if (config == null)
+        {
+            return new List<LobbyConfig>();
+        }
+
+        return new List<LobbyConfig>{ config };
+    }
+
+    protected override ImportExportEntry<LobbyConfig> ToImportExportEntry(LobbyConfig value)
+    {
+        return new ImportExportEntry<LobbyConfig>(value.Id.GetHashCode(), LobbyConstants.ConfigDisplayName, value);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/LobbyImporter.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/LobbyImporter.cs
new file mode 100644
index 0000000..5af9f17
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/ImportExport/LobbyImporter.cs
@@ -0,0 +1,164 @@
+using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Import;
+using Unity.Services.Cli.RemoteConfig.Service;
+using Unity.Services.Cli.RemoteConfig.Types;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.Authoring.Templates;
+using Unity.Services.Cli.RemoteConfig.Model;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Lobby.Handlers.Config;
+using Unity.Services.Cli.RemoteConfig.Exceptions;
+
+namespace Unity.Services.Cli.Lobby.Handlers.ImportExport;
+
+class LobbyImporter : BaseImporter<LobbyConfig>
+{
+    readonly IRemoteConfigService m_RemoteConfigService;
+    readonly IFileTemplate m_ConfigSchema;
+
+    public LobbyImporter(
+        IRemoteConfigService remoteConfigService,
+        IZipArchiver zipArchiver,
+        IUnityEnvironment unityEnvironment,
+        ILogger logger)
+        : base(
+        zipArchiver,
+        unityEnvironment,
+        logger)
+    {
+        m_RemoteConfigService = remoteConfigService;
+        m_ConfigSchema = new ConfigSchema();
+    }
+
+    protected override string FileName => LobbyConstants.ZipName;
+    protected override string EntryName => LobbyConstants.EntryName;
+
+    protected override async Task CreateConfigAsync(
+        string projectId,
+        string environmentId,
+        LobbyConfig config,
+        CancellationToken cancellationToken)
+    {
+        string json = config.Config.ToString();
+        object newConfig = JsonConvert.DeserializeObject(json)!;
+        ConfigValue value = new ConfigValue(LobbyConstants.ConfigKey, RemoteConfig.Types.ValueType.Json, newConfig);
+
+        string configId = await m_RemoteConfigService.CreateConfigAsync(projectId, environmentId, LobbyConstants.ConfigType, new[] { value }, cancellationToken);
+
+        // We can call the UpdateConfigAsync method to both 1) apply the schema and 2) update the config with the new
+        // schema ID value.
+        config.Id = configId;
+        await UpdateConfigAsync(projectId, environmentId, config, cancellationToken);
+    }
+
+    protected override async Task UpdateConfigAsync(string projectId, string environmentId, LobbyConfig config, CancellationToken cancellationToken)
+    {
+        string configId = config.Id;
+
+        // Configs should already have the schema applied, but we do this as a safeguard because if they don't, the
+        // subsequent update request will fail.
+        await ApplySchema(projectId, configId, cancellationToken);
+
+        UpdateConfigRequest request = new UpdateConfigRequest
+        {
+            Type = LobbyConstants.ConfigType,
+            Value = new object[] {
+                new RemoteConfigResponse.ConfigValue
+                {
+                    Key = LobbyConstants.ConfigKey,
+                    Type = RemoteConfig.Types.ValueType.Json.ToString().ToLower(),
+                    SchemaId = LobbyConstants.SchemaId,
+                    Value = config.Config
+                }
+            }
+        };
+
+        await m_RemoteConfigService.UpdateConfigAsync(
+            projectId,
+            configId,
+            JsonConvert.SerializeObject(request,
+                new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() }),
+            cancellationToken);
+    }
+
+    protected override ImportExportEntry<LobbyConfig> ToImportExportEntry(LobbyConfig value)
+    {
+        return new ImportExportEntry<LobbyConfig>(value.Id.GetHashCode(), LobbyConstants.ConfigDisplayName, value);
+    }
+
+    protected override Task DeleteConfigAsync(
+        string projectId,
+        string environmentId,
+        LobbyConfig config,
+        CancellationToken cancellationToken)
+    {
+        // It's not safe to delete a lobby configuration from the CLI yet because the CLI's creation and deletion happen
+        // concurrently, so a user will experience errors if the existing config is not deleted before the new one is
+        // created. However, this method should never be called; see CreateState for more details.
+        throw new CliException("Unable to delete existing configuration.  This is not supported by the CLI.  Use an in-place upgrade (no --reconcile flag) instead.", ExitCode.HandledError);
+    }
+
+    protected override async Task<IEnumerable<LobbyConfig>> ListConfigsAsync(string projectId, string environmentId, CancellationToken cancellationToken)
+    {
+        var response = await m_RemoteConfigService.GetAllConfigsFromEnvironmentAsync(
+            projectId,
+            environmentId,
+            LobbyConstants.ConfigType,
+            cancellationToken);
+
+        LobbyConfig.TryParse(response, out LobbyConfig? config);
+        if (config == null)
+        {
+            return new List<LobbyConfig>();
+        }
+
+        return new List<LobbyConfig>{ config };
+    }
+
+    protected override ImportState<LobbyConfig> CreateState(IEnumerable<LobbyConfig> localConfigs, IEnumerable<LobbyConfig> remoteConfigs)
+    {
+        var toCreate = new List<ImportExportEntry<LobbyConfig>>();
+        var toUpdate = new List<ImportExportEntry<LobbyConfig>>();
+
+        if (localConfigs.Any())
+        {
+            var newConfig = ToImportExportEntry(localConfigs.First());
+
+            if (remoteConfigs.Any())
+            {
+                // Remote Config will reject the request if you try to create an additional "Lobby"-type config, so we need
+                // to use the existing config's ID and treat this as an update.
+                localConfigs.First().Id = remoteConfigs.First().Id;
+                toUpdate.Add(newConfig);
+            }
+            else
+            {
+                toCreate.Add(newConfig);
+            }
+        }
+
+        // This list must remain empty. If the remote config is marked for deletion, it may cause the coinciding create
+        // to fail because the create could come first, which would also trigger the Remote Config error for duplicate
+        // "Lobby"-type configs. Fortunately, in Lobby's case, just updating the existing config is functionally the same
+        // as the intended effect of the --reconcile flag (deleting, then re-creating), so that's what we do instead.
+        var toDelete = new List<ImportExportEntry<LobbyConfig>>();
+
+        return new ImportState<LobbyConfig>(toCreate, toUpdate, toDelete);
+    }
+
+    async Task ApplySchema(string projectId, string configId, CancellationToken cancellationToken)
+    {
+        try
+        {
+            await m_RemoteConfigService.ApplySchemaAsync(projectId, configId, m_ConfigSchema.FileBodyText, cancellationToken);
+        }
+        catch (ApiException) // Because it's an internal API, we hide any schema-related HTTP exceptions from the user.
+        {
+            throw new CliException("An error occurred while importing the Lobby configuration.", ExitCode.HandledError);
+        }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/LobbyConstants.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/LobbyConstants.cs
new file mode 100644
index 0000000..ae1dab6
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/LobbyConstants.cs
@@ -0,0 +1,16 @@
+namespace Unity.Services.Cli.Lobby.Handlers;
+
+static class LobbyConstants
+{
+    internal const string ConfigType = "lobby";
+
+    internal const string SchemaId = "lobby";
+
+    internal const string ConfigKey = "lobbyConfig";
+
+    internal const string ZipName = "ugs.lozip";
+
+    internal const string EntryName = "lobby";
+
+    internal const string ConfigDisplayName = "Lobby configuration";
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/RequestBodyHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/RequestBodyHandler.cs
index d7b4acd..967e683 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/RequestBodyHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Handlers/RequestBodyHandler.cs
@@ -2,7 +2,7 @@
 
 namespace Unity.Services.Cli.Lobby.Handlers
 {
-    internal static class RequestBodyHandler
+    static class RequestBodyHandler
     {
         internal static string GetRequestBodyFromFileOrInput(string? input, bool isRequired = false)
         {
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Inputs/LobbyInput.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Inputs/LobbyInput.cs
index 79d5fe1..5108b17 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Inputs/LobbyInput.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Inputs/LobbyInput.cs
@@ -12,7 +12,7 @@ public class LobbyBodyInput : CommonInput
     {
         /* Optional request body as file input or raw string. */
         private protected const string k_JsonBodyDescription = "If this is a file path, the content of the file is used; otherwise, the raw string is used.";
-        private const string k_DefaultJsonBody = "{}";
+        const string k_DefaultJsonBody = "{}";
 
         public static readonly Option<string> JsonFileOrBodyOption = new(
             aliases: new[] { "-b", "--body" },
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/LobbyModule.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/LobbyModule.cs
index 8b3f1c9..ed3348f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby/LobbyModule.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/LobbyModule.cs
@@ -2,11 +2,16 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using System.CommandLine;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Authoring.Import.Input;
 using Unity.Services.Cli.Common;
+using Unity.Services.Cli.Common.Console;
 using Unity.Services.Cli.Common.Input;
 using Unity.Services.Cli.Common.Utils;
 using Unity.Services.Cli.Common.Validator;
 using Unity.Services.Cli.Lobby.Handlers;
+using Unity.Services.Cli.Lobby.Handlers.ImportExport;
 using Unity.Services.Cli.Lobby.Input;
 using Unity.Services.Cli.Lobby.Service;
 using Unity.Services.Cli.RemoteConfig.Service;
@@ -186,11 +191,42 @@ public LobbyModule()
             configUpdateCommand,
         };
 
+        var importCommand = new Command("import", "Import lobby configuration into an environment.")
+        {
+            ImportInput.InputDirectoryArgument,
+            ImportInput.FileNameArgument,
+            CommonInput.CloudProjectIdOption,
+            CommonInput.EnvironmentNameOption,
+            ImportInput.DryRunOption,
+            ImportInput.ReconcileOption,
+        };
+        importCommand.SetHandler<
+            ImportInput,
+            LobbyImporter,
+            ILoadingIndicator,
+            CancellationToken>(
+            ImportHandler.ImportAsync);
+
+        var exportCommand = new Command("export", "Export lobby configuration from an environment.")
+        {
+            ExportInput.OutputDirectoryArgument,
+            ExportInput.FileNameArgument,
+            CommonInput.CloudProjectIdOption,
+            CommonInput.EnvironmentNameOption,
+            ExportInput.DryRunOption,
+        };
+        exportCommand.SetHandler<
+            ExportInput,
+            LobbyExporter,
+            ILoadingIndicator,
+            CancellationToken>(ExportHandler.ExportAsync);
+
+
+
         /* Root Command */
         ModuleRootCommand = new("lobby", "Interact with the Lobby service.")
         {
             bulkUpdateLobbyCommand,
-            configCommand,
             createLobbyCommand,
             deleteLobbyCommand,
             getHostedLobbiesCommand,
@@ -204,6 +240,9 @@ public LobbyModule()
             reconnectCommand,
             requestTokenCommand,
             updateLobbyCommand,
+            configCommand,
+            importCommand,
+            exportCommand,
         };
     }
 
@@ -216,5 +255,7 @@ public static void RegisterServices(HostBuilderContext hostBuilderContext, IServ
         var authenticationService = serviceProvider.GetRequiredService<IServiceAccountAuthenticationService>();
         var validator = new ConfigurationValidator();
         serviceCollection.AddSingleton<ILobbyService>(new LobbyService(validator, authenticationService, null, null));
+        serviceCollection.AddTransient<LobbyImporter, LobbyImporter>();
+        serviceCollection.AddTransient<LobbyExporter, LobbyExporter>();
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Service/LobbyService.cs b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Service/LobbyService.cs
index 5bd087a..5fe3fb6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Service/LobbyService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Service/LobbyService.cs
@@ -18,23 +18,23 @@ class LobbyService : ILobbyService
     /// <summary>
     /// The config validator used to validate project and environment IDs.
     /// </summary>
-    private readonly IConfigurationValidator m_ConfigValidator;
+    readonly IConfigurationValidator m_ConfigValidator;
 
     /// <summary>
     /// The authentication service used to load the user's token.
     /// </summary>
-    private readonly IServiceAccountAuthenticationService m_AuthenticationService;
+    readonly IServiceAccountAuthenticationService m_AuthenticationService;
 
     /// <summary>
     /// The service account token received from the token exchange API.
     /// </summary>
-    private string? m_serviceToken;
+    string? m_serviceToken;
 
     /// <summary>
     /// The auto-generated Lobby client used for making Lobby API requests.
     /// </summary>
-    private ILobbyApiAsync? m_LobbyApi;
-    private ILobbyApiAsync LobbyClient
+    ILobbyApiAsync? m_LobbyApi;
+    ILobbyApiAsync LobbyClient
     {
         get
         {
@@ -55,8 +55,8 @@ private ILobbyApiAsync LobbyClient
     /// <summary>
     /// The auto-generated Auth client used for making requests to the token-exchange endpoint.
     /// </summary>
-    private IAuthApiAsync? m_AuthApi;
-    private IAuthApiAsync AuthClient
+    IAuthApiAsync? m_AuthApi;
+    IAuthApiAsync AuthClient
     {
         get
         {
@@ -352,7 +352,7 @@ public async Task<IDictionary<string, TokenData>> RequestTokenAsync(string? proj
     /// <param name="projectId">The project ID being used for the Lobby request.</param>
     /// <param name="environmentId">The environment ID being used for the Lobby request.</param>
     /// <param name="serviceId">The service ID being used for the Lobby request.</param>
-    private void ValidateRequestIds(string? projectId, string? environmentId, string? serviceId)
+    void ValidateRequestIds(string? projectId, string? environmentId, string? serviceId)
     {
         m_ConfigValidator.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, projectId ?? "");
         m_ConfigValidator.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.EnvironmentId, environmentId ?? "");
@@ -368,7 +368,7 @@ private void ValidateRequestIds(string? projectId, string? environmentId, string
     /// <param name="projectId">The project ID to use in the token exchange.</param>
     /// <param name="environmentId">The environment ID to use in the token exchange.</param>
     /// <param name="cancellationToken">Token used to cancel the task.</param>
-    private async Task SetServiceAccountToken(string projectId, string environmentId, CancellationToken cancellationToken)
+    async Task SetServiceAccountToken(string projectId, string environmentId, CancellationToken cancellationToken)
     {
         if (AuthClient.Configuration is null)
         {
@@ -391,7 +391,7 @@ private async Task SetServiceAccountToken(string projectId, string environmentId
     /// Helper function to get the user's current authentication token.
     /// </summary>
     /// <param name="cancellationToken">Token used to cancel the task.</param>
-    private async Task<string> GetToken(CancellationToken cancellationToken)
+    async Task<string> GetToken(CancellationToken cancellationToken)
     {
         try
         {
@@ -406,7 +406,7 @@ private async Task<string> GetToken(CancellationToken cancellationToken)
     /// <summary>
     /// Helper function to wrap JSON deserialization in order to throw a <see cref="CliException"/> for errors.
     /// </summary>
-    private static T? DeserializeOrThrow<T>(string value)
+    static T? DeserializeOrThrow<T>(string value)
     {
         try
         {
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Unity.Services.Cli.Lobby.csproj b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Unity.Services.Cli.Lobby.csproj
index dd8fad9..28ac3f3 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Lobby/Unity.Services.Cli.Lobby.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.Lobby/Unity.Services.Cli.Lobby.csproj
@@ -27,4 +27,7 @@
   <PropertyGroup>
     <DefineConstants Condition=" '$(ExtraDefineConstants)' != '' ">$(DefineConstants);$(ExtraDefineConstants)</DefineConstants>
   </PropertyGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Handlers\Config\lobby-config-schema.json" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/CreateHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/CreateHandlerTests.cs
index 92f1730..7477da5 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/CreateHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/CreateHandlerTests.cs
@@ -13,10 +13,10 @@ namespace Unity.Services.Cli.Player.UnitTest.Handlers;
 
 public class CreateHandlerTests
 {
-    private readonly Mock<IPlayerService>? m_MockPlayerService = new();
-    private readonly Mock<ILogger>? m_MockLogger = new();
-    private const string k_PlayerId = "player-id";
-    private const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
+    readonly Mock<IPlayerService>? m_MockPlayerService = new();
+    readonly Mock<ILogger>? m_MockLogger = new();
+    const string k_PlayerId = "player-id";
+    const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
 
     [SetUp]
     public void SetUp()
@@ -30,10 +30,10 @@ public async Task CreateAsync_CallsLoadingIndicator()
     {
         Mock<ILoadingIndicator> mockLoadingIndicator = new Mock<ILoadingIndicator>();
 
-        await CreateHandler.CreateAsync(null!,  null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
+        await CreateHandler.CreateAsync(null!, null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
 
         mockLoadingIndicator.Verify(ex => ex
-            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?,Task>>()), Times.Once);
+            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?, Task>>()), Times.Once);
     }
 
     [Test]
@@ -54,7 +54,7 @@ await CreateHandler.CreateAsync(
             CancellationToken.None
         );
 
-        m_MockPlayerService.Verify(s => s.CreateAsync(k_ProjectId,CancellationToken.None), Times.Once);
+        m_MockPlayerService.Verify(s => s.CreateAsync(k_ProjectId, CancellationToken.None), Times.Once);
         TestsHelper.VerifyLoggerWasCalled(m_MockLogger, LogLevel.Information, null, Times.Once, $"Player '{k_PlayerId}' created.");
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/DeleteHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/DeleteHandlerTests.cs
index 63310e8..ced9691 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/DeleteHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/DeleteHandlerTests.cs
@@ -13,10 +13,10 @@ namespace Unity.Services.Cli.Player.UnitTest.Handlers;
 
 public class DeleteHandlerTests
 {
-    private readonly Mock<IPlayerService>? m_MockPlayerService = new();
-    private readonly Mock<ILogger>? m_MockLogger = new();
-    private const string k_PlayerId = "player-id";
-    private const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
+    readonly Mock<IPlayerService>? m_MockPlayerService = new();
+    readonly Mock<ILogger>? m_MockLogger = new();
+    const string k_PlayerId = "player-id";
+    const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
 
     [SetUp]
     public void SetUp()
@@ -30,10 +30,10 @@ public async Task DeleteAsync_CallsLoadingIndicator()
     {
         Mock<ILoadingIndicator> mockLoadingIndicator = new Mock<ILoadingIndicator>();
 
-        await DeleteHandler.DeleteAsync(null!,  null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
+        await DeleteHandler.DeleteAsync(null!, null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
 
         mockLoadingIndicator.Verify(ex => ex
-            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?,Task>>()), Times.Once);
+            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?, Task>>()), Times.Once);
     }
 
     [Test]
@@ -55,7 +55,7 @@ await DeleteHandler.DeleteAsync(
             CancellationToken.None
         );
 
-        m_MockPlayerService.Verify(s => s.DeleteAsync(k_ProjectId,k_PlayerId,CancellationToken.None), Times.Once);
+        m_MockPlayerService.Verify(s => s.DeleteAsync(k_ProjectId, k_PlayerId, CancellationToken.None), Times.Once);
         TestsHelper.VerifyLoggerWasCalled(m_MockLogger, LogLevel.Information, null, Times.Once);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/DisableHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/DisableHandlerTests.cs
index 9f3c96f..26db99b 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/DisableHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/DisableHandlerTests.cs
@@ -12,10 +12,10 @@ namespace Unity.Services.Cli.Player.UnitTest.Handlers;
 
 public class DisableHandlerTests
 {
-    private readonly Mock<IPlayerService>? m_MockPlayerService = new();
-    private readonly Mock<ILogger>? m_MockLogger = new();
-    private const string k_PlayerId = "player-id";
-    private const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
+    readonly Mock<IPlayerService>? m_MockPlayerService = new();
+    readonly Mock<ILogger>? m_MockLogger = new();
+    const string k_PlayerId = "player-id";
+    const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
 
     [SetUp]
     public void SetUp()
@@ -29,10 +29,10 @@ public async Task DisableAsync_CallsLoadingIndicator()
     {
         Mock<ILoadingIndicator> mockLoadingIndicator = new Mock<ILoadingIndicator>();
 
-        await DisableHandler.DisableAsync(null!,  null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
+        await DisableHandler.DisableAsync(null!, null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
 
         mockLoadingIndicator.Verify(ex => ex
-            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?,Task>>()), Times.Once);
+            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?, Task>>()), Times.Once);
     }
 
     [Test]
@@ -54,7 +54,7 @@ await DisableHandler.DisableAsync(
             CancellationToken.None
         );
 
-        m_MockPlayerService.Verify(s => s.DisableAsync(k_ProjectId,k_PlayerId,CancellationToken.None), Times.Once);
+        m_MockPlayerService.Verify(s => s.DisableAsync(k_ProjectId, k_PlayerId, CancellationToken.None), Times.Once);
         TestsHelper.VerifyLoggerWasCalled(m_MockLogger, LogLevel.Information, null, Times.Once);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/EnableHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/EnableHandlerTests.cs
index a8432aa..6337d4d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/EnableHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/EnableHandlerTests.cs
@@ -12,10 +12,10 @@ namespace Unity.Services.Cli.Player.UnitTest.Handlers;
 
 public class EnableHandlerTests
 {
-    private readonly Mock<IPlayerService>? m_MockPlayerService = new();
-    private readonly Mock<ILogger>? m_MockLogger = new();
-    private const string k_PlayerId = "player-id";
-    private const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
+    readonly Mock<IPlayerService>? m_MockPlayerService = new();
+    readonly Mock<ILogger>? m_MockLogger = new();
+    const string k_PlayerId = "player-id";
+    const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
 
     [SetUp]
     public void SetUp()
@@ -29,10 +29,10 @@ public async Task EnableAsync_CallsLoadingIndicator()
     {
         Mock<ILoadingIndicator> mockLoadingIndicator = new Mock<ILoadingIndicator>();
 
-        await EnableHandler.EnableAsync(null!,  null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
+        await EnableHandler.EnableAsync(null!, null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
 
         mockLoadingIndicator.Verify(ex => ex
-            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?,Task>>()), Times.Once);
+            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?, Task>>()), Times.Once);
     }
 
     [Test]
@@ -54,7 +54,7 @@ await EnableHandler.EnableAsync(
             CancellationToken.None
         );
 
-        m_MockPlayerService.Verify(s => s.EnableAsync(k_ProjectId,k_PlayerId,CancellationToken.None), Times.Once);
+        m_MockPlayerService.Verify(s => s.EnableAsync(k_ProjectId, k_PlayerId, CancellationToken.None), Times.Once);
         TestsHelper.VerifyLoggerWasCalled(m_MockLogger, LogLevel.Information, null, Times.Once);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/GetHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/GetHandlerTests.cs
index 9542e56..a60c74a 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/GetHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/GetHandlerTests.cs
@@ -12,10 +12,10 @@ namespace Unity.Services.Cli.Player.UnitTest.Handlers;
 
 public class GetHandlerTests
 {
-    private readonly Mock<IPlayerService>? m_MockPlayerService = new();
-    private readonly Mock<ILogger>? m_MockLogger = new();
-    private const string k_PlayerId = "player-id";
-    private const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
+    readonly Mock<IPlayerService>? m_MockPlayerService = new();
+    readonly Mock<ILogger>? m_MockLogger = new();
+    const string k_PlayerId = "player-id";
+    const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
 
     [SetUp]
     public void SetUp()
@@ -29,10 +29,10 @@ public async Task GetAsync_CallsLoadingIndicator()
     {
         Mock<ILoadingIndicator> mockLoadingIndicator = new Mock<ILoadingIndicator>();
 
-        await GetHandler.GetAsync(null!,  null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
+        await GetHandler.GetAsync(null!, null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
 
         mockLoadingIndicator.Verify(ex => ex
-            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?,Task>>()), Times.Once);
+            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?, Task>>()), Times.Once);
     }
 
     [Test]
@@ -54,7 +54,7 @@ await GetHandler.GetAsync(
             CancellationToken.None
         );
 
-        m_MockPlayerService.Verify(s => s.GetAsync(k_ProjectId,k_PlayerId,CancellationToken.None), Times.Once);
+        m_MockPlayerService.Verify(s => s.GetAsync(k_ProjectId, k_PlayerId, CancellationToken.None), Times.Once);
         TestsHelper.VerifyLoggerWasCalled(m_MockLogger, LogLevel.Critical, null, Times.Once);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/ListHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/ListHandlerTests.cs
index d8c364f..eea15b2 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/ListHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Handlers/ListHandlerTests.cs
@@ -12,11 +12,11 @@ namespace Unity.Services.Cli.Player.UnitTest.Handlers;
 
 public class ListHandlerTests
 {
-    private readonly Mock<IPlayerService>? m_MockPlayerService = new();
-    private readonly Mock<ILogger>? m_MockLogger = new();
-    private const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
-    private const int k_Limit = 99;
-    private const string k_Page = "69y4J1gwcT45g23";
+    readonly Mock<IPlayerService>? m_MockPlayerService = new();
+    readonly Mock<ILogger>? m_MockLogger = new();
+    const string k_ProjectId = "abcd1234-ab12-cd34-ef56-abcdef123456";
+    const int k_Limit = 99;
+    const string k_Page = "69y4J1gwcT45g23";
 
     [SetUp]
     public void SetUp()
@@ -30,10 +30,10 @@ public async Task ListAsync_CallsLoadingIndicator()
     {
         Mock<ILoadingIndicator> mockLoadingIndicator = new Mock<ILoadingIndicator>();
 
-        await ListHandler.ListAsync(null!,  null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
+        await ListHandler.ListAsync(null!, null!, null!, mockLoadingIndicator.Object, CancellationToken.None);
 
         mockLoadingIndicator.Verify(ex => ex
-            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?,Task>>()), Times.Once);
+            .StartLoadingAsync(It.IsAny<string>(), It.IsAny<Func<StatusContext?, Task>>()), Times.Once);
     }
 
     [Test]
@@ -45,7 +45,7 @@ public async Task ListHandlerWithoutOption_Valid()
             CloudProjectId = k_ProjectId,
         };
 
-        m_MockPlayerService?.Setup(x => x.ListAsync(k_ProjectId, k_Limit,null,
+        m_MockPlayerService?.Setup(x => x.ListAsync(k_ProjectId, k_Limit, null,
             CancellationToken.None));
 
         await ListHandler.ListAsync(
@@ -69,7 +69,7 @@ public async Task ListHandlerWithOption_Valid()
             CloudProjectId = k_ProjectId,
         };
 
-        m_MockPlayerService?.Setup(x => x.ListAsync(k_ProjectId, k_Limit,k_Page,
+        m_MockPlayerService?.Setup(x => x.ListAsync(k_ProjectId, k_Limit, k_Page,
             CancellationToken.None));
 
         await ListHandler.ListAsync(
@@ -79,7 +79,7 @@ await ListHandler.ListAsync(
             CancellationToken.None
         );
 
-        m_MockPlayerService.Verify(s => s.ListAsync(k_ProjectId,k_Limit,k_Page, CancellationToken.None), Times.Once);
+        m_MockPlayerService.Verify(s => s.ListAsync(k_ProjectId, k_Limit, k_Page, CancellationToken.None), Times.Once);
         TestsHelper.VerifyLoggerWasCalled(m_MockLogger, LogLevel.Critical, null, Times.Once);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Service/PlayerServiceTests.cs b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Service/PlayerServiceTests.cs
index dd23962..eda3cb1 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Service/PlayerServiceTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Player.UnitTest/Service/PlayerServiceTests.cs
@@ -23,8 +23,8 @@ public class PlayerServiceTests
     const string k_InvalidPlayerId = "1nv4lid-pl4y3r-1d";
 
 
-    private readonly Mock<IPlayerAuthenticationAdminApiAsync> m_PlayerAdminApiAsync = new();
-    private readonly Mock<IDefaultApiAsync> m_PlayerAuthApiAsync = new();
+    readonly Mock<IPlayerAuthenticationAdminApiAsync> m_PlayerAdminApiAsync = new();
+    readonly Mock<IDefaultApiAsync> m_PlayerAuthApiAsync = new();
     readonly Mock<IConfigurationValidator> m_ValidatorObject = new();
     readonly Mock<IServiceAccountAuthenticationService> m_AuthenticationServiceObject = new();
 
@@ -83,7 +83,7 @@ public void DeletePlayer_NoProjectId()
             .Throws(new ConfigValidationException(Keys.ConfigKeys.ProjectId, k_InvalidProjectId, It.IsAny<string>()));
 
         Assert.ThrowsAsync<ConfigValidationException>(
-            () => m_PlayerService!.DeleteAsync(k_InvalidProjectId, k_ValidplayerId , CancellationToken.None));
+            () => m_PlayerService!.DeleteAsync(k_InvalidProjectId, k_ValidplayerId, CancellationToken.None));
 
         m_PlayerAdminApiAsync.Verify(
             a => a.DeletePlayerAsync(
@@ -101,7 +101,7 @@ public void DeletePlayer_NotFound()
             .Throws(new PlayerAdminApiException());
 
         Assert.ThrowsAsync<PlayerAdminApiException>(
-            () => m_PlayerService!.DeleteAsync(k_ValidProjectId, k_InvalidPlayerId , CancellationToken.None));
+            () => m_PlayerService!.DeleteAsync(k_ValidProjectId, k_InvalidPlayerId, CancellationToken.None));
     }
 
     [Test]
@@ -130,7 +130,7 @@ public void CreatePlayer_NoProjectId()
             .Throws(new ConfigValidationException(Keys.ConfigKeys.ProjectId, k_InvalidProjectId, It.IsAny<string>()));
 
         Assert.ThrowsAsync<ConfigValidationException>(
-            () => m_PlayerService!.CreateAsync(k_InvalidProjectId , CancellationToken.None));
+            () => m_PlayerService!.CreateAsync(k_InvalidProjectId, CancellationToken.None));
 
         m_PlayerAuthApiAsync.Verify(
             a => a.AnonymousSignupAsync(
@@ -169,7 +169,7 @@ public void EnablePlayer_NoProjectId()
             .Throws(new ConfigValidationException(Keys.ConfigKeys.ProjectId, k_InvalidProjectId, It.IsAny<string>()));
 
         Assert.ThrowsAsync<ConfigValidationException>(
-            () => m_PlayerService!.EnableAsync(k_InvalidProjectId, k_ValidplayerId , CancellationToken.None));
+            () => m_PlayerService!.EnableAsync(k_InvalidProjectId, k_ValidplayerId, CancellationToken.None));
 
         m_PlayerAdminApiAsync.Verify(
             a => a.PlayerEnableAsync(
@@ -187,7 +187,7 @@ public void EnablePlayer_NotFound()
             .Throws(new PlayerAdminApiException());
 
         Assert.ThrowsAsync<PlayerAdminApiException>(
-            () => m_PlayerService!.EnableAsync(k_ValidProjectId, k_InvalidPlayerId , CancellationToken.None));
+            () => m_PlayerService!.EnableAsync(k_ValidProjectId, k_InvalidPlayerId, CancellationToken.None));
     }
 
     [Test]
@@ -216,7 +216,7 @@ public void DisablePlayer_NoProjectId()
             .Throws(new ConfigValidationException(Keys.ConfigKeys.ProjectId, k_InvalidProjectId, It.IsAny<string>()));
 
         Assert.ThrowsAsync<ConfigValidationException>(
-            () => m_PlayerService!.DisableAsync(k_InvalidProjectId, k_ValidplayerId , CancellationToken.None));
+            () => m_PlayerService!.DisableAsync(k_InvalidProjectId, k_ValidplayerId, CancellationToken.None));
 
         m_PlayerAdminApiAsync.Verify(
             a => a.PlayerDisableAsync(
@@ -234,7 +234,7 @@ public void DisablePlayer_NotFound()
             .Throws(new PlayerAdminApiException());
 
         Assert.ThrowsAsync<PlayerAdminApiException>(
-            () => m_PlayerService!.DisableAsync(k_ValidProjectId, k_InvalidPlayerId , CancellationToken.None));
+            () => m_PlayerService!.DisableAsync(k_ValidProjectId, k_InvalidPlayerId, CancellationToken.None));
     }
 
     [Test]
@@ -263,7 +263,7 @@ public void GetPlayer_NoProjectId()
             .Throws(new ConfigValidationException(Keys.ConfigKeys.ProjectId, k_InvalidProjectId, It.IsAny<string>()));
 
         Assert.ThrowsAsync<ConfigValidationException>(
-            () => m_PlayerService!.GetAsync(k_InvalidProjectId, k_ValidplayerId , CancellationToken.None));
+            () => m_PlayerService!.GetAsync(k_InvalidProjectId, k_ValidplayerId, CancellationToken.None));
 
         m_PlayerAdminApiAsync.Verify(
             a => a.GetPlayerAsync(
@@ -281,7 +281,7 @@ public void GetPlayer_NotFound()
             .ThrowsAsync(new PlayerAdminApiException());
 
         Assert.ThrowsAsync<PlayerAdminApiException>(
-            () => m_PlayerService!.GetAsync(k_ValidProjectId, k_InvalidPlayerId , CancellationToken.None));
+            () => m_PlayerService!.GetAsync(k_ValidProjectId, k_InvalidPlayerId, CancellationToken.None));
     }
 
     [Test]
diff --git a/Unity.Services.Cli/Unity.Services.Cli.Player/Service/PlayerService.cs b/Unity.Services.Cli/Unity.Services.Cli.Player/Service/PlayerService.cs
index ac713a2..b6257d0 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.Player/Service/PlayerService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.Player/Service/PlayerService.cs
@@ -11,10 +11,10 @@ namespace Unity.Services.Cli.Player.Service;
 
 class PlayerService : IPlayerService
 {
-    private readonly IPlayerAuthenticationAdminApiAsync m_PlayerAdminApiAsync;
-    private readonly IDefaultApiAsync m_PlayerAuthApiAsync;
-    private readonly IServiceAccountAuthenticationService m_ServiceAccountService;
-    private readonly IConfigurationValidator m_ConfigValidator;
+    readonly IPlayerAuthenticationAdminApiAsync m_PlayerAdminApiAsync;
+    readonly IDefaultApiAsync m_PlayerAuthApiAsync;
+    readonly IServiceAccountAuthenticationService m_ServiceAccountService;
+    readonly IConfigurationValidator m_ConfigValidator;
     public PlayerService(IPlayerAuthenticationAdminApiAsync playerAdminApiAsync, IDefaultApiAsync authApiAsync, IConfigurationValidator validator, IServiceAccountAuthenticationService authenticationService)
     {
         m_ConfigValidator = validator;
@@ -48,7 +48,7 @@ public async Task<PlayerAuthAuthenticationResponse> CreateAsync(string projectId
         await AuthorizeAuthServiceAsync(cancellationToken);
         m_ConfigValidator.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, projectId);
         var req = new PlayerAuthAnonymousSignupRequestBody();
-        return await m_PlayerAuthApiAsync.AnonymousSignupAsync(projectId, req ,cancellationToken: cancellationToken);
+        return await m_PlayerAuthApiAsync.AnonymousSignupAsync(projectId, req, cancellationToken: cancellationToken);
     }
 
     public async Task<PlayerAuthPlayerProjectResponse> GetAsync(string projectId, string playerId, CancellationToken cancellationToken = default)
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/CliRemoteConfigDeploymentHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/CliRemoteConfigDeploymentHandlerTests.cs
index 1cd11f9..80cc36e 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/CliRemoteConfigDeploymentHandlerTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/CliRemoteConfigDeploymentHandlerTests.cs
@@ -1,14 +1,14 @@
-using System.IO.Abstractions;
 using Moq;
 using NUnit.Framework;
-using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.RemoteConfig.Deploy;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.ErrorHandling;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Formatting;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Json;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
-using Unity.Services.RemoteConfig.Editor.Authoring.Core.Networking;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Service;
 using IFileSystem = Unity.Services.RemoteConfig.Editor.Authoring.Core.IO.IFileSystem;
+using RemoteConfigFile = Unity.Services.Cli.RemoteConfig.Deploy.RemoteConfigFile;
 
 namespace Unity.Services.Cli.RemoteConfig.UnitTest.Deploy;
 
@@ -25,11 +25,11 @@ public class CliRemoteConfigDeploymentHandlerTests
 
     class DeploymentHandlerForTest : CliRemoteConfigDeploymentHandler
     {
-        public new  void UpdateStatus(
+        public new void UpdateStatus(
             IRemoteConfigFile remoteConfigFile,
             string status,
             string detail,
-            StatusSeverityLevel severityLevel)
+            SeverityLevel severityLevel)
         {
             base.UpdateStatus(remoteConfigFile, status, detail, severityLevel);
         }
@@ -102,35 +102,55 @@ public Task Deploy_DoesNotThrow()
     }
 
     [Test]
-    public void UpdateStatus_UpdatesContentCorrectly()
+    public void Deploy_StatusMappingWorks()
     {
-        var fileName = "fileName";
-        var filePath = "filePath";
-
-        m_DeploymentHandlerForTest!.Contents.Add(new DeployContent(
-            fileName,
-            "Remote Config",
-            filePath,
-            0,
-            "initialStatus"
-            )
-        );
-        var expectedStatus = "test-status";
-        var expectedDetail = "test-detail";
-        var expectedProgress = 0.45f;
-        var file = new RemoteConfigFile(fileName, filePath);
-        m_DeploymentHandlerForTest.UpdateStatus(
-            file,
-            expectedStatus,
-            expectedDetail,
-            StatusSeverityLevel.Info
-            );
-        m_DeploymentHandlerForTest.UpdateProgress(file, expectedProgress);
+        var handler = m_DeploymentHandlerForTest!;
+        var rcFile = new RemoteConfigFile("rc.rc", "rc.rc")
+        {
+            Entries = new List<RemoteConfigEntry>()
+            {
+                new (){ Key = "float", Value = 1.0 },
+                new() { Key = "string", Value = "string" },
+            }
+        };
+
+        handler.UpdateStatus(rcFile, "Test", string.Empty, SeverityLevel.Error);
+        Assert.That(rcFile.Status.MessageSeverity, Is.EqualTo(SeverityLevel.Error));
+
+        handler.UpdateStatus(rcFile, "Test", string.Empty, SeverityLevel.Info);
+        Assert.That(rcFile.Status.MessageSeverity, Is.EqualTo(SeverityLevel.Info));
+
+        handler.UpdateStatus(rcFile, "Test", string.Empty, SeverityLevel.None);
+        Assert.That(rcFile.Status.MessageSeverity, Is.EqualTo(SeverityLevel.None));
+
+        handler.UpdateStatus(rcFile, "Test", string.Empty, SeverityLevel.Info);
+        Assert.That(rcFile.Status.MessageSeverity, Is.EqualTo(SeverityLevel.Info));
+
+        handler.UpdateStatus(rcFile, "Test", string.Empty, SeverityLevel.Success);
+        Assert.That(rcFile.Status.MessageSeverity, Is.EqualTo(SeverityLevel.Success));
+
+        handler.UpdateStatus(rcFile, "Test", string.Empty, SeverityLevel.Warning);
+        Assert.That(rcFile.Status.MessageSeverity, Is.EqualTo(SeverityLevel.Warning));
+    }
+
+    [Test]
+    public void Deploy_ProgressUpdateWorks()
+    {
+        var handler = m_DeploymentHandlerForTest!;
+        var rcFile = new RemoteConfigFile("rc.rc", "rc.rc")
+        {
+            Entries = new List<RemoteConfigEntry>()
+            {
+                new (){ Key = "float", Value = 1.0 },
+                new() { Key = "string", Value = "string" },
+            }
+        };
+
+        Assert.That(rcFile.Progress, Is.EqualTo(0));
 
+        var newProgress = 42f;
+        handler.UpdateProgress(rcFile, newProgress);
 
-        var content = m_DeploymentHandlerForTest.Contents.First();
-        Assert.That(content.Status, Is.EqualTo(expectedStatus));
-        Assert.That(content.Progress, Is.EqualTo(expectedProgress));
-        Assert.That(content.Detail, Is.EqualTo(expectedDetail));
+        Assert.That(rcFile.Progress, Is.EqualTo(newProgress));
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/DeployContentExtensionsTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/DeployContentExtensionsTests.cs
deleted file mode 100644
index dc9d8de..0000000
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/DeployContentExtensionsTests.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-using NUnit.Framework;
-using Unity.Services.Cli.Authoring.Model;
-using Unity.Services.Cli.RemoteConfig.Deploy;
-
-namespace Unity.Services.Cli.RemoteConfig.UnitTest.Deploy;
-
-public class DeployContentExtensionsTests
-{
-    [Test]
-    public void MergeUniqueDescriptions_IgnoresUniqueDescriptions()
-    {
-        var content = new List<DeployContent>
-        {
-            new ("a", "type", "path", detail: "detail A"),
-            new ("b", "type", "path", detail: "detail B")
-        };
-
-        Assert.That(content.GetUniqueDescriptions(), Has.Count.EqualTo(2));
-    }
-
-    [Test]
-    public void MergeUniqueDescriptions_MergesDuplicateDescriptions()
-    {
-        var content = new List<DeployContent>
-        {
-            new ("a", "type", "path", detail: "detail"),
-            new ("b", "type", "path", detail: "detail")
-        };
-
-        Assert.That(content.GetUniqueDescriptions(), Has.Count.EqualTo(1));
-    }
-}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/JsonConverterTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/JsonConverterTests.cs
index 5477aca..a786db6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/JsonConverterTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/JsonConverterTests.cs
@@ -12,6 +12,7 @@ class JsonConverterTests
         Name = "foo",
         Number = 1794806,
         Flag = true,
+        InnerJson = "{'a':'b'}"
     };
     readonly string m_ExpectedJson;
     readonly JsonConverter m_Converter = new();
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigClientTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigClientTests.cs
index 78a058e..ad05158 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigClientTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigClientTests.cs
@@ -1,14 +1,13 @@
 using Moq;
 using Newtonsoft.Json;
 using NUnit.Framework;
-using Spectre.Console.Rendering;
 using Unity.Services.Cli.Common.Exceptions;
 using Unity.Services.Cli.RemoteConfig.Deploy;
 using Unity.Services.Cli.RemoteConfig.Model;
 using Unity.Services.Cli.RemoteConfig.Service;
 using Unity.Services.Cli.RemoteConfig.Types;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
-using Unity.Services.RemoteConfig.Editor.Authoring.Core.Networking;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Service;
 
 namespace Unity.Services.Cli.RemoteConfig.UnitTest.Deploy;
 
@@ -21,7 +20,7 @@ class RemoteConfigClientTests
 
     static readonly Array k_ValueTypeCases = Enum.GetValues(typeof(Types.ValueType));
 
-    readonly Mock<IRemoteConfigService> m_MockRemoteConfigService = new ();
+    readonly Mock<IRemoteConfigService> m_MockRemoteConfigService = new();
     readonly GetResponse m_ResponseWithConfig = new();
 
     RemoteConfigClient? m_RemoteConfigClient;
@@ -159,7 +158,7 @@ public async Task GetsIntegerValue()
                     {'key':'k','type':'int','value':1}
                 ],
             'id':'',
-            'version':'8',
+            'version':'',
             'createdAt':'2022-10-26T17:57:32Z',
             'updatedAt':'2023-04-20T18:14:22Z'}]
         }";
@@ -189,7 +188,7 @@ public async Task GetsDoubleValue()
                     {'key':'k','type':'float','value':1}
                 ],
             'id':'',
-            'version':'8',
+            'version':'',
             'createdAt':'2022-10-26T17:57:32Z',
             'updatedAt':'2023-04-20T18:14:22Z'}]
         }";
@@ -207,6 +206,38 @@ public async Task GetsDoubleValue()
         Assert.That(result.Configs[0].Value.GetType(), Is.EqualTo(typeof(double)));
     }
 
+
+    [Test]
+    public async Task GetsInnerJsonValue()
+    {
+        var servStr = @"{
+            'configs':[ {
+                'projectId':'',
+                'environmentId':'',
+                'type':'settings',
+                'value':[
+                {'key':'k','type':'json','value':{ 'a':'b' }}
+                ],
+                'id':'',
+                'version':'',
+                'createdAt':'2022-10-26T17:57:32Z',
+                'updatedAt':'2023-04-20T18:14:22Z'}]
+        }";
+
+        m_MockRemoteConfigService
+            .Setup(rc =>
+                rc.GetAllConfigsFromEnvironmentAsync(
+                    k_TestProjectId,
+                    k_TestEnvironmentId,
+                    RemoteConfigClient.k_ConfigType,
+                    CancellationToken.None))
+            .ReturnsAsync(servStr);
+        var result = await m_RemoteConfigClient!.GetAsync();
+        Assert.That(result.Configs, Has.Count.EqualTo(1));
+        Assert.That(result.Configs[0].Value.GetType(), Is.EqualTo(typeof(Newtonsoft.Json.Linq.JObject)));
+    }
+
+
     [Test]
     public async Task UpdateAsyncSucceed()
     {
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigDeploymentServiceTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigDeploymentServiceTests.cs
index 83b7f4e..72276df 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigDeploymentServiceTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigDeploymentServiceTests.cs
@@ -7,10 +7,12 @@
 using Unity.Services.Cli.RemoteConfig.Deploy;
 using Unity.Services.Cli.RemoteConfig.Exceptions;
 using Unity.Services.Cli.RemoteConfig.Service;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Deployment;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.ErrorHandling;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Results;
+using RemoteConfigFile = Unity.Services.Cli.RemoteConfig.Deploy.RemoteConfigFile;
 
 namespace Unity.Services.Cli.RemoteConfig.UnitTest.Deploy;
 
@@ -28,7 +30,6 @@ public class RemoteConfigDeploymentServiceTests
     };
 
     readonly Mock<ICliRemoteConfigClient> m_MockCliRemoteConfigClient = new();
-    readonly Mock<ICliDeploymentOutputHandler> m_MockCliDeploymentOutputHandler = new();
     readonly Mock<IRemoteConfigScriptsLoader> m_MockRemoteConfigScriptsLoader = new();
     readonly Mock<IRemoteConfigDeploymentHandler> m_MockRemoteConfigDeploymentHandler = new();
 
@@ -43,24 +44,23 @@ public class RemoteConfigDeploymentServiceTests
         Reconcile = false
     };
 
-    static readonly IReadOnlyCollection<DeployContent> k_DeployedContents = new[]
+    static readonly IReadOnlyList<RemoteConfigFile> k_DeployedContents = new[]
     {
-        new DeployContent("script.rc", "Remote Config", "path", 100, "Published"),
+        new RemoteConfigFile("script.rc", "path"),
     };
 
-    static readonly IReadOnlyCollection<DeployContent> k_FailedContents = new[]
+    static readonly IReadOnlyList<RemoteConfigFile> k_FailedContents = new[]
     {
-        new DeployContent("invalid1.rc", "Remote Config", "path", 0, "Failed to Load", detail: "invalid1"),
-        new DeployContent("invalid2.rc", "Remote Config", "path", 0, "Failed to Load", detail: "invalid2"),
+        new RemoteConfigFile("invalid1.rc", "path"),
+        new RemoteConfigFile("invalid2.rc",  "path"),
     };
 
-    List<DeployContent> m_Contents = k_DeployedContents.Concat(k_FailedContents).ToList();
+
 
     [SetUp]
     public void SetUp()
     {
         m_MockCliRemoteConfigClient.Reset();
-        m_MockCliDeploymentOutputHandler.Reset();
         m_MockRemoteConfigScriptsLoader.Reset();
         m_MockRemoteConfigDeploymentHandler.Reset();
         k_MockRemoteConfigServicesWrapper.Reset();
@@ -68,20 +68,14 @@ public void SetUp()
 
         k_MockRemoteConfigServicesWrapper.Setup(x => x.RemoteConfigClient)
             .Returns(m_MockCliRemoteConfigClient.Object);
-        k_MockRemoteConfigServicesWrapper.Setup(x => x.DeploymentOutputHandler)
-            .Returns(m_MockCliDeploymentOutputHandler.Object);
-        m_MockCliDeploymentOutputHandler.Setup(x => x.Contents)
-            .Returns(new List<DeployContent>());
         k_MockRemoteConfigServicesWrapper.Setup(x => x.RemoteConfigScriptsLoader)
             .Returns(m_MockRemoteConfigScriptsLoader.Object);
         k_MockRemoteConfigServicesWrapper.Setup(x => x.DeploymentHandler)
             .Returns(m_MockRemoteConfigDeploymentHandler.Object);
 
-        m_MockCliDeploymentOutputHandler.SetupGet(c => c.Contents).Returns(m_Contents);
-
         m_MockRemoteConfigScriptsLoader.Setup(loader =>
-                loader.LoadScriptsAsync(It.IsAny<IReadOnlyList<string>>(), It.IsAny<ICollection<DeployContent>>()))
-            .Returns(Task.FromResult(new LoadResult(new List<IRemoteConfigFile>(), new List<DeployContent>())));
+                loader.LoadScriptsAsync(It.IsAny<IReadOnlyList<string>>(),  CancellationToken.None))
+            .Returns(Task.FromResult(new LoadResult(new List<RemoteConfigFile>(), new List<RemoteConfigFile>())));
         m_RemoteConfigDeploymentService = new (k_MockRemoteConfigServicesWrapper.Object);
 
         m_MockRemoteConfigDeploymentHandler.Setup(ex => ex
@@ -91,6 +85,10 @@ public void SetUp()
                 Array.Empty<RemoteConfigEntry>(),
                 Array.Empty<RemoteConfigEntry>()
             )));
+
+        k_DeployedContents[0].Progress = 100;
+        k_FailedContents[0].Status = new DeploymentStatus(Statuses.FailedToRead, "invalid1", SeverityLevel.Error);
+        k_FailedContents[1].Status = new DeploymentStatus(Statuses.FailedToRead, "invalid2", SeverityLevel.Error);
     }
 
     [Test]
@@ -159,7 +157,7 @@ await m_RemoteConfigDeploymentService.Deploy(
         m_MockRemoteConfigScriptsLoader.Verify(x =>
                 x.LoadScriptsAsync(
                     k_ValidFilePaths,
-                    k_MockRemoteConfigServicesWrapper.Object.DeploymentOutputHandler.Contents),
+                    CancellationToken.None),
             Times.Once);
     }
 
@@ -169,8 +167,8 @@ public async Task DeployAsync_CallsDeployAsyncCorrectly()
         var expectedRemoteConfigFiles = new List<RemoteConfigFile>();
 
         m_MockRemoteConfigScriptsLoader.Setup(d =>
-                d.LoadScriptsAsync(It.IsAny<IReadOnlyList<string>>(), It.IsAny<ICollection<DeployContent>>()))
-            .ReturnsAsync(new LoadResult(new List<IRemoteConfigFile>(), new List<DeployContent>()));
+                d.LoadScriptsAsync(It.IsAny<IReadOnlyList<string>>(),  CancellationToken.None))
+            .ReturnsAsync(new LoadResult(new List<RemoteConfigFile>(), new List<RemoteConfigFile>()));
 
         await m_RemoteConfigDeploymentService.Deploy(
             m_DefaultInput,
@@ -188,6 +186,11 @@ await m_RemoteConfigDeploymentService.Deploy(
     public async Task DeployAsync_CallsLogDeploymentResultCorrectly()
     {
         m_MockRemoteConfigDeploymentHandler.Reset();
+        m_MockRemoteConfigScriptsLoader
+            .Setup(l =>
+                    l.LoadScriptsAsync(It.IsAny<IReadOnlyList<string>>(), It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult(new LoadResult(k_DeployedContents, k_FailedContents)));
+
         var result = await m_RemoteConfigDeploymentService.Deploy(
             m_DefaultInput,
             k_ValidFilePaths,
@@ -203,8 +206,12 @@ public async Task DeployAsync_CallsLogDeploymentResultCorrectly()
     [Test]
     public async Task DeployAsync_RemoteEntriesHaveCorrectFilePath()
     {
-        m_MockRemoteConfigDeploymentHandler.Setup(ex => ex
-                .DeployAsync(It.IsAny<IReadOnlyList<IRemoteConfigFile>>(), It.IsAny<bool>(), It.IsAny<bool>()))
+        m_MockRemoteConfigDeploymentHandler
+            .Setup(ex =>
+                ex.DeployAsync(
+                    It.IsAny<IReadOnlyList<IRemoteConfigFile>>(),
+                    It.IsAny<bool>(),
+                    It.IsAny<bool>()))
             .Returns(Task.FromResult(new DeployResult(
                 Array.Empty<RemoteConfigEntry>(),
                 Array.Empty<RemoteConfigEntry>(),
@@ -232,19 +239,14 @@ public async Task DeployAsync_RemoteEntriesHaveCorrectFilePath()
     [Test]
     public async Task DeployAsync_EmptyRemoteFilesAreSkipped()
     {
-        m_MockRemoteConfigDeploymentHandler.Setup(ex => ex
+        m_MockRemoteConfigDeploymentHandler
+            .Setup(ex => ex
                 .DeployAsync(It.IsAny<IReadOnlyList<IRemoteConfigFile>>(), It.IsAny<bool>(), It.IsAny<bool>()))
             .Returns(Task.FromResult(new DeployResult(
                 Array.Empty<RemoteConfigEntry>(),
                 Array.Empty<RemoteConfigEntry>(),
                 Array.Empty<RemoteConfigEntry>(),
-                new[]
-                {
-                    new RemoteConfigFile("", "")
-                    {
-                        Entries = null!
-                    }
-                }
+                Array.Empty<RemoteConfigFile>()
             )));
 
         var result = await m_RemoteConfigDeploymentService.Deploy(
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigFetchServiceTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigFetchServiceTests.cs
index 093fda6..88227b0 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigFetchServiceTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigFetchServiceTests.cs
@@ -8,19 +8,21 @@
 using Unity.Services.Cli.Authoring.Service;
 using Unity.Services.Cli.RemoteConfig.Deploy;
 using Unity.Services.Cli.RemoteConfig.Service;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Deployment;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.ErrorHandling;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Fetch;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Results;
 using FetchResult = Unity.Services.RemoteConfig.Editor.Authoring.Core.Results.FetchResult;
+using RemoteConfigFile = Unity.Services.Cli.RemoteConfig.Deploy.RemoteConfigFile;
 
 namespace Unity.Services.Cli.RemoteConfig.UnitTest.Deploy;
 
 [TestFixture]
 public class RemoteConfigFetchServiceTests
 {
-    RemoteConfigFetchService? m_RemoteConfigDeploymentService;
+    RemoteConfigFetchService? m_RemoteConfigFetchService;
     const string k_ValidProjectId = "a912b1fd-541d-42e1-89f2-85436f27aabd";
     const string k_ValidEnvironmentId = "00000000-0000-0000-0000-000000000000";
     const string k_DeployFileExtension = ".rc";
@@ -31,7 +33,7 @@ public class RemoteConfigFetchServiceTests
         "test_b.rc"
     };
 
-    private List<IRemoteConfigFile> m_RemoteConfigFiles = new();
+    List<IRemoteConfigFile> m_RemoteConfigFiles = new();
 
     readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
     readonly Mock<ICliRemoteConfigClient> m_MockCliRemoteConfigClient = new();
@@ -48,7 +50,7 @@ public class RemoteConfigFetchServiceTests
         Reconcile = false
     };
 
-    private Result m_Result;
+    Result m_Result = null!;
 
     [SetUp]
     public void SetUp()
@@ -61,7 +63,7 @@ public void SetUp()
         m_MockRemoteConfigServicesWrapper.Reset();
         m_MockLogger.Reset();
 
-        m_RemoteConfigDeploymentService =
+        m_RemoteConfigFetchService =
             new RemoteConfigFetchService(
                 m_MockUnityEnvironment.Object,
                 m_MockRemoteConfigFetchHandler.Object,
@@ -126,55 +128,48 @@ public void SetUp()
                     CancellationToken.None))
             .Returns(Task.FromResult((FetchResult)m_Result));
 
-        m_MockRemoteConfigScriptsLoader.Setup(loader =>
-                loader.LoadScriptsAsync(It.IsAny<IReadOnlyList<string>>(), It.IsAny<ICollection<DeployContent>>()))
-            .Returns(Task.FromResult(new LoadResult(new List<IRemoteConfigFile>(), new List<DeployContent>())));
+        m_MockRemoteConfigScriptsLoader
+            .Setup(loader =>
+                loader.LoadScriptsAsync(It.IsAny<IReadOnlyList<string>>(), CancellationToken.None))
+            .Returns(Task.FromResult(new LoadResult(Array.Empty<RemoteConfigFile>(), Array.Empty<RemoteConfigFile>())));
     }
 
     [Test]
-    public void FetchAsync_MapsResultProperly()
+    public async Task FetchAsync_MapsResultProperly()
     {
-        var res = m_RemoteConfigDeploymentService!.FetchAsync(
+        var res = await m_RemoteConfigFetchService!.FetchAsync(
             m_DefaultInput,
             (StatusContext)null!,
             CancellationToken.None);
 
         Assert.Multiple(() =>
         {
-            Assert.That(res.Result.Deleted, Has.Count.EqualTo(1));
-            Assert.That(res.Result.Updated, Has.Count.EqualTo(1));
-            Assert.That(res.Result.Created, Has.Count.EqualTo(1));
+            Assert.That(res.Deleted, Has.Count.EqualTo(1));
+            Assert.That(res.Updated, Has.Count.EqualTo(1));
+            Assert.That(res.Created, Has.Count.EqualTo(1));
         });
     }
 
     [Test]
-    public void FetchAsync_FormatsKeyFilePair()
+    public async Task FetchAsync_FailedToLoadIsForwarded()
     {
-        var res = m_RemoteConfigDeploymentService!.FetchAsync(
+        var failedRcFileName = "failed.rc";
+        m_MockRemoteConfigScriptsLoader
+            .Setup(loader =>
+                loader.LoadScriptsAsync(It.IsAny<IReadOnlyList<string>>(), CancellationToken.None))
+            .Returns(Task.FromResult(
+                new LoadResult(Array.Empty<RemoteConfigFile>(),
+                    new []{ new RemoteConfigFile(failedRcFileName, failedRcFileName)
+                    {
+                        Status = new DeploymentStatus(Statuses.FailedToRead, string.Empty, SeverityLevel.Error)
+                    }})));
+
+        var res = await m_RemoteConfigFetchService!.FetchAsync(
             m_DefaultInput,
             (StatusContext)null!,
             CancellationToken.None);
 
-        var deletedKeyStr = string.Format(
-            m_RemoteConfigDeploymentService.m_KeyFileMessageFormat,
-            m_Result.Deleted[0].Key,
-            m_Result.Deleted[0].File.Path);
-
-        var updatedKeyStr = string.Format(
-            m_RemoteConfigDeploymentService.m_KeyFileMessageFormat,
-            m_Result.Updated[0].Key,
-            m_Result.Updated[0].File.Path);
-
-        var createddKeyStr = string.Format(
-            m_RemoteConfigDeploymentService.m_KeyFileMessageFormat,
-            m_Result.Created[0].Key,
-            m_Result.Created[0].File.Path);
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(res.Result.Deleted[0], Is.EqualTo(deletedKeyStr));
-            Assert.That(res.Result.Updated[0], Is.EqualTo(updatedKeyStr));
-            Assert.That(res.Result.Created[0], Is.EqualTo(createddKeyStr));
-        });
+        Assert.That(res.Failed, Has.Count.EqualTo(1));
+        Assert.That(res.Failed[0].Name, Is.EqualTo(failedRcFileName));
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigScriptsLoaderTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigScriptsLoaderTests.cs
index 527dc59..2b4fcad 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigScriptsLoaderTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/RemoteConfigScriptsLoaderTests.cs
@@ -1,3 +1,5 @@
+using System.IO.Abstractions;
+using Moq;
 using NUnit.Framework;
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.RemoteConfig.Deploy;
@@ -7,27 +9,35 @@ namespace Unity.Services.Cli.RemoteConfig.UnitTest.Deploy;
 [TestFixture]
 public class RemoteConfigScriptsLoaderTests
 {
-    const string k_ValidTempFilePath = @".\validTestTemp.rc";
+    const string k_ValidTempFilePath = "validTestTemp.rc";
     const string k_ValidFileContent = "{\"id\":{\"type\":\"string\"},\"entries\":{\"type\":\"string\",\"description\":\"Values to store\"}}";
 
-    const string k_InvalidTempFilePath = @".\invalidTestTemp.rc";
+    const string k_InvalidTempFilePath = "invalidTestTemp.rc";
     const string k_InvalidFileContent = "{\"description\":\"Values to store\"}}";
 
-    RemoteConfigScriptsLoader m_RemoteConfigScriptsLoader = new();
+    const string k_EmptyTempFilePath = "emptyTemp.rc";
+    const string k_EmptyFileContent = "";
+
+    static readonly Mock<IFile> k_File = new ();
+    static readonly Mock<IPath> k_Path = new ();
+
+    RemoteConfigScriptsLoader m_RemoteConfigScriptsLoader = new(k_File.Object, k_Path.Object);
 
     [SetUp]
-    public async Task SetUp()
+    public void SetUp()
     {
-        if (File.Exists(k_ValidTempFilePath))
-        {
-            File.Delete(k_ValidTempFilePath);
-        }
-        if (File.Exists(k_InvalidTempFilePath))
-        {
-            File.Delete(k_InvalidTempFilePath);
-        }
-        await File.WriteAllTextAsync(k_ValidTempFilePath, k_ValidFileContent);
-        await File.WriteAllTextAsync(k_InvalidTempFilePath, k_InvalidFileContent);
+        k_File.Reset();
+        k_File.Setup(f => f.ReadAllTextAsync(k_ValidTempFilePath, CancellationToken.None))
+            .ReturnsAsync(k_ValidFileContent);
+        k_File.Setup(f => f.ReadAllTextAsync(k_InvalidTempFilePath, CancellationToken.None))
+            .ReturnsAsync(k_InvalidFileContent);
+        k_File.Setup(f => f.ReadAllTextAsync(k_EmptyTempFilePath, CancellationToken.None))
+            .ReturnsAsync(k_EmptyFileContent);
+        k_Path.Reset();
+        k_Path.Setup(p => p.GetFileName(k_ValidTempFilePath)).Returns(k_ValidTempFilePath);
+        k_Path.Setup(p => p.GetFileName(k_InvalidTempFilePath)).Returns(k_InvalidTempFilePath);
+        k_Path.Setup(p => p.GetFileName(k_EmptyTempFilePath)).Returns(k_EmptyTempFilePath);
+
     }
 
     [TearDown]
@@ -44,8 +54,7 @@ public async Task LoadScriptsAsync_ReturnsCorrectRemoteConfigFiles()
         {
             k_ValidTempFilePath
         };
-        var deployContentList = new List<DeployContent>();
-        var loadResult = await m_RemoteConfigScriptsLoader.LoadScriptsAsync(filepaths, deployContentList);
+        var loadResult = await m_RemoteConfigScriptsLoader.LoadScriptsAsync(filepaths, CancellationToken.None);
         Assert.That(loadResult.Loaded.ToList(), Has.Count.EqualTo(1));
         Assert.That(loadResult.Failed.ToList(), Has.Count.EqualTo(0));
     }
@@ -57,22 +66,37 @@ public async Task LoadScriptsAsync_CorrectlyCreatesLoadedDeployContent()
         {
             k_ValidTempFilePath
         };
-        var deployContentList = new List<DeployContent>();
-        await m_RemoteConfigScriptsLoader.LoadScriptsAsync(filepaths, deployContentList);
 
-        Assert.That(deployContentList, Has.Count.EqualTo(1));
+        var res = await m_RemoteConfigScriptsLoader.LoadScriptsAsync(filepaths, CancellationToken.None);
+
+        Assert.That(res.Loaded, Has.Count.EqualTo(1));
     }
 
     [Test]
-    public async Task LoadScriptsAsync_CorrectlyCreatesFailedDeployContent()
+    public async Task LoadScriptsAsync_InvalidContentCreatesFailedDeployContent()
     {
         var filepaths = new List<string>
         {
             k_InvalidTempFilePath
         };
-        var deployContentList = new List<DeployContent>();
-        await m_RemoteConfigScriptsLoader.LoadScriptsAsync(filepaths, deployContentList);
+        var res = await m_RemoteConfigScriptsLoader.LoadScriptsAsync(filepaths, CancellationToken.None);
+
+        Assert.That(res.Failed, Has.Count.EqualTo(1));
+        StringAssert.Contains("Additional text encountered after finished reading JSON content: }. Path '', line 1, position 33.",res.Failed.First().Detail);
+    }
+
+    [Test]
+    public async Task LoadScriptsAsync_EmptyContentCreatesFailedDeployContent()
+    {
+        var filepaths = new List<string>
+        {
+            k_EmptyTempFilePath
+        };
+
+        var res = await m_RemoteConfigScriptsLoader.LoadScriptsAsync(filepaths, CancellationToken.None);
+
+        Assert.That(res.Failed, Has.Count.EqualTo(1));
+        StringAssert.Contains($"{k_EmptyTempFilePath} is not a valid resource",res.Failed.First().Detail);
 
-        Assert.That(deployContentList, Has.Count.EqualTo(1));
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/TestData.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/TestData.cs
index 9cb478d..bf846e8 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/TestData.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Deploy/TestData.cs
@@ -9,6 +9,8 @@ class TestData : IEquatable<TestData>
 
     public bool Flag;
 
+    public string InnerJson = "{}";
+
     public bool Equals(TestData? other)
     {
         if (ReferenceEquals(null, other))
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/ImportExport/ExportHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/ImportExport/ExportHandlerTests.cs
new file mode 100644
index 0000000..059a5b6
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/ImportExport/ExportHandlerTests.cs
@@ -0,0 +1,169 @@
+using System.IO.Abstractions;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Spectre.Console;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.RemoteConfig.Deploy;
+using Unity.Services.Cli.RemoteConfig.Handlers.ExportImport;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Service;
+
+namespace Unity.Services.Cli.RemoteConfig.UnitTest.ImportExport;
+
+
+[TestFixture]
+class ExportHandlerTests
+{
+    const string TestEnvironment = "00000000-0000-0000-0000-000000000000";
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<ICliRemoteConfigClient> m_MockRemoteConfigClient = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IZipArchiver> m_MockArchiver = new();
+    readonly Mock<IFileSystem> m_FileSystemMock = new();
+    readonly Mock<ILoadingIndicator> m_MockLoadingIndicator = new();
+
+    RemoteConfigExporter m_RemoteConfigExporter = null!;
+
+    readonly List<RemoteConfigEntryDTO> m_LocalEntries = new()
+    {
+        new RemoteConfigEntryDTO { key = "local", value = true, type = "bool"}
+    };
+
+    ExportInput m_ExportInput = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_MockUnityEnvironment.Reset();
+        m_MockRemoteConfigClient.Reset();
+        m_MockLogger.Reset();
+        m_FileSystemMock.Reset();
+
+        m_MockUnityEnvironment
+            .Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestEnvironment);
+
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<RemoteConfigEntryDTO>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult((IEnumerable<RemoteConfigEntryDTO>)m_LocalEntries));
+
+        m_RemoteConfigExporter = new RemoteConfigExporter(
+            m_MockRemoteConfigClient.Object,
+            m_MockArchiver.Object,
+            m_MockUnityEnvironment.Object,
+            m_FileSystemMock.Object,
+            m_MockLogger.Object);
+
+        m_ExportInput = new ExportInput()
+        {
+            OutputDirectory = "dir",
+            FileName = "filename.rczip",
+            DryRun = true
+        };
+    }
+
+    [Test]
+    public async Task ExportAsync_CallsLoadingIndicator()
+    {
+        await ExportHandler.ExportAsync(
+            m_ExportInput,
+            m_RemoteConfigExporter,
+            m_MockLoadingIndicator.Object,
+            CancellationToken.None
+        );
+
+        m_MockLoadingIndicator
+            .Verify(li => li.StartLoadingAsync(
+                ExportHandler.LoadingIndicatorMessage,
+            It.IsAny<Func<StatusContext?, Task>>()));
+    }
+
+    [Test]
+    public async Task ExportAsync_Zips()
+    {
+        m_ExportInput.DryRun = false;
+
+        var remoteEntries = new List<RemoteConfigEntry>()
+        {
+            new () { Key = "remote", Value = true}
+        };
+
+        m_MockRemoteConfigClient
+            .Setup(c => c.GetAsync())
+            .Returns(Task.FromResult(new GetConfigsResult(true, remoteEntries)));
+
+        var archivePath = Path.Join(m_ExportInput.OutputDirectory, m_ExportInput.FileName);
+
+        m_FileSystemMock.Setup(
+            e => e
+                .Directory
+                .CreateDirectory(It.IsAny<string>()));
+        m_FileSystemMock.Setup(
+                e => e
+                    .Path
+                    .Join(It.IsAny<string?>(), It.IsAny<string?>()))
+            .Returns(archivePath);
+        m_FileSystemMock.Setup(
+                e => e
+                    .File
+                    .Exists(It.IsAny<string>()))
+            .Returns<string>((path) => false);
+
+        await m_RemoteConfigExporter.ExportAsync(m_ExportInput, CancellationToken.None);
+
+        m_MockArchiver.Verify(za => za.ZipAsync<RemoteConfigEntryDTO>(
+            archivePath,
+            RemoteConfigConstants.EntryName,
+            It.IsAny<IEnumerable<RemoteConfigEntryDTO>>(),
+            It.IsAny<CancellationToken>()));
+    }
+
+    [Test]
+    public void ExportAsync_FailsWithInvalidExtension()
+    {
+        var fileName = "other.zip";
+
+        m_ExportInput.FileName = fileName;
+
+        var exception = Assert.ThrowsAsync<CliException>(async () =>
+        {
+            await m_RemoteConfigExporter.ExportAsync(m_ExportInput, CancellationToken.None);
+        });
+        Assert.That(exception!.Message, Is.EqualTo($"The file-name argument must have the extension '{Path.GetExtension(RemoteConfigConstants.ZipName)}'."));
+    }
+
+    [Test]
+    [TestCase(true, true, 1, 0, 0, Description = "DryRun still calls Get")]
+    [TestCase(false, false, 1, 0 , 0, Description = "Does not create if does not exist")]
+    [TestCase(false, true, 1, 0, 0, Description = "Does not update if does not exist")]
+    public async Task ExportAsync_ApiCalls(bool dryRun, bool exists, int getCalls, int updateCalls, int createCalls)
+    {
+        m_MockRemoteConfigClient
+            .Setup(c => c.GetAsync())
+            .Returns(Task.FromResult(new GetConfigsResult(exists, Array.Empty<RemoteConfigEntry>())));
+
+        await m_RemoteConfigExporter.ExportAsync(m_ExportInput, CancellationToken.None);
+
+        var getCallsTimes = getCalls == 0 ? Times.Never() : Times.Exactly(getCalls);
+        var updateCallsTimes = updateCalls == 0 ? Times.Never() : Times.Exactly(updateCalls);
+        var createCallsTimes = createCalls == 0 ? Times.Never() : Times.Exactly(createCalls);
+
+        m_MockRemoteConfigClient.Verify(
+            c => c.GetAsync(),
+            getCallsTimes);
+        m_MockRemoteConfigClient.Verify(
+            c => c.CreateAsync(It.IsAny<IReadOnlyList<RemoteConfigEntry>>()),
+            createCallsTimes);
+        m_MockRemoteConfigClient.Verify(
+            c => c.UpdateAsync(It.IsAny<IReadOnlyList<RemoteConfigEntry>>()),
+            updateCallsTimes);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/ImportExport/ImportHandlerTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/ImportExport/ImportHandlerTests.cs
new file mode 100644
index 0000000..e67bfc6
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/ImportExport/ImportHandlerTests.cs
@@ -0,0 +1,192 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Spectre.Console;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Common.Exceptions;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.RemoteConfig.Deploy;
+using Unity.Services.Cli.RemoteConfig.Handlers.ExportImport;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Service;
+
+namespace Unity.Services.Cli.RemoteConfig.UnitTest.ImportExport;
+
+
+[TestFixture]
+class ImportHandlerTests
+{
+    const string TestEnvironment = "00000000-0000-0000-0000-000000000000";
+    readonly Mock<IUnityEnvironment> m_MockUnityEnvironment = new();
+    readonly Mock<ICliRemoteConfigClient> m_MockRemoteConfigClient = new();
+    readonly Mock<ILogger> m_MockLogger = new();
+    readonly Mock<IZipArchiver> m_MockArchiver = new();
+    readonly Mock<ILoadingIndicator> m_MockLoadingIndicator = new();
+
+    RemoteConfigImporter m_RemoteConfigImporter = null!;
+
+    readonly List<RemoteConfigEntryDTO> m_LocalEntries = new()
+    {
+        new RemoteConfigEntryDTO { key = "local", value = true, type = "bool"}
+    };
+
+    ImportInput m_ImportInput = new ()
+    {
+        InputDirectory = "mock_input_directory"
+    };
+
+
+    [SetUp]
+    public void SetUp()
+    {
+        m_MockUnityEnvironment.Reset();
+        m_MockRemoteConfigClient.Reset();
+        m_MockLogger.Reset();
+
+        m_MockUnityEnvironment
+            .Setup(x => x.FetchIdentifierAsync())
+            .ReturnsAsync(TestEnvironment);
+
+        m_MockArchiver.Setup(
+                za => za.UnzipAsync<RemoteConfigEntryDTO>(
+                    It.IsAny<string>(),
+                    It.IsAny<string>(),
+                    It.IsAny<CancellationToken>()))
+            .Returns(Task.FromResult((IEnumerable<RemoteConfigEntryDTO>)m_LocalEntries));
+
+        m_RemoteConfigImporter = new RemoteConfigImporter(
+            m_MockRemoteConfigClient.Object,
+            m_MockArchiver.Object,
+            m_MockUnityEnvironment.Object,
+            m_MockLogger.Object);
+
+        m_ImportInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory"
+        };
+    }
+
+    [Test]
+    public async Task ImportAsync_CallsLoadingIndicator()
+    {
+        var importInput = new ImportInput()
+        {
+            InputDirectory = "mock_input_directory"
+        };
+
+        await ImportHandler.ImportAsync(
+            importInput,
+            m_RemoteConfigImporter,
+            m_MockLoadingIndicator.Object,
+            CancellationToken.None
+        );
+
+        m_MockLoadingIndicator
+            .Verify(li => li.StartLoadingAsync(
+                ImportHandler.LoadingIndicatorMessage,
+            It.IsAny<Func<StatusContext?, Task>>()));
+    }
+
+    [Test]
+    public async Task ImportAsync_Unzips()
+    {
+        m_ImportInput.DryRun = true;
+
+        m_MockRemoteConfigClient
+            .Setup(c => c.GetAsync())
+            .Returns(Task.FromResult(new GetConfigsResult(true, Array.Empty<RemoteConfigEntry>())));
+
+        await m_RemoteConfigImporter.ImportAsync(m_ImportInput, CancellationToken.None);
+
+        var archivePath = Path.Join(m_ImportInput.InputDirectory, RemoteConfigConstants.ZipName);
+
+        m_MockArchiver.Verify(za => za.UnzipAsync<RemoteConfigEntryDTO>(
+            archivePath,
+            RemoteConfigConstants.EntryName,
+            It.IsAny<CancellationToken>()));
+    }
+
+    [Test]
+    [TestCase(true)]
+    [TestCase(false)]
+    public void ImportAsync_FailsWithInvalidExtension(bool dryRun)
+    {
+        var fileName = "other.zip";
+
+        m_ImportInput.FileName = fileName;
+        m_ImportInput.DryRun = dryRun;
+
+        var exception = Assert.ThrowsAsync<CliException>(async () =>
+        {
+            await m_RemoteConfigImporter.ImportAsync(m_ImportInput, CancellationToken.None);
+        });
+        Assert.That(exception!.Message, Is.EqualTo($"The file-name argument must have the extension '{Path.GetExtension(RemoteConfigConstants.ZipName)}'."));
+    }
+
+    [Test]
+    [TestCase(true, true, 1, 0, 0, Description = "DryRun does not create or update")]
+    [TestCase(false, false, 1, 0 , 1, Description = "Creates if it does not exist")]
+    [TestCase(false, true, 1, 1, 0, Description = "Updates if it exists")]
+    public async Task ImportAsync_ApiCalls(bool dryRun, bool exists, int getCalls, int updateCalls, int createCalls)
+    {
+        m_ImportInput.DryRun = dryRun;
+
+        m_MockRemoteConfigClient
+            .Setup(c => c.GetAsync())
+            .Returns(Task.FromResult(new GetConfigsResult(exists, Array.Empty<RemoteConfigEntry>())));
+
+        await m_RemoteConfigImporter.ImportAsync(m_ImportInput, CancellationToken.None);
+
+        var getCallsTimes = getCalls == 0 ? Times.Never() : Times.Exactly(getCalls);
+        var updateCallsTimes = updateCalls == 0 ? Times.Never() : Times.Exactly(updateCalls);
+        var createCallsTimes = createCalls == 0 ? Times.Never() : Times.Exactly(createCalls);
+
+        m_MockRemoteConfigClient.Verify(
+            c => c.GetAsync(),
+            getCallsTimes);
+        m_MockRemoteConfigClient.Verify(
+            c => c.CreateAsync(It.IsAny<IReadOnlyList<RemoteConfigEntry>>()),
+            createCallsTimes);
+        m_MockRemoteConfigClient.Verify(
+            c => c.UpdateAsync(It.IsAny<IReadOnlyList<RemoteConfigEntry>>()),
+            updateCallsTimes);
+    }
+
+    [Test]
+    public async Task Reconcile_Deletes()
+    {
+        m_ImportInput.Reconcile = true;
+
+        var remoteEntries = new List<RemoteConfigEntry>()
+        {
+            new () { Key = "remote", Value = true}
+        };
+
+        var sentEntries = new List<RemoteConfigEntry>();
+
+        m_MockRemoteConfigClient
+            .Setup(c => c.GetAsync())
+            .Returns(Task.FromResult(new GetConfigsResult(true, remoteEntries)));
+
+        m_MockRemoteConfigClient
+            .Setup(c => c.UpdateAsync(It.IsAny<IReadOnlyList<RemoteConfigEntry>>()))
+            .Callback(
+                new Action<IReadOnlyList<RemoteConfigEntry>>(list =>
+                {
+                    sentEntries.AddRange(list);
+                }));
+
+        await m_RemoteConfigImporter.ImportAsync(m_ImportInput, CancellationToken.None);
+
+        m_MockRemoteConfigClient.Verify(
+            c => c.UpdateAsync(It.IsAny<IReadOnlyList<RemoteConfigEntry>>()), Times.Once());
+
+        Assert.That(
+            sentEntries.SingleOrDefault(e => e.Key == m_LocalEntries[0].key && e.Value == m_LocalEntries[0].value),
+            Is.Not.EqualTo(null));
+        CollectionAssert.DoesNotContain(sentEntries, remoteEntries[0]);
+    }
+
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/RemoteConfigModuleTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/RemoteConfigModuleTests.cs
index a77b19e..805ce65 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/RemoteConfigModuleTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/RemoteConfigModuleTests.cs
@@ -32,6 +32,7 @@ public void ConfigureServicesRegistersExpectedServices(Type serviceType)
 
         Assert.That(services.FirstOrDefault(c => c.ServiceType == serviceType), Is.Not.Null);
     }
+
     [Test]
     public void RemoteConfigModule_HasNewFileCommand()
     {
@@ -43,4 +44,29 @@ public void RemoteConfigModule_HasNewFileCommand()
         TestsHelper.AssertContainsCommand(module.ModuleRootCommand!, newFileCommand.Name, out var resultCommand);
         Assert.That(resultCommand, Is.EqualTo(newFileCommand));
     }
+
+    [Test]
+    public void RemoteConfigModule_HasImportCommand()
+    {
+        var importCommand = new Command("import", "import environment")
+            .AddNewFileCommand<RemoteConfigTemplate>("Remote Config");
+
+        var module = new RemoteConfigModule();
+
+        TestsHelper.AssertContainsCommand(module.ModuleRootCommand!, importCommand.Name, out var resultCommand);
+        Assert.That(resultCommand, Is.EqualTo(importCommand));
+    }
+
+
+    [Test]
+    public void RemoteConfigModule_HasExportCommand()
+    {
+        var exportCommand = new Command("export", "export environment")
+            .AddNewFileCommand<RemoteConfigTemplate>("Remote Config");
+
+        var module = new RemoteConfigModule();
+
+        TestsHelper.AssertContainsCommand(module.ModuleRootCommand!, exportCommand.Name, out var resultCommand);
+        Assert.That(resultCommand, Is.EqualTo(exportCommand));
+    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Service/RemoteConfigServiceTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Service/RemoteConfigServiceTests.cs
index b76f218..4241161 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Service/RemoteConfigServiceTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Service/RemoteConfigServiceTests.cs
@@ -6,6 +6,9 @@
 using Unity.Services.Cli.Common.Validator;
 using Unity.Services.Cli.RemoteConfig.Types;
 using Unity.Services.Cli.ServiceAccountAuthentication;
+using Unity.Services.Cli.Common.Networking;
+using System.Reflection;
+using Unity.Services.Cli.RemoteConfig.Exceptions;
 
 namespace Unity.Services.Cli.RemoteConfig.UnitTest.Service;
 
@@ -18,7 +21,7 @@ class RemoteConfigServiceTests
     const string k_InvalidProjectId = "invalidProject";
     const string k_ConfigId = "97dfdc30-9bb8-46f2-89c5-7df39232e686";
     const string k_EmptyConfigId = "";
-    const string k_ConfigBody = @"{""type"": ""settings"",""value"": [{""key"": ""testConfig"", ""type"": ""int"", ""value"": 1}]}";
+    const string k_ConfigBody = @"{""type"": ""alt"",""value"": [{""key"": ""testConfig"", ""type"": ""int"", ""value"": 1}]}";
 
     Mock<IConfigurationValidator> m_ValidatorObject = new();
     Mock<IServiceAccountAuthenticationService> m_AuthenticationServiceObject = new();
@@ -27,9 +30,17 @@ class RemoteConfigServiceTests
     [SetUp]
     public void SetUp()
     {
+        EndpointHelper.InitializeNetworkTargetEndpoints(new[]
+        {
+            typeof(RemoteConfigEndpoints).GetTypeInfo(),
+            typeof(RemoteConfigInternalEndpoints).GetTypeInfo()
+        });
+
         m_AuthenticationServiceObject.Reset();
 
         m_ValidatorObject = new Mock<IConfigurationValidator>();
+        m_ValidatorObject.Setup(v => v.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, k_InvalidProjectId))
+            .Throws(new ConfigValidationException(Keys.ConfigKeys.ProjectId, k_InvalidProjectId, It.IsAny<string>()));
         m_AuthenticationServiceObject = new Mock<IServiceAccountAuthenticationService>();
         m_AuthenticationServiceObject.Setup(a => a.GetAccessTokenAsync(CancellationToken.None))
             .Returns(Task.FromResult(k_TestAccessToken));
@@ -42,59 +53,155 @@ public void SetUp()
     [Test]
     public void GetAllConfigsFromEnvironmentAsync_InvalidProjectIDThrowConfigValidationException()
     {
-        m_ValidatorObject.Setup(v => v.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, k_InvalidProjectId))
-            .Throws(new ConfigValidationException(Keys.ConfigKeys.ProjectId, k_InvalidProjectId, It.IsAny<string>()));
         Assert.ThrowsAsync<ConfigValidationException>(() =>
             m_RemoteConfigService!.GetAllConfigsFromEnvironmentAsync(k_InvalidProjectId, k_TestEnvironmentId, null, CancellationToken.None));
     }
 
     [Test]
-    public void GetAllConfigsFromEnvironmentAsync_CallsAuthorizeServiceAsync()
+    public async Task GetAllConfigsFromEnvironmentAsync_CallsAuthorizeServiceAsync()
     {
-        m_ValidatorObject.Setup(v => v.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, k_InvalidProjectId))
-            .Throws(new ConfigValidationException(Keys.ConfigKeys.ProjectId, k_InvalidProjectId, It.IsAny<string>()));
-        m_RemoteConfigService!.GetAllConfigsFromEnvironmentAsync(k_TestProjectId, k_TestEnvironmentId, null, CancellationToken.None);
+        try
+        {
+            await m_RemoteConfigService!.GetAllConfigsFromEnvironmentAsync(k_TestProjectId, k_TestEnvironmentId, null, CancellationToken.None);
+        }
+        catch (ApiException)
+        {
+            // These tests are not intending to test the actual APIs so these calls will fail because we don't
+            // have a valid token. We just want to make sure that the class is getting the token.
+        }
         m_AuthenticationServiceObject.Verify(x => x.GetAccessTokenAsync(It.IsAny<CancellationToken>()), Times.Once);
     }
 
     [Test]
     public void UpdateConfigAsync_InvalidProjectIDThrowConfigValidationException()
     {
-        m_ValidatorObject.Setup(v => v.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, k_InvalidProjectId))
-            .Throws(new ConfigValidationException(Keys.ConfigKeys.ProjectId, k_InvalidProjectId, It.IsAny<string>()));
         Assert.ThrowsAsync<ConfigValidationException>(() =>
             m_RemoteConfigService!.UpdateConfigAsync(k_InvalidProjectId, k_ConfigId, k_ConfigBody, CancellationToken.None));
     }
 
     [Test]
-    public void UpdateConfigAsync_InvalidConfigIDThrowConfigValidationException()
+    public void UpdateConfigAsync_InvalidConfigIDThrowArgumentException()
     {
         Assert.ThrowsAsync<ArgumentException>(() =>
             m_RemoteConfigService!.UpdateConfigAsync(k_TestProjectId, k_EmptyConfigId, k_ConfigBody, CancellationToken.None));
     }
 
     [Test]
-    public void UpdateConfigAsync_CallsAuthorizeServiceAsync()
+    public void UpdateConfigAsync_InvalidBodyThrowCliExceptionAsync()
     {
-        m_ValidatorObject.Setup(v => v.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, k_InvalidProjectId));
-        m_RemoteConfigService!.UpdateConfigAsync(k_TestProjectId, "configId", k_ConfigBody, CancellationToken.None);
+        Assert.ThrowsAsync<CliException>(() =>
+            m_RemoteConfigService!.UpdateConfigAsync(k_TestProjectId, "configId", "><> I'm a FISH! ><>", CancellationToken.None),
+            "Config request body contains invalid JSON");
+    }
+
+    [Test]
+    public void UpdateConfigAsync_NullJsonBodyThrowCliExceptionAsync()
+    {
+        Assert.ThrowsAsync<CliException>(() =>
+            m_RemoteConfigService!.UpdateConfigAsync(k_TestProjectId, "configId", "null", CancellationToken.None),
+            "Empty config request body");
+    }
+
+    [Test]
+    public void UpdateConfigAsync_BodyMissingTypeThrowCliExceptionAsync()
+    {
+        Assert.ThrowsAsync<CliException>(() =>
+            m_RemoteConfigService!.UpdateConfigAsync(k_TestProjectId, "configId", "{}", CancellationToken.None),
+            "Config request body is missing type");
+    }
+
+    [Test]
+    public async Task UpdateConfigAsync_CallsAuthorizeServiceAsync()
+    {
+        try
+        {
+            await m_RemoteConfigService!.UpdateConfigAsync(k_TestProjectId, "configId", k_ConfigBody, CancellationToken.None);
+        }
+        catch (ApiException)
+        {
+            // These tests are not intending to test the actual APIs so these calls will fail because we don't
+            // have a valid token. We just want to make sure that the class is getting the token.
+        }
         m_AuthenticationServiceObject.Verify(x => x.GetAccessTokenAsync(It.IsAny<CancellationToken>()), Times.Once);
     }
 
     [Test]
     public void CreateConfigAsync_InvalidProjectIDThrowConfigValidationException()
     {
-        m_ValidatorObject.Setup(v => v.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, k_InvalidProjectId))
-            .Throws(new ConfigValidationException(Keys.ConfigKeys.ProjectId, k_InvalidProjectId, It.IsAny<string>()));
         Assert.ThrowsAsync<ConfigValidationException>(() =>
             m_RemoteConfigService!.CreateConfigAsync(k_InvalidProjectId, k_TestEnvironmentId, "settings", new List<ConfigValue>(), CancellationToken.None));
     }
 
     [Test]
-    public void CreateConfigAsync_CallsAuthentication()
+    public async Task CreateConfigAsync_CallsAuthorizeServiceAsync()
+    {
+        try
+        {
+            await m_RemoteConfigService!.CreateConfigAsync(k_TestProjectId, k_TestEnvironmentId, "alt", new List<ConfigValue>(), CancellationToken.None);
+        }
+        catch (ApiException)
+        {
+            // These tests are not intending to test the actual APIs so these calls will fail because we don't
+            // have a valid token. We just want to make sure that the class is getting the token.
+        }
+        m_AuthenticationServiceObject.Verify(x => x.GetAccessTokenAsync(It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Test]
+    public void DeleteConfigAsync_InvalidProjectIDThrowConfigValidationException()
+    {
+        Assert.ThrowsAsync<ConfigValidationException>(() =>
+            m_RemoteConfigService!.DeleteConfigAsync(k_InvalidProjectId, k_ConfigId, "settings", CancellationToken.None));
+    }
+
+    [Test]
+    public void DeleteConfigAsync_InvalidConfigIDThrowArgumentException()
+    {
+        Assert.ThrowsAsync<ArgumentException>(() =>
+            m_RemoteConfigService!.DeleteConfigAsync(k_TestProjectId, k_EmptyConfigId, "settings", CancellationToken.None));
+    }
+
+    [Test]
+    public async Task DeleteConfigAsync_CallsAuthorizeServiceAsync()
+    {
+        try
+        {
+            await m_RemoteConfigService!.DeleteConfigAsync(k_TestProjectId, k_TestEnvironmentId, "alt", CancellationToken.None);
+        }
+        catch (ApiException)
+        {
+            // These tests are not intending to test the actual APIs so these calls will fail because we don't
+            // have a valid token. We just want to make sure that the class is getting the token.
+        }
+        m_AuthenticationServiceObject.Verify(x => x.GetAccessTokenAsync(It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Test]
+    public void ApplySchemaAsync_InvalidProjectIDThrowConfigValidationException()
+    {
+        Assert.ThrowsAsync<ConfigValidationException>(() =>
+            m_RemoteConfigService!.ApplySchemaAsync(k_InvalidProjectId, k_ConfigId, k_ConfigBody, CancellationToken.None));
+    }
+
+    [Test]
+    public void ApplySchemaAsync_InvalidConfigIDThrowArgumentException()
+    {
+        Assert.ThrowsAsync<ArgumentException>(() =>
+            m_RemoteConfigService!.ApplySchemaAsync(k_TestProjectId, k_EmptyConfigId, k_ConfigBody, CancellationToken.None));
+    }
+
+    [Test]
+    public async Task ApplySchemaAsync_CallsAuthorizeServiceAsync()
     {
-        m_ValidatorObject.Setup(v => v.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, k_InvalidProjectId));
-        m_RemoteConfigService!.CreateConfigAsync(k_TestProjectId, k_TestEnvironmentId, "settings", new List<ConfigValue>(), CancellationToken.None);
+        try
+        {
+            await m_RemoteConfigService!.ApplySchemaAsync(k_TestProjectId, "configId", k_ConfigBody, CancellationToken.None);
+        }
+        catch (ApiException)
+        {
+            // These tests are not intending to test the actual APIs so these calls will fail because we don't
+            // have a valid token. We just want to make sure that the class is getting the token.
+        }
         m_AuthenticationServiceObject.Verify(x => x.GetAccessTokenAsync(It.IsAny<CancellationToken>()), Times.Once);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Service/RemoteConfigServicesWrapperTests.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Service/RemoteConfigServicesWrapperTests.cs
index ffc3f0c..e682d29 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Service/RemoteConfigServicesWrapperTests.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig.UnitTest/Service/RemoteConfigServicesWrapperTests.cs
@@ -25,8 +25,6 @@ public void GetAllConfigsFromEnvironmentAsync_InvalidProjectIDThrowConfigValidat
         m_RemoteConfigServicesWrapper = new RemoteConfigServicesWrapper(
             m_DeploymentHandler.Object,
             m_RemoteConfigClient.Object,
-            m_DeploymentOutputHandler.Object,
-            m_DeployFileService.Object,
             m_RemoteConfigService.Object,
             m_RemoteConfigScriptsLoader.Object);
 
@@ -34,8 +32,6 @@ public void GetAllConfigsFromEnvironmentAsync_InvalidProjectIDThrowConfigValidat
         {
             Assert.That(m_RemoteConfigServicesWrapper.DeploymentHandler, Is.EqualTo(m_DeploymentHandler.Object));
             Assert.That(m_RemoteConfigServicesWrapper.RemoteConfigClient, Is.EqualTo(m_RemoteConfigClient.Object));
-            Assert.That(m_RemoteConfigServicesWrapper.DeploymentOutputHandler, Is.EqualTo(m_DeploymentOutputHandler.Object));
-            Assert.That(m_RemoteConfigServicesWrapper.DeployFileService, Is.EqualTo(m_DeployFileService.Object));
             Assert.That(m_RemoteConfigServicesWrapper.RemoteConfigService, Is.EqualTo(m_RemoteConfigService.Object));
             Assert.That(m_RemoteConfigServicesWrapper.RemoteConfigScriptsLoader, Is.EqualTo(m_RemoteConfigScriptsLoader.Object));
         });
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/CliRemoteConfigDeploymentHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/CliRemoteConfigDeploymentHandler.cs
index eceb9ba..73924ab 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/CliRemoteConfigDeploymentHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/CliRemoteConfigDeploymentHandler.cs
@@ -1,17 +1,15 @@
-using Unity.Services.Cli.Authoring.Model;
-using Unity.Services.Cli.Authoring.Service;
+using Unity.Services.DeploymentApi.Editor;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Deployment;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Formatting;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.IO;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Json;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
-using Unity.Services.RemoteConfig.Editor.Authoring.Core.Networking;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Service;
 
 namespace Unity.Services.Cli.RemoteConfig.Deploy;
 
-class CliRemoteConfigDeploymentHandler : RemoteConfigDeploymentHandler, ICliDeploymentOutputHandler
+class CliRemoteConfigDeploymentHandler : RemoteConfigDeploymentHandler
 {
-    public ICollection<DeployContent> Contents { get; } = new List<DeployContent>();
-
     public CliRemoteConfigDeploymentHandler(
         IRemoteConfigClient remoteConfigClient,
         IRemoteConfigParser remoteConfigParser,
@@ -24,17 +22,19 @@ public CliRemoteConfigDeploymentHandler(
     {
     }
 
-    protected override void UpdateStatus(IRemoteConfigFile remoteConfigFile, string status, string detail,
-        StatusSeverityLevel severityLevel)
+    protected override void UpdateStatus(
+        IRemoteConfigFile remoteConfigFile,
+        string status,
+        string detail,
+        SeverityLevel severityLevel)
     {
-        var content = Contents.First(c => string.Equals(remoteConfigFile.Path, c.Path));
-        content.Status = status;
-        content.Detail = detail;
+        var file = (RemoteConfigFile)remoteConfigFile;
+        file.Status = new DeploymentStatus(status, detail, severityLevel);
     }
 
     protected override void UpdateProgress(IRemoteConfigFile remoteConfigFile, float progress)
     {
-        var deployContent = Contents.First(c => string.Equals(c.Path, remoteConfigFile.Path));
-        deployContent.Progress = progress;
+        var file = (RemoteConfigFile)remoteConfigFile;
+        file.Progress = progress;
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/CliRemoteConfigFetchHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/CliRemoteConfigFetchHandler.cs
index 6688ee1..bef71ae 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/CliRemoteConfigFetchHandler.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/CliRemoteConfigFetchHandler.cs
@@ -2,7 +2,7 @@
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.IO;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Json;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
-using Unity.Services.RemoteConfig.Editor.Authoring.Core.Networking;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Service;
 
 namespace Unity.Services.Cli.RemoteConfig.Deploy;
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/DeployContentExtensions.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/DeployContentExtensions.cs
deleted file mode 100644
index b403edd..0000000
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/DeployContentExtensions.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-using Unity.Services.Cli.Authoring.Model;
-
-namespace Unity.Services.Cli.RemoteConfig.Deploy;
-
-public static class DeployContentExtensions
-{
-    public static ICollection<DeployContent> GetUniqueDescriptions(this ICollection<DeployContent> contents)
-    {
-        var merged = new Dictionary<string, DeployContent>();
-        foreach (var content in contents)
-        {
-            var key = content.Detail;
-            if (merged.ContainsKey(key))
-            {
-                var existing = merged[key];
-                merged[key] = new DeployContent($"{existing.Name}' '{content.Name}", existing.Type, existing.Path, existing.Progress, existing.Status, existing.Detail);
-            }
-            else
-            {
-                merged.Add(key, content);
-            }
-        }
-        return merged.Values;
-    }
-}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/ICliRemoteConfigClient.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/ICliRemoteConfigClient.cs
index cd67e80..bf1ecf4 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/ICliRemoteConfigClient.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/ICliRemoteConfigClient.cs
@@ -1,4 +1,4 @@
-using Unity.Services.RemoteConfig.Editor.Authoring.Core.Networking;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Service;
 
 namespace Unity.Services.Cli.RemoteConfig.Deploy;
 
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/IRemoteConfigScriptsLoader.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/IRemoteConfigScriptsLoader.cs
index 253f299..953d370 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/IRemoteConfigScriptsLoader.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/IRemoteConfigScriptsLoader.cs
@@ -7,5 +7,5 @@ interface IRemoteConfigScriptsLoader
 {
     Task<LoadResult> LoadScriptsAsync(
         IReadOnlyList<string> filePaths,
-        ICollection<DeployContent> deployContents);
+        CancellationToken token);
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/LoadResult.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/LoadResult.cs
index f2e97bf..9f9e2f6 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/LoadResult.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/LoadResult.cs
@@ -5,10 +5,10 @@ namespace Unity.Services.Cli.RemoteConfig.Deploy;
 
 class LoadResult
 {
-    public IEnumerable<IRemoteConfigFile> Loaded { get; }
-    public IEnumerable<DeployContent> Failed { get; }
+    public IReadOnlyList<RemoteConfigFile> Loaded { get; }
+    public IReadOnlyList<RemoteConfigFile> Failed { get; }
 
-    public LoadResult(IEnumerable<IRemoteConfigFile> loaded, IEnumerable<DeployContent> failed)
+    public LoadResult(IReadOnlyList<RemoteConfigFile> loaded, IReadOnlyList<RemoteConfigFile> failed)
     {
         Loaded = loaded;
         Failed = failed;
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigClient.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigClient.cs
index 8a69d1a..58c494d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigClient.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigClient.cs
@@ -5,7 +5,7 @@
 using Unity.Services.Cli.RemoteConfig.Service;
 using Unity.Services.Cli.RemoteConfig.Types;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
-using Unity.Services.RemoteConfig.Editor.Authoring.Core.Networking;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Service;
 using ValueType = Unity.Services.Cli.RemoteConfig.Types.ValueType;
 
 namespace Unity.Services.Cli.RemoteConfig.Deploy;
@@ -21,7 +21,7 @@ class RemoteConfigClient : ICliRemoteConfigClient
 
     readonly IRemoteConfigService m_Service;
 
-    static readonly JsonSerializerSettings k_JsonSerializerSettings = new ()
+    static readonly JsonSerializerSettings k_JsonSerializerSettings = new()
     {
         ContractResolver = new CamelCasePropertyNamesContractResolver()
     };
@@ -118,34 +118,7 @@ public static IReadOnlyList<RemoteConfigEntry> ToRemoteConfigEntry(IReadOnlyList
         {
             File = null,
             Key = dto.key,
-            Value = ToValue(dto.value, dto.type)
+            Value = RemoteConfigEntryDTO.ToValue(dto.value, dto.type)
         }).ToList();
     }
-
-    static object ToValue(
-        object val,
-        string type)
-    {
-        switch (type)
-        {
-            case "string":
-            case "json":
-            case "bool":
-            case "long":
-                return val;
-            case "int":
-                return (int)(long)val;
-            case "float":
-                if (val is double)
-                    return val;
-                //the second "cast" is a type-conversion not a type-cast
-                if (val is float f)
-                    return (double)f;
-                if (val is int i)
-                    return (double)i;
-                return (double)(long)val;
-        }
-
-        throw new NotSupportedException($"Type '{type}' is not supported, value: '{val}', value type: '{val.GetType().Name}' !");
-    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigDeploymentService.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigDeploymentService.cs
index 704ebf0..fc74c63 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigDeploymentService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigDeploymentService.cs
@@ -3,7 +3,9 @@
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.Authoring.Service;
 using Unity.Services.Cli.RemoteConfig.Exceptions;
+using Unity.Services.Cli.RemoteConfig.Model;
 using Unity.Services.Cli.RemoteConfig.Service;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Deployment;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.ErrorHandling;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
@@ -11,14 +13,14 @@
 
 namespace Unity.Services.Cli.RemoteConfig.Deploy;
 
-internal class RemoteConfigDeploymentService : IDeploymentService
+partial class RemoteConfigDeploymentService : IDeploymentService
 {
-    string m_ServiceType;
-    string m_DeployFileExtension;
-    IRemoteConfigDeploymentHandler m_DeploymentHandler;
-    ICliRemoteConfigClient m_RemoteConfigClient;
-    ICliDeploymentOutputHandler m_DeploymentOutputHandler;
-    IRemoteConfigScriptsLoader m_RemoteConfigScriptsLoader;
+    readonly string m_ServiceType;
+    readonly string m_ServiceName;
+    readonly string m_DeployFileExtension;
+    readonly IRemoteConfigDeploymentHandler m_DeploymentHandler;
+    readonly ICliRemoteConfigClient m_RemoteConfigClient;
+    readonly IRemoteConfigScriptsLoader m_RemoteConfigScriptsLoader;
 
     public RemoteConfigDeploymentService(
         IRemoteConfigServicesWrapper servicesWrapper
@@ -26,22 +28,29 @@ IRemoteConfigServicesWrapper servicesWrapper
     {
         m_DeploymentHandler = servicesWrapper.DeploymentHandler;
         m_RemoteConfigClient = servicesWrapper.RemoteConfigClient;
-        m_DeploymentOutputHandler = servicesWrapper.DeploymentOutputHandler;
         m_RemoteConfigScriptsLoader = servicesWrapper.RemoteConfigScriptsLoader;
         m_ServiceType = "Remote Config";
+        m_ServiceName = "remote-config";
         m_DeployFileExtension = ".rc";
     }
 
     string IDeploymentService.ServiceType => m_ServiceType;
 
+    string IDeploymentService.ServiceName => m_ServiceName;
+
     string IDeploymentService.DeployFileExtension => m_DeployFileExtension;
 
-    public async Task<DeploymentResult> Deploy(DeployInput deployInput, IReadOnlyList<string> filePaths, string projectId, string environmentId,
-        StatusContext? loadingContext, CancellationToken cancellationToken)
+    public async Task<DeploymentResult> Deploy(
+        DeployInput deployInput,
+        IReadOnlyList<string> filePaths,
+        string projectId,
+        string environmentId,
+        StatusContext? loadingContext,
+        CancellationToken cancellationToken)
     {
         DeployResult deploymentResult = null!;
         m_RemoteConfigClient.Initialize(projectId, environmentId, cancellationToken);
-        var loadResult = await m_RemoteConfigScriptsLoader.LoadScriptsAsync(filePaths, m_DeploymentOutputHandler.Contents);
+        var loadResult = await m_RemoteConfigScriptsLoader.LoadScriptsAsync(filePaths, cancellationToken);
         var configFiles = loadResult.Loaded.ToList();
         loadingContext?.Status($"Deploying {m_ServiceType} Files...");
 
@@ -61,22 +70,27 @@ public async Task<DeploymentResult> Deploy(DeployInput deployInput, IReadOnlyLis
             // Ignoring it because this exception should already be logged into the deployment content status
         }
 
-        if (deploymentResult == null || configFiles == null)
+        if (deploymentResult == null)
         {
-            return new DeploymentResult(m_DeploymentOutputHandler.Contents.GetUniqueDescriptions().ToList());
+            return new DeploymentResult(loadResult.Loaded.Concat(loadResult.Failed).ToList());
         }
 
-        var failed = ToDeployContents(deploymentResult.Failed).Concat(loadResult.Failed).ToList();
+        var failed = deploymentResult
+            .Failed
+            .Select(d => (RemoteConfigFile)d)
+            .UnionBy(loadResult.Failed, f => f.Path)
+            .ToList();
 
         return new DeploymentResult(
-            ToDeployContents(deploymentResult.Created),
-            ToDeployContents(deploymentResult.Updated),
-            ToDeployContents(deploymentResult.Deleted),
-            ToDeployContents(deploymentResult.Deployed, 100, "Deployed", "Deployed Successfully"),
-            failed);
+            ToDeployContents(deploymentResult.Updated, 100, "Updated"),
+            ToDeployContents(deploymentResult.Deleted, 100, "Deleted"),
+            ToDeployContents(deploymentResult.Created, 100, "Created"),
+            deploymentResult.Deployed.Select(d => (RemoteConfigFile)d).ToList(),
+            failed,
+            deployInput.DryRun);
     }
 
-    IReadOnlyCollection<DeployContent> ToDeployContents(
+    static IReadOnlyList<IDeploymentItem> ToDeployContents(
         IReadOnlyCollection<RemoteConfigEntry> entries,
         float progress = 0f,
         string status = "",
@@ -86,25 +100,8 @@ IReadOnlyCollection<DeployContent> ToDeployContents(
             .Select(entry =>
             {
                 var filePath = entry.File == null ? "Remote" : entry.File.Path;
-                return new DeployContent(entry.Key, "Remote Config", filePath, progress, status, detail);
+                return new CliRemoteConfigEntry(entry.Key, "RemoteConfig Entry", filePath, progress, status, detail);
             })
             .ToList();
     }
-
-    IReadOnlyCollection<DeployContent> ToDeployContents(
-        IReadOnlyList<IRemoteConfigFile> files,
-        float progress = 0f,
-        string status = "",
-        string detail = "")
-    {
-
-        var entries = files
-            .Where(file => file.Entries != null)
-            .SelectMany(file => file.Entries)
-            .ToList();
-
-        return entries
-            .Select(entry => new DeployContent(entry.Key, "Remote Config", entry.File.Path, progress, status, detail))
-            .ToList();
-    }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigFetchService.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigFetchService.cs
index 6444330..f29fd63 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigFetchService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigFetchService.cs
@@ -3,21 +3,23 @@
 using Unity.Services.Cli.Authoring.Input;
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.Authoring.Service;
+using Unity.Services.Cli.RemoteConfig.Model;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Fetch;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
 
 namespace Unity.Services.Cli.RemoteConfig.Deploy;
 
 class RemoteConfigFetchService : IFetchService
 {
-    private readonly IUnityEnvironment m_UnityEnvironment;
-    private readonly IRemoteConfigFetchHandler m_FetchHandler;
-    private readonly ICliRemoteConfigClient m_RemoteConfigClient;
-    private readonly IDeployFileService m_DeployFileService;
-    private readonly IRemoteConfigScriptsLoader m_RemoteConfigScriptsLoader;
-    private readonly string m_DeployFileExtension;
-
-    internal readonly string m_KeyFileMessageFormat = "Key '{0}' in file '{1}'";
+    readonly IUnityEnvironment m_UnityEnvironment;
+    readonly IRemoteConfigFetchHandler m_FetchHandler;
+    readonly ICliRemoteConfigClient m_RemoteConfigClient;
+    readonly IDeployFileService m_DeployFileService;
+    readonly IRemoteConfigScriptsLoader m_RemoteConfigScriptsLoader;
+    readonly string m_DeployFileExtension;
     public string ServiceType { get; }
+    public string ServiceName { get; }
 
     string IFetchService.FileExtension => m_DeployFileExtension;
 
@@ -35,6 +37,7 @@ IRemoteConfigScriptsLoader remoteConfigScriptsLoader
         m_DeployFileService = deployFileService;
         m_RemoteConfigScriptsLoader = remoteConfigScriptsLoader;
         ServiceType = "Remote Config";
+        ServiceName = "remote-config";
         m_DeployFileExtension = ".rc";
     }
 
@@ -47,31 +50,49 @@ public async Task<FetchResult> FetchAsync(
         m_RemoteConfigClient.Initialize(input.CloudProjectId!, environmentId, cancellationToken);
         var remoteConfigFiles = m_DeployFileService.ListFilesToDeploy(new[] {input.Path}, m_DeployFileExtension).ToList();
 
-        var contents = new List<DeployContent>();
         var loadResult = await m_RemoteConfigScriptsLoader
-            .LoadScriptsAsync(remoteConfigFiles, contents);
+            .LoadScriptsAsync(remoteConfigFiles, cancellationToken);
         var configFiles = loadResult.Loaded.ToList();
 
         loadingContext?.Status($"Fetching {ServiceType} Files...");
 
-        Services.RemoteConfig.Editor.Authoring.Core.Results.FetchResult fetchResult = await m_FetchHandler.FetchAsync(
+        var fetchResult = await m_FetchHandler.FetchAsync(
                 input.Path,
                 configFiles,
                 input.DryRun,
                 input.Reconcile,
                 cancellationToken);
 
+        var failed = fetchResult
+            .Failed
+            .Select(d => (RemoteConfigFile)d)
+            .UnionBy(loadResult.Failed, f => f.Path)
+            .ToList();
 
         return new FetchResult(
-            fetchResult.Updated.Select(kvp => string.Format(m_KeyFileMessageFormat, kvp.Key, NormalizePath(kvp.File.Path)) ).ToList(),
-            fetchResult.Deleted.Select(kvp => string.Format(m_KeyFileMessageFormat, kvp.Key, NormalizePath(kvp.File.Path)) ).ToList(),
-            fetchResult.Created.Select(kvp => string.Format(m_KeyFileMessageFormat, kvp.Key, NormalizePath(kvp.File.Path)) ).ToList(),
-            fetchResult.Fetched.Select(f => Path.GetRelativePath(".", f.Path) ).ToList(),
-            fetchResult.Failed.Select(f => Path.GetRelativePath(".", f.Path)).ToList());
+            fetchResult.Updated.Select(rce => GetDeployContent(rce, "Updated")).ToList(),
+            fetchResult.Deleted.Select(rce => GetDeployContent(rce, "Deleted")).ToList(),
+            fetchResult.Created.Select(rce => GetDeployContent(rce, "Updated")).ToList(),
+            fetchResult.Fetched.Select(ToFetchedFile).ToList(),
+            failed,
+            input.DryRun);
+    }
+
+    static RemoteConfigFile ToFetchedFile(IRemoteConfigFile file)
+    {
+        var f = (RemoteConfigFile)file;
+        f.Status = new DeploymentStatus(Statuses.Fetched, string.Empty, SeverityLevel.Success);
+        f.Progress = 100f;
+        return f;
+    }
+
+    static DeployContent GetDeployContent(RemoteConfigEntry entry, string status)
+    {
+        return new CliRemoteConfigEntry(entry.Key, "RemoteConfig Key", NormalizePath(entry.File) ,100, status, string.Empty);
     }
 
-    static string NormalizePath(string path)
+    static string NormalizePath(IRemoteConfigFile? file)
     {
-        return path.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+        return file is null ? "" : file.Path.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigFile.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigFile.cs
index 32de9b4..a56c330 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigFile.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigFile.cs
@@ -1,18 +1,15 @@
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
 
 namespace Unity.Services.Cli.RemoteConfig.Deploy;
 
-class RemoteConfigFile : IRemoteConfigFile
+class RemoteConfigFile : DeployContent, IRemoteConfigFile
 {
     public RemoteConfigFile(string name, string path)
+        : base(name, "RemoteConfig File", path, 0f, DeploymentStatus.Empty )
     {
-        Name = name;
-        Path = path;
         Entries = new List<RemoteConfigEntry>();
     }
-
-    public string Name { get; }
-    public string Path { get; set; }
-
     public List<RemoteConfigEntry> Entries { get; set; }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigScriptsLoader.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigScriptsLoader.cs
index 67a95b0..b21001e 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigScriptsLoader.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Deploy/RemoteConfigScriptsLoader.cs
@@ -1,38 +1,50 @@
+using System.IO.Abstractions;
 using Newtonsoft.Json;
 using Unity.Services.Cli.Authoring.Model;
 using Unity.Services.Cli.RemoteConfig.Deploy;
+using Unity.Services.DeploymentApi.Editor;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
 
 namespace Unity.Services.Cli.RemoteConfig.Deploy;
 
-internal class RemoteConfigScriptsLoader : IRemoteConfigScriptsLoader
+class RemoteConfigScriptsLoader : IRemoteConfigScriptsLoader
 {
-    const string k_ServiceType = "Remote Config";
+    readonly IFile m_File;
+    readonly IPath m_Path;
 
-    public async Task<LoadResult> LoadScriptsAsync(IReadOnlyList<string> filePaths, ICollection<DeployContent> deployContents)
+    public RemoteConfigScriptsLoader(IFile file, IPath path)
+    {
+        m_File = file;
+        m_Path = path;
+    }
+
+    public async Task<LoadResult> LoadScriptsAsync(IReadOnlyList<string> filePaths, CancellationToken token)
     {
         var loaded = new List<RemoteConfigFile>();
-        var failed = new List<DeployContent>();
+        var failed = new List<RemoteConfigFile>();
 
         foreach (var filePath in filePaths)
         {
-            var name = Path.GetFileName(filePath);
+            var name = m_Path.GetFileName(filePath);
+            var file = new RemoteConfigFile(name, filePath);
             try
             {
-                var fileText = await File.ReadAllTextAsync(filePath);
-                var content = JsonConvert.DeserializeObject<RemoteConfigFileContent>(fileText)!;
+                var fileText = await m_File.ReadAllTextAsync(filePath, token);
+                var content = JsonConvert.DeserializeObject<RemoteConfigFileContent>(fileText);
+                if (content is null)
+                {
+                    throw new JsonException($"{filePath} is not a valid resource");
+                }
 
-                var file = new RemoteConfigFile(name, filePath);
                 content.ToRemoteConfigEntries(file, new RemoteConfigParser(new ConfigTypeDeriver()));
 
-                loaded.Add(new RemoteConfigFile(name, filePath));
-                deployContents.Add(new DeployContent(name, k_ServiceType, filePath, 0, "Loaded"));
+                loaded.Add(file);
+                file.Status = new DeploymentStatus(Statuses.Loaded);
             }
             catch (JsonException ex)
             {
-                var content = new DeployContent(name, k_ServiceType, filePath, 0, "Failed To Read", ex.Message);
-                failed.Add(content);
-                deployContents.Add(content);
+                file.Status = new DeploymentStatus(Statuses.FailedToRead, ex.Message, SeverityLevel.Error);
+                failed.Add(file);
             }
         }
         return new LoadResult(loaded, failed);
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/ExportHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/ExportHandler.cs
new file mode 100644
index 0000000..770b679
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/ExportHandler.cs
@@ -0,0 +1,24 @@
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Authoring.Export.Input;
+
+namespace Unity.Services.Cli.RemoteConfig.Handlers.ExportImport;
+
+static class ExportHandler
+{
+    internal const string LoadingIndicatorMessage = "Exporting your environment...";
+    public static async Task ExportAsync(
+        ExportInput exportInput,
+        RemoteConfigExporter? remoteConfigExporter,
+        ILoadingIndicator loadingIndicator,
+        CancellationToken cancellationToken)
+    {
+        await loadingIndicator.StartLoadingAsync(
+            LoadingIndicatorMessage,
+            _ =>
+            {
+                if (remoteConfigExporter == null) return Task.CompletedTask;
+                return remoteConfigExporter.ExportAsync(exportInput, cancellationToken);
+            }
+        );
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/ImportHandler.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/ImportHandler.cs
new file mode 100644
index 0000000..107157a
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/ImportHandler.cs
@@ -0,0 +1,24 @@
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.Cli.Authoring.Import.Input;
+
+namespace Unity.Services.Cli.RemoteConfig.Handlers.ExportImport;
+
+static class ImportHandler
+{
+    internal const string LoadingIndicatorMessage = "Importing your environment...";
+    public static async Task ImportAsync(
+        ImportInput importInput,
+        RemoteConfigImporter? remoteConfigImporter,
+        ILoadingIndicator loadingIndicator,
+        CancellationToken cancellationToken)
+    {
+        await loadingIndicator.StartLoadingAsync(
+            LoadingIndicatorMessage,
+            _ =>
+            {
+                if (remoteConfigImporter == null) return Task.CompletedTask;
+                return remoteConfigImporter.ImportAsync(importInput, cancellationToken);
+            }
+        );
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/RemoteConfigConstants.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/RemoteConfigConstants.cs
new file mode 100644
index 0000000..6038dd3
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/RemoteConfigConstants.cs
@@ -0,0 +1,8 @@
+
+namespace Unity.Services.Cli.RemoteConfig.Handlers.ExportImport;
+
+static class RemoteConfigConstants
+{
+    internal const string ZipName = "ugs.rczip";
+    internal static readonly string EntryName = "rc-config";
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/RemoteConfigExporter.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/RemoteConfigExporter.cs
new file mode 100644
index 0000000..613cdb5
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/RemoteConfigExporter.cs
@@ -0,0 +1,55 @@
+using System.IO.Abstractions;
+using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Export;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.RemoteConfig.Deploy;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
+
+namespace Unity.Services.Cli.RemoteConfig.Handlers.ExportImport;
+
+class RemoteConfigExporter : BaseExporter<RemoteConfigEntryDTO>
+{
+    readonly ICliRemoteConfigClient m_RemoteConfigClient;
+
+    public RemoteConfigExporter(
+        ICliRemoteConfigClient remoteConfigClient,
+        IZipArchiver zipArchiver,
+        IUnityEnvironment unityEnvironment,
+        IFileSystem fileSystem,
+        ILogger logger)
+        : base(
+        zipArchiver,
+        unityEnvironment,
+        fileSystem,
+        logger)
+        {
+            m_RemoteConfigClient = remoteConfigClient;
+        }
+
+    protected override string FileName => RemoteConfigConstants.ZipName;
+    protected override string EntryName => RemoteConfigConstants.EntryName;
+
+    protected override async Task<IEnumerable<RemoteConfigEntryDTO>> ListConfigsAsync(string projectId, string environmentId, CancellationToken cancellationToken)
+    {
+        m_RemoteConfigClient.Initialize(projectId, environmentId, cancellationToken);
+        var result = await m_RemoteConfigClient.GetAsync();
+        return ToDto(result.Configs);
+    }
+
+    protected override ImportExportEntry<RemoteConfigEntryDTO> ToImportExportEntry(RemoteConfigEntryDTO value)
+    {
+        return new ImportExportEntry<RemoteConfigEntryDTO>(value.key.GetHashCode(), value.key, value);
+    }
+    
+    static IReadOnlyList<RemoteConfigEntryDTO> ToDto(IReadOnlyList<RemoteConfigEntry> entries)
+    {
+        return entries.Select(entry => new RemoteConfigEntryDTO()
+        {
+            key = entry.Key,
+            type = entry.GetEntryConfigType().ToString().ToLower(),
+            value = entry.Value
+        }).ToList();
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/RemoteConfigImporter.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/RemoteConfigImporter.cs
new file mode 100644
index 0000000..51740a9
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Handlers/ExportImport/RemoteConfigImporter.cs
@@ -0,0 +1,116 @@
+using Microsoft.Extensions.Logging;
+using Unity.Services.Cli.Common.Utils;
+using Unity.Services.Cli.Authoring.Compression;
+using Unity.Services.Cli.Authoring.Import;
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.Cli.RemoteConfig.Deploy;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Service;
+
+namespace Unity.Services.Cli.RemoteConfig.Handlers.ExportImport;
+
+class RemoteConfigImporter : BaseImporter<RemoteConfigEntryDTO>
+{
+    readonly ICliRemoteConfigClient m_RemoteConfigClient;
+    GetConfigsResult m_GetResult;
+
+    public RemoteConfigImporter(
+        ICliRemoteConfigClient remoteConfigClient,
+        IZipArchiver zipArchiver,
+        IUnityEnvironment unityEnvironment,
+        ILogger logger)
+        : base(
+        zipArchiver,
+        unityEnvironment,
+        logger)
+        {
+            m_RemoteConfigClient = remoteConfigClient;
+        }
+
+    protected override string FileName => RemoteConfigConstants.ZipName;
+    protected override string EntryName => RemoteConfigConstants.EntryName;
+
+
+    /// Method to get list config async
+    protected override async Task<IEnumerable<RemoteConfigEntryDTO>> ListConfigsAsync(
+        string cloudProjectId,
+        string environmentId,
+        CancellationToken cancellationToken)
+    {
+        m_RemoteConfigClient.Initialize(cloudProjectId, environmentId, cancellationToken);
+        m_GetResult = await m_RemoteConfigClient.GetAsync();
+
+        var configsOnRemote = ToDto(m_GetResult.Configs);
+        return configsOnRemote;
+    }
+
+    /// Method to create config async
+    protected override Task CreateConfigAsync(
+        string projectId,
+        string environmentId,
+        RemoteConfigEntryDTO config,
+        CancellationToken cancellationToken)
+    {
+        throw new InvalidOperationException("RC does not have granularity, so it does not apply");
+    }
+
+    /// Method to try update config async
+    protected override Task UpdateConfigAsync(
+        string projectId,
+        string environmentId,
+        RemoteConfigEntryDTO config,
+        CancellationToken cancellationToken)
+    {
+        throw new InvalidOperationException("RC does not have granularity, so it does not apply");
+    }
+
+    /// Method to delete config async
+    protected override Task DeleteConfigAsync(
+        string projectId,
+        string environmentId,
+        RemoteConfigEntryDTO configToDelete,
+        CancellationToken cancellationToken)
+    {
+        throw new InvalidOperationException("RC does not have granularity, so it does not apply");
+    }
+
+    protected override ImportExportEntry<RemoteConfigEntryDTO> ToImportExportEntry(RemoteConfigEntryDTO value)
+    {
+        return new ImportExportEntry<RemoteConfigEntryDTO>(value.key.GetHashCode(), value.key, value);
+    }
+
+    protected override async Task ImportConfigsAsync(string projectId, string environmentId, bool reconcile, ImportState<RemoteConfigEntryDTO> state, int maxParallelTaskLimit, CancellationToken cancellationToken)
+    {
+        List<RemoteConfigEntryDTO> configs = new ();
+        configs.AddRange(state.ToCreate.Select(c => c.Value));
+        configs.AddRange(state.ToUpdate.Select(c => c.Value));
+        if (!reconcile)
+        {
+            // Not adding Deleted values will delete them IE reconcile
+            // We add them if reconcile is disabled to keep them
+            configs.AddRange(state.ToDelete.Select(c => c.Value));
+        }
+
+        var configsToSend = RemoteConfigClient.ToRemoteConfigEntry(configs);
+
+        if (m_GetResult.ConfigsExists)
+        {
+            await m_RemoteConfigClient.UpdateAsync(configsToSend);
+        }
+        else
+        {
+            await m_RemoteConfigClient.CreateAsync(configsToSend);
+        }
+    }
+
+    static IReadOnlyList<RemoteConfigEntryDTO> ToDto(IReadOnlyList<RemoteConfigEntry> entries)
+    {
+        return entries.Select(entry => new RemoteConfigEntryDTO()
+        {
+            key = entry.Key,
+            type = entry.GetEntryConfigType().ToString().ToLower(),
+            value = entry.Value
+        }).ToList();
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Model/CliRemoteConfigEntry.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Model/CliRemoteConfigEntry.cs
new file mode 100644
index 0000000..53e5b36
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Model/CliRemoteConfigEntry.cs
@@ -0,0 +1,18 @@
+using Unity.Services.Cli.Authoring.Model;
+using Unity.Services.DeploymentApi.Editor;
+
+namespace Unity.Services.Cli.RemoteConfig.Model;
+
+
+public class CliRemoteConfigEntry : DeployContent
+{
+    public CliRemoteConfigEntry(string name, string type, string path, float progress, string status, string? detail = null, SeverityLevel level = SeverityLevel.None)
+        : base(name, type, path, progress, status, detail, level)
+    { }
+
+    public override string ToString()
+    {
+        return $"Key '{Name}' in '{Path}'";
+    }
+}
+
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/RemoteConfigModule.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/RemoteConfigModule.cs
index fa725ce..4ccb56f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/RemoteConfigModule.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/RemoteConfigModule.cs
@@ -1,3 +1,4 @@
+using Unity.Services.Cli.Authoring.Compression;
 using System.CommandLine;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
@@ -10,12 +11,16 @@
 using Unity.Services.Cli.RemoteConfig.Service;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Fetch;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Formatting;
-using Unity.Services.RemoteConfig.Editor.Authoring.Core.IO;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Json;
 using Unity.Services.RemoteConfig.Editor.Authoring.Core.Model;
-using Unity.Services.RemoteConfig.Editor.Authoring.Core.Networking;
 using FileSystem = Unity.Services.Cli.RemoteConfig.Deploy.FileSystem;
 using IFileSystem = Unity.Services.RemoteConfig.Editor.Authoring.Core.IO.IFileSystem;
+using Unity.Services.Cli.Common.Input;
+using Unity.Services.Cli.Authoring.Export.Input;
+using Unity.Services.Cli.Authoring.Import.Input;
+using Unity.Services.Cli.RemoteConfig.Handlers.ExportImport;
+using Unity.Services.Cli.Common.Console;
+using Unity.Services.RemoteConfig.Editor.Authoring.Core.Service;
 
 namespace Unity.Services.Cli.RemoteConfig;
 
@@ -25,19 +30,48 @@ namespace Unity.Services.Cli.RemoteConfig;
 public class RemoteConfigModule : ICommandModule
 {
     public Command? ModuleRootCommand { get; }
+    internal Command ExportCommand { get; }
+    internal Command ImportCommand { get; }
 
     public RemoteConfigModule()
     {
+        ExportCommand = new Command(
+            name: "export",
+            description: "Export Environment in a file")
+        {
+            CommonInput.EnvironmentNameOption,
+            CommonInput.CloudProjectIdOption,
+            ExportInput.OutputDirectoryArgument,
+            DryRunInput.DryRunOption,
+            ExportInput.FileNameArgument
+        };
+        ExportCommand.SetHandler<ExportInput, RemoteConfigExporter, ILoadingIndicator, CancellationToken>(ExportHandler.ExportAsync);
+
+        ImportCommand = new Command(
+            name: "import",
+            description: "Import Environment from a file")
+        {
+            CommonInput.EnvironmentNameOption,
+            CommonInput.CloudProjectIdOption,
+            ImportInput.InputDirectoryArgument,
+            DryRunInput.DryRunOption,
+            ImportInput.FileNameArgument
+        };
+        ImportCommand.SetHandler<ImportInput, RemoteConfigImporter, ILoadingIndicator, CancellationToken>(ImportHandler.ImportAsync);
+
         ModuleRootCommand = new Command(
             name: "remote-config",
             description: "Manage RemoteConfig.")
         {
-            ModuleRootCommand.AddNewFileCommand<RemoteConfigTemplate>("Remote Config")
+            ModuleRootCommand.AddNewFileCommand<RemoteConfigTemplate>("Remote Config"),
+            ExportCommand,
+            ImportCommand
         };
 
         ModuleRootCommand.AddAlias("rc");
     }
 
+
     /// <summary>
     /// Register service to UGS CLI host builder
     /// </summary>
@@ -63,13 +97,15 @@ public static void RegisterServices(HostBuilderContext hostBuilderContext, IServ
             s => new RemoteConfigServicesWrapper(
             s.GetRequiredService<CliRemoteConfigDeploymentHandler>(),
             s.GetRequiredService<ICliRemoteConfigClient>(),
-            s.GetRequiredService<CliRemoteConfigDeploymentHandler>(),
-            s.GetRequiredService<IDeployFileService>(),
             s.GetRequiredService<IRemoteConfigService>(),
             s.GetRequiredService<IRemoteConfigScriptsLoader>()));
 
         serviceCollection.AddTransient<IRemoteConfigFetchHandler, CliRemoteConfigFetchHandler>();
         serviceCollection.AddTransient<IDeploymentService, RemoteConfigDeploymentService>();
         serviceCollection.AddTransient<IFetchService, RemoteConfigFetchService>();
+        serviceCollection.AddTransient<RemoteConfigExporter, RemoteConfigExporter>();
+        serviceCollection.AddTransient<RemoteConfigImporter, RemoteConfigImporter>();
+        serviceCollection.AddTransient<IZipArchiver, ZipArchiver>();
+        serviceCollection.AddTransient<System.IO.Abstractions.IFileSystem, System.IO.Abstractions.FileSystem>();
     }
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/IRemoteConfigService.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/IRemoteConfigService.cs
index 7cea3d3..98beccd 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/IRemoteConfigService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/IRemoteConfigService.cs
@@ -4,6 +4,15 @@ namespace Unity.Services.Cli.RemoteConfig.Service;
 
 public interface IRemoteConfigService
 {
+    /// <summary>
+    /// Create a new config of a given type, constructing the payload from the values provided.
+    /// </summary>
+    /// <param name="projectId">Unity Genesis project ID</param>
+    /// <param name="environmentId">ID of the environment, or default environment if not provided</param>
+    /// <param name="configType">Type of the config being created (default: "settings")</param>
+    /// <param name="values">Collection of config values</param>
+    /// <param name="cancellationToken">Token to cancel the task</param>
+    /// <returns>The ID of the created config</returns>
     public Task<string> CreateConfigAsync(
         string projectId,
         string environmentId,
@@ -19,7 +28,12 @@ public Task<string> CreateConfigAsync(
     /// <param name="configType">Type of the config being updated (default: "settings")</param>
     /// <param name="values">Collection of config values</param>
     /// <param name="cancellationToken">Token to cancel the task</param>
-    public Task UpdateConfigAsync(string projectId, string configId, string? configType, IEnumerable<ConfigValue> values, CancellationToken cancellationToken = default);
+    public Task UpdateConfigAsync(
+        string projectId,
+        string configId,
+        string? configType,
+        IEnumerable<ConfigValue> values,
+        CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Update an existing config from the provided JSON string.
@@ -28,7 +42,22 @@ public Task<string> CreateConfigAsync(
     /// <param name="configId">ID of the config being updated</param>
     /// <param name="body">Serialized JSON body containing the <a href="https://services.docs.unity.com/remote-config-admin/v1#tag/Configs/paths/~1remote-config~1v1~1projects~1%7BprojectId%7D~1configs~1%7BconfigId%7D/put">update</a></param>
     /// <param name="cancellationToken">Token to cancel the task</param>
-    public Task UpdateConfigAsync(string projectId, string configId, string body, CancellationToken cancellationToken = default);
+    public Task UpdateConfigAsync(string projectId,
+        string configId,
+        string body,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Delete an existing config.
+    /// </summary>
+    /// <param name="projectId">Unity Genesis project ID</param>
+    /// <param name="configId">ID of the config being deleted</param>
+    /// <param name="configType">The type the config to delete</param>
+    /// <param name="cancellationToken">Token to cancel the task</param>
+    public Task DeleteConfigAsync(string projectId,
+        string configId,
+        string configType,
+        CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Get all configs from the provided environment.
@@ -37,5 +66,20 @@ public Task<string> CreateConfigAsync(
     /// <param name="environmentId">ID of the environment, or default environment if not provided</param>
     /// <param name="configType">Type of the config being updated (default: "settings")</param>
     /// <param name="cancellationToken">Token to cancel the task</param>
-    public Task<string> GetAllConfigsFromEnvironmentAsync(string projectId, string? environmentId, string? configType, CancellationToken cancellationToken = default);
+    public Task<string> GetAllConfigsFromEnvironmentAsync(string projectId,
+        string? environmentId,
+        string? configType,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Apply a JSON schema to an existing config.
+    /// </summary>
+    /// <param name="projectId">Unity Genesis project ID</param>
+    /// <param name="configId">ID of the config using the schema</param>
+    /// <param name="body">The schema JSON body</param>
+    /// <param name="cancellationToken">Token to cancel the task</param>
+    public Task ApplySchemaAsync(string projectId,
+        string configId,
+        string body,
+        CancellationToken cancellationToken = default);
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/IRemoteConfigServicesWrapper.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/IRemoteConfigServicesWrapper.cs
index 5ddb4d1..447d7be 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/IRemoteConfigServicesWrapper.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/IRemoteConfigServicesWrapper.cs
@@ -10,10 +10,6 @@ interface IRemoteConfigServicesWrapper
 
     ICliRemoteConfigClient RemoteConfigClient { get; }
 
-    IDeployFileService DeployFileService { get; }
-
-    ICliDeploymentOutputHandler DeploymentOutputHandler { get; }
-
     IRemoteConfigScriptsLoader RemoteConfigScriptsLoader { get; }
 
 }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/RemoteConfigService.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/RemoteConfigService.cs
index 185824f..51fc13f 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/RemoteConfigService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/RemoteConfigService.cs
@@ -19,6 +19,8 @@ public class RemoteConfigService : IRemoteConfigService
 
     static readonly string k_BaseUrl = $"{EndpointHelper.GetCurrentEndpointFor<RemoteConfigEndpoints>()}/remote-config/v1";
 
+    static readonly string k_InternalBaseUrl = $"{EndpointHelper.GetCurrentEndpointFor<RemoteConfigInternalEndpoints>()}/api/remote-config/v1";
+
     static readonly JsonSerializerSettings k_JsonSerializerSettings = new()
     {
         ContractResolver = new CamelCasePropertyNamesContractResolver()
@@ -35,6 +37,7 @@ public RemoteConfigService(IServiceAccountAuthenticationService authService, ICo
         m_httpClient.DefaultRequestHeaders.SetXClientIdHeader();
     }
 
+    /// <inheritdoc />
     public Task<string> CreateConfigAsync(
         string projectId,
         string environmentId,
@@ -52,14 +55,25 @@ async Task<string> CreateConfigAsync(string projectId, string body, Cancellation
     {
         m_configValidator.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, projectId);
 
+        string requestType = GetRequestTypeFromBody(body);
+
+        var uri = new Uri($"{k_BaseUrl}/projects/{projectId}/configs");
+        var request = new HttpRequestMessage(HttpMethod.Post, uri)
+        {
+            Content = new StringContent(body, Encoding.UTF8, "application/json")
+        };
+        if (requestType != k_ConfigTypeDefaultValue)
+        {
+            // Only set x-requesting-service if a non-default configType was specified
+            request.Headers.Add("x-requesting-service", requestType);
+        }
+
+        await AuthorizeServiceAsync(cancellationToken);
+
+        HttpResponseMessage response = new HttpResponseMessage();
         try
         {
-            await AuthorizeServiceAsync(cancellationToken);
-            var utf8Body = Encoding.UTF8.GetString(Encoding.Default.GetBytes(body));
-            var response = await m_httpClient.PostAsync(
-                $"{k_BaseUrl}/projects/{projectId}/configs",
-                new StringContent(utf8Body, Encoding.UTF8, "application/json"),
-                cancellationToken);
+            response = await m_httpClient.SendAsync(request, cancellationToken);
             response.EnsureSuccessStatusCode();
             var responseStr = await response.Content.ReadAsStringAsync(cancellationToken);
             var responseObj = JsonConvert.DeserializeObject<CreateResponse>(responseStr, k_JsonSerializerSettings);
@@ -67,18 +81,28 @@ async Task<string> CreateConfigAsync(string projectId, string body, Cancellation
         }
         catch (HttpRequestException exception)
         {
-            throw new ApiException($"{nameof(CreateConfigAsync)} failed: {exception.Message}", exception, ExitCode.UnhandledError);
+            string content = await response.Content.ReadAsStringAsync(cancellationToken);
+            throw new ApiException($"{nameof(CreateConfigAsync)} failed: {content}", exception, ExitCode.UnhandledError);
         }
     }
 
-    public Task UpdateConfigAsync(string projectId, string configId, string? configType, IEnumerable<ConfigValue> values, CancellationToken cancellationToken = default)
+    /// <inheritdoc />
+    public Task UpdateConfigAsync(string projectId,
+        string configId,
+        string? configType,
+        IEnumerable<ConfigValue> values,
+        CancellationToken cancellationToken = default)
     {
         var body = CreateBody(configType, values);
 
         return UpdateConfigAsync(projectId, configId, body.ToString(), cancellationToken);
     }
 
-    public Task UpdateConfigAsync(string projectId, string configId, string body, CancellationToken cancellationToken = default)
+    /// <inheritdoc />
+    public Task UpdateConfigAsync(string projectId,
+        string configId,
+        string body,
+        CancellationToken cancellationToken = default)
     {
         m_configValidator.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, projectId);
         if (string.IsNullOrEmpty(configId))
@@ -89,54 +113,89 @@ public Task UpdateConfigAsync(string projectId, string configId, string body, Ca
         return UpdateConfigInternalAsync(projectId, configId, body, cancellationToken);
     }
 
-    private async Task UpdateConfigInternalAsync(string projectId, string configId, string body, CancellationToken cancellationToken = default)
+    async Task UpdateConfigInternalAsync(string projectId,
+        string configId,
+        string body,
+        CancellationToken cancellationToken = default)
     {
+        m_configValidator.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, projectId);
+
+        var requestType = GetRequestTypeFromBody(body);
+
+        var uri = new Uri($"{k_BaseUrl}/projects/{projectId}/configs/{configId}");
+        var request = new HttpRequestMessage(HttpMethod.Put, uri)
+        {
+            Content = new StringContent(body, Encoding.UTF8, "application/json")
+        };
+        if (requestType != k_ConfigTypeDefaultValue)
+        {
+            // Only set x-requesting-service if a non-default configType was specified
+            request.Headers.Add("x-requesting-service", requestType);
+        }
+
+        await AuthorizeServiceAsync(cancellationToken);
+
+        HttpResponseMessage response = new HttpResponseMessage();
         try
         {
-            await AuthorizeServiceAsync(cancellationToken);
-            var utf8Body = Encoding.UTF8.GetString(Encoding.Default.GetBytes(body));
-            const string deserializationErrorMsg = "Failed to deserialize config update request body.";
-            UpdateConfigRequest? updateRequest;
+            response = await m_httpClient.SendAsync(request, cancellationToken);
+            response.EnsureSuccessStatusCode();
+        }
+        catch (HttpRequestException exception)
+        {
+            string content = await response.Content.ReadAsStringAsync(cancellationToken);
+            throw new ApiException($"{nameof(UpdateConfigInternalAsync)} failed: {content}", exception, ExitCode.UnhandledError);
+        }
+    }
 
-            // Deserializing the body here is necessary in order to check the config type.
-            try
-            {
-                updateRequest = JsonConvert.DeserializeObject<UpdateConfigRequest>(utf8Body, k_JsonSerializerSettings);
-            }
-            catch (Exception ex)
-            {
-                throw new CliException(deserializationErrorMsg, ex, ExitCode.HandledError);
-            }
+    /// <inheritdoc />
+    public async Task DeleteConfigAsync(string projectId,
+        string configId,
+        string? configType,
+        CancellationToken cancellationToken = default)
+    {
+        m_configValidator.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, projectId);
+        if (string.IsNullOrEmpty(configId))
+        {
+            throw new ArgumentException("Required parameter is invalid", nameof(configId));
+        }
 
-            if (updateRequest is null || string.IsNullOrEmpty(updateRequest.Type))
-            {
-                throw new CliException(deserializationErrorMsg, null, ExitCode.HandledError);
-            }
+        try
+        {
+            await AuthorizeServiceAsync(cancellationToken);
 
             var uri = new Uri($"{k_BaseUrl}/projects/{projectId}/configs/{configId}");
-            var request = new HttpRequestMessage(HttpMethod.Put, uri);
-            request.Content = new StringContent(utf8Body, Encoding.UTF8, "application/json");
-            if (updateRequest.Type != k_ConfigTypeDefaultValue)
+            var request = new HttpRequestMessage(HttpMethod.Delete, uri);
+
+            if (configType != null && configType != k_ConfigTypeDefaultValue)
             {
                 // Only set x-requesting-service if a non-default configType was specified
-                request.Headers.Add("x-requesting-service", updateRequest.Type);
+                request.Headers.Add("x-requesting-service", configType);
             }
+
             var response = await m_httpClient.SendAsync(request, cancellationToken);
             response.EnsureSuccessStatusCode();
         }
         catch (HttpRequestException exception)
         {
-            throw new ApiException($"{nameof(UpdateConfigInternalAsync)} failed: {exception.Message}", exception, ExitCode.HandledError);
+            throw new ApiException($"{nameof(DeleteConfigAsync)} failed", exception, ExitCode.UnhandledError);
         }
     }
 
-    public Task<string> GetAllConfigsFromEnvironmentAsync(string projectId, string? environmentId, string? configType, CancellationToken cancellationToken = default)
+    /// <inheritdoc />
+    public Task<string> GetAllConfigsFromEnvironmentAsync(string projectId,
+        string? environmentId,
+        string? configType,
+        CancellationToken cancellationToken = default)
     {
         m_configValidator.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, projectId);
         return GetAllConfigsFromEnvironmentInternalAsync(projectId, environmentId, configType, cancellationToken);
     }
 
-    private async Task<string> GetAllConfigsFromEnvironmentInternalAsync(string projectId, string? environmentId, string? configType, CancellationToken cancellationToken = default)
+    async Task<string> GetAllConfigsFromEnvironmentInternalAsync(string projectId,
+        string? environmentId,
+        string? configType,
+        CancellationToken cancellationToken = default)
     {
         try
         {
@@ -162,7 +221,45 @@ private async Task<string> GetAllConfigsFromEnvironmentInternalAsync(string proj
         }
         catch (HttpRequestException exception)
         {
-            throw new ApiException($"{nameof(GetAllConfigsFromEnvironmentAsync)} failed: {exception.Message}", exception, ExitCode.HandledError);
+            throw new ApiException($"{nameof(GetAllConfigsFromEnvironmentAsync)} failed", exception, ExitCode.UnhandledError);
+        }
+    }
+
+    public async Task ApplySchemaAsync(string projectId,
+        string configId,
+        string body,
+        CancellationToken cancellationToken = default)
+    {
+        m_configValidator.ThrowExceptionIfConfigInvalid(Keys.ConfigKeys.ProjectId, projectId);
+        if (string.IsNullOrEmpty(configId))
+        {
+            throw new ArgumentException("Required parameter is invalid", nameof(configId));
+        }
+
+        HttpResponseMessage response = new HttpResponseMessage();
+        try
+        {
+            await AuthorizeServiceAsync(cancellationToken);
+
+            var uri = new Uri($"{k_InternalBaseUrl}/projects/{projectId}/configs/{configId}/schemas");
+            var request = new HttpRequestMessage(HttpMethod.Post, uri)
+            {
+                Content = new StringContent(body, Encoding.UTF8, "application/json"),
+            };
+
+            response = await m_httpClient.SendAsync(request, cancellationToken);
+            response.EnsureSuccessStatusCode();
+        }
+        catch (HttpRequestException exception)
+        {
+            // A 409 Conflict is returned if the exact same schema has already been applied to this config, so we
+            // consider that to be successful too.
+            if (response.StatusCode == System.Net.HttpStatusCode.Conflict)
+            {
+                return;
+            }
+
+            throw new ApiException($"{nameof(ApplySchemaAsync)} failed", exception, ExitCode.UnhandledError);
         }
     }
 
@@ -182,7 +279,47 @@ static JObject CreateBody(string? configType, IEnumerable<ConfigValue> values)
         return body;
     }
 
-    private async Task AuthorizeServiceAsync(CancellationToken cancellationToken = default)
+    /// <summary>
+    /// Gets the type property from the Remote Config request bod.
+    /// </summary>
+    /// <param name="body">The JSON formatted request body to extract the type from.</param>
+    /// <returns>The type from the request body if it's valid.</returns>
+    /// <exception cref="CliException">Throws if the request body is invalid or doesn't contain a type.</exception>
+    static string GetRequestTypeFromBody(string body)
+    {
+        UpdateConfigRequest? configRequest;
+
+        // Deserializing the body here is necessary in order to check the config type.
+        try
+        {
+            configRequest = JsonConvert.DeserializeObject<UpdateConfigRequest>(body, k_JsonSerializerSettings);
+        }
+        catch (JsonException ex)
+        {
+            throw new CliException("Config request body contains invalid JSON. " + ex.Message, null, ExitCode.HandledError);
+        }
+        catch (Exception ex)
+        {
+            throw new CliException("Failed to deserialize config request body", ex, ExitCode.UnhandledError);
+        }
+
+        if (configRequest is null)
+        {
+            throw new CliException("Empty config request body", null, ExitCode.HandledError);
+        }
+
+        if (string.IsNullOrEmpty(configRequest.Type))
+        {
+            throw new CliException("Config request body is missing type", null, ExitCode.HandledError);
+        }
+
+        return configRequest.Type;
+    }
+
+    /// <summary>
+    /// Creates an authorization token for the configured service account and attaches it to the http client.
+    /// </summary>
+    async Task AuthorizeServiceAsync(CancellationToken cancellationToken = default)
     {
         var token = await m_authService.GetAccessTokenAsync(cancellationToken);
         m_httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", token);
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/RemoteConfigServicesWrapper.cs b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/RemoteConfigServicesWrapper.cs
index 64b00f7..c0ed5e4 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/RemoteConfigServicesWrapper.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Service/RemoteConfigServicesWrapper.cs
@@ -10,24 +10,16 @@ class RemoteConfigServicesWrapper : IRemoteConfigServicesWrapper
     public ICliRemoteConfigClient RemoteConfigClient { get; }
     public IRemoteConfigService RemoteConfigService { get; }
 
-    public IDeployFileService DeployFileService { get; }
-
-    public ICliDeploymentOutputHandler DeploymentOutputHandler { get; }
-
     public IRemoteConfigScriptsLoader RemoteConfigScriptsLoader { get; }
 
     public RemoteConfigServicesWrapper(
         IRemoteConfigDeploymentHandler deploymentHandler,
         ICliRemoteConfigClient remoteConfigClient,
-        ICliDeploymentOutputHandler deploymentOutputHandler,
-        IDeployFileService deployFileService,
         IRemoteConfigService remoteConfigService,
         IRemoteConfigScriptsLoader remoteConfigScriptsLoader)
     {
         DeploymentHandler = deploymentHandler;
         RemoteConfigClient = remoteConfigClient;
-        DeploymentOutputHandler = deploymentOutputHandler;
-        DeployFileService = deployFileService;
         RemoteConfigService = remoteConfigService;
         RemoteConfigScriptsLoader = remoteConfigScriptsLoader;
     }
diff --git a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Unity.Services.Cli.RemoteConfig.csproj b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Unity.Services.Cli.RemoteConfig.csproj
index 9453ab9..38bf01d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Unity.Services.Cli.RemoteConfig.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli.RemoteConfig/Unity.Services.Cli.RemoteConfig.csproj
@@ -20,7 +20,7 @@
     <ProjectReference Include="..\Unity.Services.Cli.ServiceAccountAuthentication\Unity.Services.Cli.ServiceAccountAuthentication.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Unity.Services.RemoteConfig.Authoring.Editor.Core" Version="0.4.0" />
+    <PackageReference Include="Unity.Services.RemoteConfig.Authoring.Editor.Core" Version="0.5.0" />
   </ItemGroup>
   <PropertyGroup>
     <DefineConstants Condition=" '$(ExtraDefineConstants)' != '' ">$(DefineConstants);$(ExtraDefineConstants)</DefineConstants>
diff --git a/Unity.Services.Cli/Unity.Services.Cli.ServiceAccountAuthentication/Service/AuthenticationService.cs b/Unity.Services.Cli/Unity.Services.Cli.ServiceAccountAuthentication/Service/AuthenticationService.cs
index d3ec755..9a0ee00 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.ServiceAccountAuthentication/Service/AuthenticationService.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli.ServiceAccountAuthentication/Service/AuthenticationService.cs
@@ -7,7 +7,7 @@ namespace Unity.Services.Cli.ServiceAccountAuthentication;
 class AuthenticationService : IServiceAccountAuthenticationService
 {
     readonly IPersister<string> m_Persister;
-    private readonly ISystemEnvironmentProvider m_SystemEnvironmentProvider;
+    readonly ISystemEnvironmentProvider m_SystemEnvironmentProvider;
 
     public AuthenticationService(IPersister<string> persister, ISystemEnvironmentProvider environmentProvider)
     {
diff --git a/Unity.Services.Cli/Unity.Services.Cli.sln b/Unity.Services.Cli/Unity.Services.Cli.sln
index 7925362..5c0189c 100644
--- a/Unity.Services.Cli/Unity.Services.Cli.sln
+++ b/Unity.Services.Cli/Unity.Services.Cli.sln
@@ -33,6 +33,7 @@ EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Services.Cli.Integration.MockServer", "Unity.Services.Cli.Integration.MockServer\Unity.Services.Cli.Integration.MockServer.csproj", "{92DBFB5E-BAD9-4852-9162-DA6B94CE6BF3}"
 EndProject
 EndProject
+EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Services.Cli.Leaderboards", "Unity.Services.Cli.Leaderboards\Unity.Services.Cli.Leaderboards.csproj", "{4C0810A8-3439-4DCD-8325-0E5F4D47DCC2}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Services.Cli.Leaderboards.UnitTest", "Unity.Services.Cli.Leaderboards.UnitTest\Unity.Services.Cli.Leaderboards.UnitTest.csproj", "{64C6D8E5-4396-419A-94F6-2B221E9B7860}"
@@ -45,6 +46,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Services.Cli.Authorin
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Services.Cli.RemoteConfig.UnitTest", "Unity.Services.Cli.RemoteConfig.UnitTest\Unity.Services.Cli.RemoteConfig.UnitTest.csproj", "{F60B608F-8AED-4F6D-9853-C3A2D7CFA641}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Services.ModuleTemplate.Authoring.Core", "Unity.Services.ModuleTemplate.Authoring.Core\Unity.Services.ModuleTemplate.Authoring.Core.csproj", "{08B0E479-D8CF-43B9-AB24-C3FF18452E98}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Services.Cli.Access", "Unity.Services.Cli.Access\Unity.Services.Cli.Access.csproj", "{26EE370C-FB17-41C2-8AE8-215515900CC3}"
 EndProject
@@ -62,6 +64,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Documentation", "Documentat
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Services.Cli.Integration.MockServerApp", "Unity.Services.Cli.Integration.MockServerApp\Unity.Services.Cli.Integration.MockServerApp.csproj", "{27BBE31C-43CE-45AA-9DE4-BF3D097DC1A3}"
 EndProject
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -148,6 +151,10 @@ Global
 		{F60B608F-8AED-4F6D-9853-C3A2D7CFA641}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F60B608F-8AED-4F6D-9853-C3A2D7CFA641}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F60B608F-8AED-4F6D-9853-C3A2D7CFA641}.Release|Any CPU.Build.0 = Release|Any CPU
+		{08B0E479-D8CF-43B9-AB24-C3FF18452E98}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{08B0E479-D8CF-43B9-AB24-C3FF18452E98}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{08B0E479-D8CF-43B9-AB24-C3FF18452E98}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{08B0E479-D8CF-43B9-AB24-C3FF18452E98}.Release|Any CPU.Build.0 = Release|Any CPU
 		{93151F5A-F12D-47A1-AF9A-25A4D0717B53}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{93151F5A-F12D-47A1-AF9A-25A4D0717B53}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{93151F5A-F12D-47A1-AF9A-25A4D0717B53}.Release|Any CPU.ActiveCfg = Release|Any CPU
diff --git a/Unity.Services.Cli/Unity.Services.Cli.sln.DotSettings b/Unity.Services.Cli/Unity.Services.Cli.sln.DotSettings
new file mode 100644
index 0000000..cd2f26e
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli.sln.DotSettings
@@ -0,0 +1,18 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ArrangeTypeMemberModifiers/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ArrangeTypeModifiers/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=MemberCanBeMadeStatic_002EGlobal/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=MemberCanBeMadeStatic_002ELocal/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/DEFAULT_INTERNAL_MODIFIER/@EntryValue">Implicit</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/DEFAULT_PRIVATE_MODIFIER/@EntryValue">Implicit</s:String>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/MAX_INVOCATION_ARGUMENTS_ON_LINE/@EntryValue">3</s:Int64>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_AFTER_DECLARATION_LPAR/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_AFTER_INVOCATION_LPAR/@EntryValue">True</s:Boolean>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARGUMENTS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_CHAINED_METHOD_CALLS/@EntryValue">CHOP_IF_LONG</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_PARAMETERS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="k_" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpKeepExistingMigration/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpPlaceEmbeddedOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpUseContinuousIndentInsideBracesMigration/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/Unity.Services.Cli/Unity.Services.Cli/Program.LoggerConsole.cs b/Unity.Services.Cli/Unity.Services.Cli/Program.LoggerConsole.cs
new file mode 100644
index 0000000..e1168a8
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.Cli/Program.LoggerConsole.cs
@@ -0,0 +1,35 @@
+using System;
+using System.CommandLine;
+using System.CommandLine.IO;
+using System.IO;
+
+namespace Unity.Services.Cli;
+
+public static partial class Program
+{
+    class LoggerConsole : IConsole
+    {
+        public LoggerConsole(TextWriter stdout, TextWriter stderr)
+        {
+            Out = new StandardStreamWriter(stdout ?? Console.Out);
+            Error = new StandardStreamWriter(stderr ?? Console.Error);
+        }
+        public IStandardStreamWriter Out { get; }
+        public IStandardStreamWriter Error { get; }
+        public bool IsOutputRedirected => Console.IsOutputRedirected;
+        public bool IsErrorRedirected => Console.IsOutputRedirected;
+        public bool IsInputRedirected => Console.IsInputRedirected;
+
+        class StandardStreamWriter : IStandardStreamWriter
+        {
+            readonly TextWriter m_Writer;
+            public StandardStreamWriter(TextWriter writer) {
+                m_Writer = writer;
+            }
+            public void Write(string value)
+            {
+                m_Writer.Write(value);
+            }
+        }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.Cli/Program.cs b/Unity.Services.Cli/Unity.Services.Cli/Program.cs
index 5d4e01c..d1702ee 100644
--- a/Unity.Services.Cli/Unity.Services.Cli/Program.cs
+++ b/Unity.Services.Cli/Unity.Services.Cli/Program.cs
@@ -4,11 +4,14 @@
 using System.CommandLine.Builder;
 using System.CommandLine.Help;
 using System.CommandLine.Hosting;
+using System.CommandLine.IO;
 using System.CommandLine.Parsing;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 using Spectre.Console;
 using Unity.Services.Cli.CloudCode;
 using Unity.Services.Cli.Lobby;
@@ -33,11 +36,15 @@
 
 namespace Unity.Services.Cli;
 
-static class Program
+public static partial class Program
 {
-    static async Task<int> Main(string[] args)
+    public static async Task<int> Main(string[] args)
+    {
+        return await InternalMain(args, new Logger());
+    }
+
+    public static async Task<int> InternalMain(string[] args, Logger logger)
     {
-        var logger = new Logger();
         var services = new ServiceTypesBridge();
         var ansiConsole = AnsiConsole.Create(new AnsiConsoleSettings());
         TelemetrySender telemetrySender = null;
@@ -45,11 +52,16 @@ static async Task<int> Main(string[] args)
         IAnalyticEventFactory analyticEventFactory = new AnalyticEventFactory(systemEnvironmentProvider);
 
         var parser = BuildCommandLine()
-            .UseHost(_ => Host.CreateDefaultBuilder(),
+            .UseHost(
+                _ => Host.CreateDefaultBuilder(),
                 host =>
                 {
                     host.UseServiceProviderFactory(_ => services);
-                    CommonModule.ConfigureCommonServices(host, logger, ansiConsole, analyticEventFactory);
+                    CommonModule.ConfigureCommonServices(
+                        host,
+                        logger,
+                        ansiConsole,
+                        analyticEventFactory);
                     telemetrySender = CommonModule.CreateTelemetrySender(systemEnvironmentProvider);
 
                     host.ConfigureServices(ConfigurationModule.RegisterServices);
@@ -68,26 +80,31 @@ static async Task<int> Main(string[] args)
                         .AddSingleton<ISystemEnvironmentProvider>(systemEnvironmentProvider));
                 })
             .UseVersionOption()
-            .UseHelp(ctx =>
-            {
-                ctx.HelpBuilder.CustomizeLayout(_ =>
+            .UseHelp(
+                ctx =>
                 {
-                    List<HelpSectionDelegate> helpSectionDelegates = HelpBuilder.Default.GetLayout().ToList();
+                    ctx.HelpBuilder.CustomizeLayout(
+                        _ =>
+                        {
+                            List<HelpSectionDelegate> helpSectionDelegates = HelpBuilder.Default.GetLayout().ToList();
 
-                    helpSectionDelegates.Insert(1, _ => ansiConsole
-                        .Markup($"Project Role Requirements:{System.Environment.NewLine}  You may need " +
-                                $"permissions to use this module or command.{System.Environment.NewLine}  " +
-                                "Visit https://services.docs.unity.com/guides/ugs-cli/latest/general/" +
-                                "troubleshooting/project-roles for required project roles." +
-                                $"{System.Environment.NewLine}"));
+                            helpSectionDelegates.Insert(
+                                1,
+                                _ => ansiConsole
+                                    .Markup(
+                                        $"Project Role Requirements:{System.Environment.NewLine}  You may need " +
+                                        $"permissions to use this module or command.{System.Environment.NewLine}  " +
+                                        "Visit https://services.docs.unity.com/guides/ugs-cli/latest/general/" +
+                                        "troubleshooting/project-roles for required project roles." +
+                                        $"{System.Environment.NewLine}"));
 
-                    // Replace built-in subcommand help section by custom subcommand help section
-                    helpSectionDelegates.Remove(HelpBuilder.Default.SubcommandsSection());
-                    helpSectionDelegates.Add(SubcommandsSectionDelegate(ctx, ansiConsole));
+                            // Replace built-in subcommand help section by custom subcommand help section
+                            helpSectionDelegates.Remove(HelpBuilder.Default.SubcommandsSection());
+                            helpSectionDelegates.Add(SubcommandsSectionDelegate(ctx, ansiConsole));
 
-                    return helpSectionDelegates.AsEnumerable();
-                });
-            })
+                            return helpSectionDelegates.AsEnumerable();
+                        });
+                })
             .UseEnvironmentVariableDirective()
             .UseParseDirective()
             .UseSuggestDirective()
@@ -123,13 +140,15 @@ static async Task<int> Main(string[] args)
             .AddModule(new RemoteConfigModule())
             .Build();
 
-        return await parser.InvokeAsync(args)
-            .ContinueWith(commandTask =>
-            {
-                logger.Write();
-                TrySendCommandUsageMetric(analyticEventFactory, parser.Parse(args).CommandResult);
-                return commandTask.Result;
-            });
+        return await parser
+            .InvokeAsync(args, console: new LoggerConsole(logger.StdOut, logger.StdErr))
+            .ContinueWith(
+                commandTask =>
+                {
+                    logger.Write();
+                    TrySendCommandUsageMetric(analyticEventFactory, parser.Parse(args).CommandResult);
+                    return commandTask.Result;
+                });
     }
 
     static CommandLineBuilder BuildCommandLine()
diff --git a/Unity.Services.Cli/Unity.Services.Cli/Properties/launchSettings.json b/Unity.Services.Cli/Unity.Services.Cli/Properties/launchSettings.json
index 3d18c5b..8ab0f67 100644
--- a/Unity.Services.Cli/Unity.Services.Cli/Properties/launchSettings.json
+++ b/Unity.Services.Cli/Unity.Services.Cli/Properties/launchSettings.json
@@ -3,7 +3,8 @@
   "profiles": {
     "Unity.Services.Cli": {
       "commandName": "Project",
-      "workingDirectory": "$(SolutionDir)/../"
+      "workingDirectory": "$(SolutionDir)/../",
+      "commandLineArgs": "cloud-code modules import Unity.Services.Cli/Unity.Services.Cli.CloudCode.UnitTest/ModuleTestCases test.ccmzip"
     },
     "Unity.Services.Cli.PrintTree": {
       "commandName": "Project",
diff --git a/Unity.Services.Cli/Unity.Services.Cli/Unity.Services.Cli.csproj b/Unity.Services.Cli/Unity.Services.Cli/Unity.Services.Cli.csproj
index d32938d..34dae5d 100644
--- a/Unity.Services.Cli/Unity.Services.Cli/Unity.Services.Cli.csproj
+++ b/Unity.Services.Cli/Unity.Services.Cli/Unity.Services.Cli.csproj
@@ -5,7 +5,7 @@
     <LangVersion>10</LangVersion>
     <AssemblyName>ugs</AssemblyName>
     <VersionPrefix>1.0.0</VersionPrefix>
-    <VersionSuffix>beta.4</VersionSuffix>
+    <VersionSuffix>beta.5</VersionSuffix>
     <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
     <IncludeAllContentForSelfExtract>true</IncludeAllContentForSelfExtract>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
@@ -18,13 +18,15 @@
     </None>
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="Polly" Version="7.2.3" />
+    <PackageReference Include="Polly.Extensions.Http" Version="3.0.0" />
     <PackageReference Include="System.CommandLine.Hosting" Version="0.4.0-alpha.22272.1" />
     <ProjectReference Include="..\Unity.Services.Cli.Player\Unity.Services.Cli.Player.csproj" />
     <ProjectReference Include="..\Unity.Services.Cli.Access\Unity.Services.Cli.Access.csproj" />
     <ProjectReference Include="..\Unity.Services.Cli.CloudCode\Unity.Services.Cli.CloudCode.csproj" />
     <ProjectReference Include="..\Unity.Services.Cli.Common\Unity.Services.Cli.Common.csproj" />
     <ProjectReference Include="..\Unity.Services.Cli.Authoring\Unity.Services.Cli.Authoring.csproj" />
-    <ProjectReference Include="..\Unity.Services.Cli.Environment\Unity.Services.Cli.Environment.csproj" />
+    <ProjectReference Include="..\Unity.Services.Cli.Environment\Unity.Services.Cli.Environment.csproj" PrivateAssets="All" />
     <ProjectReference Include="..\Unity.Services.Cli.Leaderboards\Unity.Services.Cli.Leaderboards.csproj" />
     <ProjectReference Include="..\Unity.Services.Cli.ServiceAccountAuthentication\Unity.Services.Cli.ServiceAccountAuthentication.csproj" />
     <ProjectReference Include="..\Unity.Services.Cli.RemoteConfig\Unity.Services.Cli.RemoteConfig.csproj" />
@@ -37,7 +39,7 @@
   </ItemGroup>
   <PropertyGroup>
     <DebugType>full</DebugType>
-    <DefineConstants>TRACE;FEATURE_LEADERBOARDS;</DefineConstants>
+    <DefineConstants>TRACE;FEATURE_LEADERBOARDS;FEATURE_LEADERBOARDS_IMPORT_EXPORT;</DefineConstants>
   </PropertyGroup>
   <PropertyGroup>
     <DefineConstants Condition=" '$(ExtraDefineConstants)' != '' ">$(DefineConstants);$(ExtraDefineConstants)</DefineConstants>
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/.template.config/template.json b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/.template.config/template.json
new file mode 100644
index 0000000..8bb8dd1
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/.template.config/template.json
@@ -0,0 +1,19 @@
+{
+  "$schema": "http://json.schemastore.org/template",
+  "author": "UGS EdEx Team",
+  "classifications": [
+    "Console",
+    "UGS",
+    "CLI",
+    "Unity",
+    "Services"
+  ],
+  "identity": "Ugs.Cli.ModuleDeploy",
+  "name": "UGS CLI ModuleDeploy",
+  "shortName": "UgsCliModuleDeploy",
+  "tags": {
+    "language": "C#",
+    "type": "project"
+  },
+  "sourceName": "ModuleTemplate"
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Batching/Batching.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Batching/Batching.cs
new file mode 100644
index 0000000..3989792
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Batching/Batching.cs
@@ -0,0 +1,259 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.Batching
+{
+    /// <summary>An utility class for executing delegates in batches with a time interval between them</summary>
+    /// <warning>Currently only supports async delegates (with or without return values)</warning>
+    public static class Batching
+    {
+        const int k_BatchSize = 10;
+        const double k_SecondsDelay = 1;
+
+        const string k_BatchingExceptionMessage =
+            "One or more exceptions were thrown during the batching execution. See inner exceptions.";
+
+        /// <summary>
+        /// Asynchronously execute a collection of delegates in batches with delay between them
+        /// </summary>
+        /// <param name="delegates">IEnumerable of the delegates you want to run in batches</param>
+        /// <param name="callback">Callback that will be invoked when a delegate has finished executing</param>
+        /// <param name="cancellationToken"></param>
+        /// <param name="batchSize">Size of the batches</param>
+        /// <param name="secondsDelay">Delay in seconds between batches</param>
+        /// <exception cref="AggregateException">Exception thrown when a delegate throws an exception</exception>
+        /// <warning>You need to handle the AggregateException's innerExceptions (that's where you'll get
+        /// the exceptions related to the individual batch items executed)</warning>
+        public static async Task ExecuteInBatchesAsync(
+            IEnumerable<Func<Task>> delegates,
+            CancellationToken cancellationToken,
+            int batchSize = k_BatchSize,
+            double secondsDelay = k_SecondsDelay)
+        {
+            var newDelegates = new List<Func<Task<int>>>();
+
+            foreach (var del in delegates)
+            {
+                newDelegates.Add(
+                    async () =>
+                    {
+                        await Task.Run(del, cancellationToken);
+                        return 0;
+                    });
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+            }
+
+            await ExecuteInBatchesAsync(
+                newDelegates,
+                cancellationToken,
+                batchSize,
+                secondsDelay);
+        }
+
+        /// <summary>
+        /// Asynchronously execute a collection of delegates in batches with delay between them
+        /// </summary>
+        /// <param name="delegates">IEnumerable of the delegates you want to run in batches</param>
+        /// <param name="callback">Callback that will be invoked when a delegate has finished executing</param>
+        /// <param name="cancellationToken"></param>
+        /// <param name="batchSize">Size of the batches</param>
+        /// <param name="secondsDelay">Delay in seconds between batches</param>
+        /// <typeparam name="TResult">The return value type of your delegates</typeparam>
+        /// <returns>A collection of results</returns>
+        /// <exception cref="AggregateException">Exception thrown when a delegate throws an exception</exception>
+        /// <warning>You need to handle the AggregateException's innerExceptions (that's where you'll get
+        /// the exceptions related to the individual batch items executed)</warning>
+        public static async Task<IReadOnlyList<TResult>> ExecuteInBatchesAsync<TResult>(
+            IReadOnlyList<Func<Task<TResult>>> delegates,
+            CancellationToken cancellationToken,
+            int batchSize = k_BatchSize,
+            double secondsDelay = k_SecondsDelay)
+        {
+            var exceptions = new ConcurrentQueue<Exception>();
+            var batchesResult = new ConcurrentBag<TResult>();
+            var chunks = delegates.Chunk(batchSize).ToList();
+
+            for (int i = 0; i < chunks.Count; i++)
+            {
+                try
+                {
+                    var batchResult = await ExecuteBatchAsync(chunks[i], cancellationToken);
+                    foreach (var result in batchResult)
+                    {
+                        batchesResult.Add(result);
+                    }
+                }
+                catch (AggregateException e)
+                {
+                    foreach (var innerException in e.InnerExceptions)
+                    {
+                        exceptions.Enqueue(innerException);
+                    }
+                }
+
+                if (i + 1 != chunks.Count)
+                {
+                    await Task.Delay(TimeSpan.FromSeconds(secondsDelay), cancellationToken);
+                }
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    break;
+                }
+            }
+
+            if (!exceptions.IsEmpty)
+            {
+                throw new AggregateException(k_BatchingExceptionMessage, exceptions.ToList());
+            }
+
+            return batchesResult.ToList();
+        }
+
+        public static async Task ExecuteInBatchesAsync(
+            IEnumerable<Task> tasks,
+            CancellationToken cancellationToken,
+            int batchSize = k_BatchSize,
+            double secondsDelay = k_SecondsDelay)
+        {
+            var exceptions = new List<Exception>();
+            var iterator = tasks.GetEnumerator();
+
+            while (true)
+            {
+                var chunk = new List<Task>();
+                for (int i = 0; i < batchSize; ++i)
+                {
+                    if (!iterator.MoveNext())
+                        break;
+                    chunk.Add(iterator.Current);
+                }
+
+                if (chunk.Count == 0)
+                    break;
+
+                var innerExceptions = await ExecuteBatchAsync(chunk);
+                exceptions.AddRange(innerExceptions);
+
+                if (cancellationToken.IsCancellationRequested)
+                    break;
+
+                await Task.Delay(TimeSpan.FromSeconds(secondsDelay), cancellationToken);
+
+                if (cancellationToken.IsCancellationRequested)
+                    break;
+            }
+
+            iterator.Dispose();
+
+            if (exceptions.Count != 0)
+            {
+                throw new AggregateException(k_BatchingExceptionMessage, exceptions.ToList());
+            }
+        }
+
+        static async Task<IReadOnlyList<TResult>> ExecuteBatchAsync<TResult>(
+            IEnumerable<Func<Task<TResult>>> delegates,
+            CancellationToken cancellationToken)
+        {
+            var exceptions = new ConcurrentQueue<Exception>();
+            var batchesResult = new ConcurrentBag<TResult>();
+            var tasks = new ConcurrentBag<Task>();
+
+            Parallel.ForEach(
+                delegates,
+                del =>
+                {
+                    var task = Task.Run(
+                        async () =>
+                        {
+                            try
+                            {
+                                var result = await Task.Run(del, cancellationToken);
+                                batchesResult.Add(result);
+                            }
+                            catch (Exception e)
+                            {
+                                exceptions.Enqueue(e);
+                            }
+                        },
+                        cancellationToken);
+
+                    tasks.Add(task);
+                });
+
+            await Task.WhenAll(tasks);
+
+            if (!exceptions.IsEmpty)
+            {
+                throw new AggregateException(k_BatchingExceptionMessage, exceptions.ToList());
+            }
+
+            return batchesResult.ToList();
+        }
+
+        static async Task<IReadOnlyList<Exception>> ExecuteBatchAsync(IEnumerable<Task> insideTasks)
+        {
+            var tasks = new ConcurrentBag<Task>();
+            var exceptions = new ConcurrentQueue<Exception>();
+
+            Parallel.ForEach(
+                insideTasks,
+                async del =>
+                {
+                    tasks.Add(del);
+                    try
+                    {
+                        await del;
+                    }
+                    catch (Exception e)
+                    {
+                        exceptions.Enqueue(e);
+                    }
+                });
+
+            await Task.WhenAll(tasks);
+
+            return exceptions.ToList();
+        }
+
+        // Copy/pasted utility code from the Enumerable.Chunk method available in dotnet 5
+        static IEnumerable<TSource[]> ChunkIterator<TSource>(IEnumerable<TSource> source, int size)
+        {
+            using IEnumerator<TSource> e = source.GetEnumerator();
+            while (e.MoveNext())
+            {
+                TSource[] chunk = new TSource[size];
+                chunk[0] = e.Current;
+
+                int i = 1;
+                for (; i < chunk.Length && e.MoveNext(); i++)
+                {
+                    chunk[i] = e.Current;
+                }
+
+                if (i == chunk.Length)
+                {
+                    yield return chunk;
+                }
+                else
+                {
+                    Array.Resize(ref chunk, i);
+                    yield return chunk;
+                    yield break;
+                }
+            }
+        }
+
+        static IEnumerable<TSource[]> Chunk<TSource>(this IEnumerable<TSource> source, int size)
+            => ChunkIterator(source, size);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Deploy/DeployResult.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Deploy/DeployResult.cs
new file mode 100644
index 0000000..36b7084
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Deploy/DeployResult.cs
@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using Unity.Services.ModuleTemplate.Authoring.Core.Model;
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.Deploy
+{
+    public class DeployResult
+    {
+        public List<IResource> Created { get; set; }
+        public List<IResource> Updated { get; set; }
+        public List<IResource> Deleted { get; set; }
+        public List<IResource> Deployed { get; set; }
+        public List<IResource> Failed { get; set; }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Deploy/IModuleTemplateDeploymentHandler.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Deploy/IModuleTemplateDeploymentHandler.cs
new file mode 100644
index 0000000..46f0757
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Deploy/IModuleTemplateDeploymentHandler.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Unity.Services.ModuleTemplate.Authoring.Core.Model;
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.Deploy
+{
+    public interface IModuleTemplateDeploymentHandler
+    {
+        Task<DeployResult> DeployAsync(IReadOnlyList<IResource> localResources,
+            bool dryRun = false,
+            bool reconcile = false,
+            CancellationToken token = default);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Deploy/ModuleTemplateDeploymentHandler.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Deploy/ModuleTemplateDeploymentHandler.cs
new file mode 100644
index 0000000..59b9392
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Deploy/ModuleTemplateDeploymentHandler.cs
@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Unity.Services.DeploymentApi.Editor;
+using Unity.Services.ModuleTemplate.Authoring.Core.Model;
+using Unity.Services.ModuleTemplate.Authoring.Core.Service;
+using Unity.Services.ModuleTemplate.Authoring.Core.Validations;
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.Deploy
+{
+    public class ModuleTemplateDeploymentHandler : IModuleTemplateDeploymentHandler
+    {
+        readonly IModuleTemplateClient m_Client;
+        readonly object m_ResultLock = new();
+
+        public ModuleTemplateDeploymentHandler(IModuleTemplateClient client)
+        {
+            m_Client = client;
+        }
+
+        public async Task<DeployResult> DeployAsync(
+            IReadOnlyList<IResource> localResources,
+            bool dryRun = false,
+            bool reconcile = false,
+            CancellationToken token = default)
+        {
+            var res = new DeployResult();
+
+            localResources = DuplicateResourceValidation.FilterDuplicateResources(
+                localResources, out var duplicateGroups);
+
+            var remoteResources = await m_Client.List();
+
+            var toCreate = localResources
+                .Except(remoteResources)
+                .ToList();
+
+            var toUpdate = localResources
+                .Except(toCreate)
+                .ToList();
+
+            var toDelete = new List<IResource>();
+            if (reconcile)
+            {
+                toDelete = remoteResources
+                    .Except(localResources)
+                    .ToList();
+            }
+
+            res.Created = toCreate;
+            res.Deleted = toDelete;
+            res.Updated = toUpdate;
+            res.Deployed = new List<IResource>();
+            res.Failed = new List<IResource>();
+
+            UpdateDuplicateResourceStatus(res, duplicateGroups, dryRun);
+
+            if (dryRun)
+            {
+                return res;
+            }
+
+            var createTasks = GetTasks(toCreate, m_Client.Create, res);
+            var updateTasks = GetTasks(toUpdate, m_Client.Update, res);
+            var deleteTasks = reconcile
+                ? GetTasks(toDelete, m_Client.Delete, res)
+                : new List<Task>();
+
+            var allTasks = createTasks.Concat(updateTasks).Concat(deleteTasks);
+
+            await Batching.Batching.ExecuteInBatchesAsync(allTasks, token);
+
+            return res;
+        }
+
+        // TODO: Add support for CancellationToken in m_Client.Create, m_Client.Update, m_Client.Delete
+        IEnumerable<Task> GetTasks(List<IResource> resources, Func<IResource, Task> func, DeployResult res)
+            => resources.Select(i => DeployResource(func, i, res));
+
+        protected virtual void UpdateStatus(
+            IResource resource,
+            DeploymentStatus status)
+        {
+            // clients can override this to provide user feedback on progress
+            resource.Status = status;
+        }
+
+        protected virtual void UpdateProgress(
+            IResource resource,
+            float progress)
+        {
+            // clients can override this to provide user feedback on progress
+            resource.Progress = progress;
+        }
+
+        void UpdateDuplicateResourceStatus(
+            DeployResult result,
+            IReadOnlyList<IGrouping<string, IResource>> duplicateGroups,
+            bool dryRun)
+        {
+            foreach (var group in duplicateGroups)
+            {
+                foreach (var res in group)
+                {
+                    result.Failed.Add(res);
+                    var (message, shortMessage) = DuplicateResourceValidation.GetDuplicateResourceErrorMessages(res, group.ToList());
+                    UpdateStatus(res, Statuses.GetFailedToDeploy(shortMessage));
+                }
+            }
+        }
+
+        async Task DeployResource(
+            Func<IResource, Task> task,
+            IResource resource,
+            DeployResult res)
+        {
+            try
+            {
+                await task(resource);
+                lock (m_ResultLock)
+                    res.Deployed.Add(resource);
+                UpdateStatus(resource, Statuses.Deployed);
+                UpdateProgress(resource, 100);
+            }
+            catch (Exception e)
+            {
+                lock (m_ResultLock)
+                    res.Failed.Add(resource);
+                UpdateStatus(resource, Statuses.GetFailedToDeploy(e.Message));
+            }
+        }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Fetch/FetchResult.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Fetch/FetchResult.cs
new file mode 100644
index 0000000..b1b51ce
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Fetch/FetchResult.cs
@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using Unity.Services.ModuleTemplate.Authoring.Core.Model;
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.Fetch
+{
+    public class FetchResult
+    {
+        public List<IResource> Created { get; set; }
+        public List<IResource> Updated { get; set; }
+        public List<IResource> Deleted { get; set; }
+        public List<IResource> Fetched { get; set; }
+        public List<IResource> Failed { get; set; }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Fetch/IModuleTemplateFetchHandler.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Fetch/IModuleTemplateFetchHandler.cs
new file mode 100644
index 0000000..82fd18d
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Fetch/IModuleTemplateFetchHandler.cs
@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Unity.Services.ModuleTemplate.Authoring.Core.Model;
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.Fetch
+{
+    public interface IModuleTemplateFetchHandler
+    {
+        public Task<FetchResult> FetchAsync(
+            string rootDirectory,
+            IReadOnlyList<IResource> localResources,
+            bool dryRun = false,
+            bool reconcile = false,
+            CancellationToken token = default);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Fetch/ModuleTemplateFetchHandler.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Fetch/ModuleTemplateFetchHandler.cs
new file mode 100644
index 0000000..2fa2c45
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Fetch/ModuleTemplateFetchHandler.cs
@@ -0,0 +1,163 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Unity.Services.DeploymentApi.Editor;
+using Unity.Services.ModuleTemplate.Authoring.Core.Deploy;
+using Unity.Services.ModuleTemplate.Authoring.Core.IO;
+using Unity.Services.ModuleTemplate.Authoring.Core.Model;
+using Unity.Services.ModuleTemplate.Authoring.Core.Service;
+using Unity.Services.ModuleTemplate.Authoring.Core.Validations;
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.Fetch
+{
+    public class ModuleTemplateFetchHandler : IModuleTemplateFetchHandler
+    {
+        readonly IModuleTemplateClient m_Client;
+        readonly IFileSystem m_FileSystem;
+
+        public ModuleTemplateFetchHandler(
+            IModuleTemplateClient client,
+            IFileSystem fileSystem)
+        {
+            m_Client = client;
+            m_FileSystem = fileSystem;
+        }
+
+        public async Task<FetchResult> FetchAsync(string rootDirectory,
+            IReadOnlyList<IResource> localResources,
+            bool dryRun = false,
+            bool reconcile = false,
+            CancellationToken token = default)
+        {
+            var res = new FetchResult();
+
+            localResources = DuplicateResourceValidation.FilterDuplicateResources(
+                localResources, out var duplicateGroups);
+
+            var remoteResources = await m_Client.List();
+
+            var toUpdate = remoteResources
+                .Intersect(localResources)
+                .ToList();
+
+            var toDelete = localResources
+                .Except(remoteResources)
+                .ToList();
+
+            var toCreate = new List<IResource>();
+            if (reconcile)
+            {
+                toCreate = remoteResources
+                    .Except(localResources)
+                    .ToList();
+            }
+
+            res.Created = toCreate;
+            res.Deleted = toDelete;
+            res.Updated = toUpdate;
+            res.Fetched = new List<IResource>();
+            res.Failed = new List<IResource>();
+
+            UpdateDuplicateResourceStatus(res, duplicateGroups, dryRun);
+
+            if (dryRun)
+            {
+                return res;
+            }
+
+            var updateTasks = new List<(IResource, Task)>();
+            var deleteTasks = new List<(IResource, Task)>();
+            var createTasks = new List<(IResource, Task)>();
+
+            foreach (var resource in toUpdate)
+            {
+                var task = m_FileSystem.WriteAllText(
+                    resource.Path,
+                    res.ToString(),
+                    token);
+                updateTasks.Add((resource, task));
+            }
+
+            foreach (var resource in toDelete)
+            {
+                var task = m_FileSystem.Delete(
+                    resource.Path,
+                    token);
+                deleteTasks.Add((resource, task));
+            }
+
+            if (reconcile)
+            {
+                foreach (var resource in toCreate)
+                {
+                    var task = m_FileSystem.WriteAllText(
+                        resource.Path,
+                        resource.Name,
+                        token);
+                    createTasks.Add((resource, task));
+                }
+            }
+
+            await UpdateResult(updateTasks, res);
+            await UpdateResult(deleteTasks, res);
+            await UpdateResult(createTasks, res);
+
+            return res;
+        }
+
+        protected virtual void UpdateStatus(
+            IResource resource,
+            DeploymentStatus status)
+        {
+            // clients can override this to provide user feedback on progress
+            resource.Status = status;
+        }
+
+        protected virtual void UpdateProgress(
+            IResource resource,
+            float progress)
+        {
+            // clients can override this to provide user feedback on progress
+            resource.Progress = progress;
+        }
+
+        void UpdateDuplicateResourceStatus(
+            FetchResult result,
+            IReadOnlyList<IGrouping<string, IResource>> duplicateGroups,
+            bool dryRun)
+        {
+            foreach (var group in duplicateGroups)
+            {
+                foreach (var res in group)
+                {
+                    result.Failed.Add(res);
+                    var (message, shortMessage) = DuplicateResourceValidation.GetDuplicateResourceErrorMessages(res, group.ToList());
+                    UpdateStatus(res, Statuses.GetFailedToFetch(shortMessage));
+                }
+            }
+        }
+
+        async Task UpdateResult(
+            List<(IResource, Task)> tasks,
+            FetchResult res)
+        {
+            foreach (var (resource, task) in tasks)
+            {
+                try
+                {
+                    await task;
+                    res.Fetched.Add(resource);
+                    UpdateStatus(resource, Statuses.Fetched);
+                    UpdateProgress(resource, 100);
+                }
+                catch (Exception e)
+                {
+                    res.Failed.Add(resource);
+                    UpdateStatus(resource, Statuses.GetFailedToFetch(e.Message));
+                }
+            }
+        }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/IO/IFileSystem.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/IO/IFileSystem.cs
new file mode 100644
index 0000000..4ddbb0b
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/IO/IFileSystem.cs
@@ -0,0 +1,19 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.IO
+{
+    public interface IFileSystem
+    {
+        Task<string> ReadAllText(
+            string path,
+            CancellationToken token = default(CancellationToken));
+
+        Task WriteAllText(
+            string path,
+            string contents,
+            CancellationToken token = default(CancellationToken));
+
+        Task Delete(string path, CancellationToken token = default(CancellationToken));
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Model/IResource.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Model/IResource.cs
new file mode 100644
index 0000000..36b93ce
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Model/IResource.cs
@@ -0,0 +1,10 @@
+using Unity.Services.DeploymentApi.Editor;
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.Model
+{
+    public interface IResource : IDeploymentItem, ITypedItem
+    {
+        string Id { get; }
+        new float Progress { get; set; }
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Model/Statuses.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Model/Statuses.cs
new file mode 100644
index 0000000..11d03e7
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Model/Statuses.cs
@@ -0,0 +1,20 @@
+using Unity.Services.DeploymentApi.Editor;
+
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.Model
+{
+    static class Statuses
+    {
+        public static readonly DeploymentStatus FailedToLoad = new ("Failed to load", string.Empty, SeverityLevel.Error);
+
+        public static DeploymentStatus GetFailedToFetch(string details)
+            => new ("Failed to fetch", details, SeverityLevel.Error);
+        public static readonly DeploymentStatus Fetching = new ("Fetching", string.Empty, SeverityLevel.Info);
+        public static readonly DeploymentStatus Fetched = new ("Fetched", string.Empty, SeverityLevel.Success);
+
+        public static DeploymentStatus GetFailedToDeploy(string details)
+            => new ("Failed to deploy", details, SeverityLevel.Error);
+        public static readonly DeploymentStatus Deploying = new ( "Deploying", string.Empty, SeverityLevel.Info);
+        public static readonly DeploymentStatus Deployed = new ("Deployed",  string.Empty, SeverityLevel.Success);
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Service/IModuleTemplateClient.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Service/IModuleTemplateClient.cs
new file mode 100644
index 0000000..8f4e0c5
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Service/IModuleTemplateClient.cs
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Unity.Services.ModuleTemplate.Authoring.Core.Model;
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.Service
+{
+    //This is a sample IServiceClient and might not map to your existing admin APIs
+    public interface IModuleTemplateClient
+    {
+        void Initialize(string environmentId, string projectId, CancellationToken cancellationToken);
+
+        Task<IResource> Get(string name);
+        Task Update(IResource resource);
+        Task Create(IResource resource);
+        Task Delete(IResource resource);
+        Task<IReadOnlyList<IResource>> List();
+    }
+}
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Unity.Services.ModuleTemplate.Authoring.Core.csproj b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Unity.Services.ModuleTemplate.Authoring.Core.csproj
new file mode 100644
index 0000000..746aef6
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Unity.Services.ModuleTemplate.Authoring.Core.csproj
@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net5.0</TargetFramework>
+    <Nullable>disable</Nullable>
+    <Version>0.0.1</Version>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <OutputType>Library</OutputType>
+    <IsPackable>true</IsPackable>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <!-- This matches the editor LangVersion -->
+    <LangVersion>9</LangVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+      <_Parameter1>$(AssemblyName).UnitTest</_Parameter1>
+    </AssemblyAttribute>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+      <_Parameter1>DynamicProxyGenAssembly2</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Unity.Services.DeploymentApi" Version="1.0.0-beta.1" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Validations/DuplicateResourceValidation.cs b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Validations/DuplicateResourceValidation.cs
new file mode 100644
index 0000000..a64171a
--- /dev/null
+++ b/Unity.Services.Cli/Unity.Services.ModuleTemplate.Authoring.Core/Validations/DuplicateResourceValidation.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Unity.Services.ModuleTemplate.Authoring.Core.Model;
+
+namespace Unity.Services.ModuleTemplate.Authoring.Core.Validations
+{
+    static class DuplicateResourceValidation
+    {
+        public static IReadOnlyList<IResource> FilterDuplicateResources(
+            IReadOnlyList<IResource> resources,
+            out IReadOnlyList<IGrouping<string, IResource>> duplicateGroups)
+        {
+            duplicateGroups = resources
+                .GroupBy(r => r.Id)
+                .Where(g => g.Count() > 1)
+                .ToList();
+
+            var hashset = new HashSet<string>(duplicateGroups.Select(g => g.Key));
+
+            return resources
+                .Where(r => !hashset.Contains(r.Id))
+                .ToList();
+        }
+
+        public static (string, string) GetDuplicateResourceErrorMessages(
+            IResource targetResource,
+            IReadOnlyList<IResource> group)
+        {
+            var duplicates = group
+                .Except(new[] { targetResource })
+                .ToList();
+
+            var duplicatesStr = string.Join(", ", duplicates.Select(d => $"'{d.Path}'"));
+            var shortMessage = $"'{targetResource.Path}' was found duplicated in other files: {duplicatesStr}";
+            var message = $"Multiple resources with the same identifier '{targetResource.Id}' were found. "
+                      + "Only a single resource for a given identifier may be deployed/fetched at the same time. "
+                      + "Give all resources unique identifiers or deploy/fetch them separately to proceed.\n"
+                      + shortMessage;
+            return (shortMessage, message);
+        }
+    }
+}
diff --git a/Unity.Services.Cli/test.rc/ugs.rczip b/Unity.Services.Cli/test.rc/ugs.rczip
new file mode 100644
index 0000000..f81d2a4
Binary files /dev/null and b/Unity.Services.Cli/test.rc/ugs.rczip differ
diff --git a/build.py b/build.py
index 5d3a48a..d3d3f27 100755
--- a/build.py
+++ b/build.py
@@ -6,23 +6,26 @@
 import stat
 import xml.etree.ElementTree as ET
 
-EXECUTABLE_NAME = "ugs"
 PROJECT_PATH = "Unity.Services.Cli/Unity.Services.Cli/Unity.Services.Cli.csproj"
 BUILD_DIR = "build"
 
 
+PLATFORMS = [
+    { "name": "Windows"             , "folder": "windows"    , "executable_name": "ugs.exe" , "arch": "win-x64"        , "skip_env_var": "SKIP_WINDOWS_BUILD"    },
+    { "name": "MacOS"               , "folder": "macos"      , "executable_name": "ugs"     , "arch": "osx-x64"        , "skip_env_var": "SKIP_MACOS_BUILD"      },
+    { "name": "Linux"               , "folder": "linux"      , "executable_name": "ugs"     , "arch": "linux-x64"      , "skip_env_var": "SKIP_LINUX_BUILD"      },
+    { "name": "Linux-Musl (Alpine)" , "folder": "linux-musl" , "executable_name": "ugs"     , "arch": "linux-musl-x64" , "skip_env_var": "SKIP_LINUX_MUSL_BUILD" },
+]
+
 def main():
     if not os.path.exists(BUILD_DIR):
         os.makedirs(BUILD_DIR)
 
-    create_version_file()
+    platforms_to_build = [platform for platform in PLATFORMS if platform.get("skip_env_var") not in os.environ]
 
-    skip_windows_build = "SKIP_WINDOWS_BUILD" in os.environ
-    skip_macos_build = "SKIP_MACOS_BUILD" in os.environ
-    skip_linux_build = "SKIP_LINUX_BUILD" in os.environ
-    skip_alpine_linux_build = "SKIP_ALPINE_LINUX_BUILD" in os.environ
+    create_version_file()
 
-    log_build_flow(skip_windows_build, skip_macos_build, skip_linux_build, skip_alpine_linux_build)
+    log_build_flow(platforms_to_build)
 
     args = parse_input()
     extra_defines = get_extra_defines(args)
@@ -31,10 +34,8 @@ def main():
     if len(extra_defines) > 0:
         base_build_command = base_build_command + " -p:ExtraDefineConstants=" + extra_defines
 
-    build_for_platform(base_build_command, "win-x64", "windows", skip_windows_build, ".exe")
-    build_for_platform(base_build_command, "osx-x64", "macos", skip_macos_build)
-    build_for_platform(base_build_command, "linux-x64", "linux", skip_linux_build)
-    build_for_platform(base_build_command, "linux-musl-x64", "linux-alpine", skip_alpine_linux_build)
+    for platform in platforms_to_build:
+        build_for_platform(base_build_command, platform)
 
 
 def create_version_file():
@@ -57,17 +58,9 @@ def create_version_file():
         version_file.write(cli_version)
 
 
-def log_build_flow(skip_windows_build, skip_macos_build, skip_linux_build, skip_alpine_linux_build):
-    included_platforms = ""
-    if not skip_windows_build:
-        included_platforms = included_platforms + " Windows"
-    if not skip_macos_build:
-        included_platforms = included_platforms + " MacOS"
-    if not skip_linux_build:
-        included_platforms = included_platforms + " Linux"
-    if not skip_alpine_linux_build:
-        included_platforms = included_platforms + " Linux(Alpine)"
-    print("Building " + EXECUTABLE_NAME + " for " + included_platforms + " in " + BUILD_DIR)
+def log_build_flow(platforms_to_build):
+    for platform in platforms_to_build:
+        print("Building " + platform["executable_name"] + " for " + platform["name"] + " in " + BUILD_DIR)
 
 
 def parse_input():
@@ -89,17 +82,12 @@ def get_extra_defines(args):
     return extra_defines
 
 
-def build_for_platform(base_build_command, platform_build_argument, platform_name, skip_build,
-                       executable_extension=""):
-    if skip_build:
-        print("Skipping " + platform_name + " build")
-        return
-
-    print("Building " + platform_name)
-    build_command = base_build_command + " -r " + platform_build_argument + " -o " + BUILD_DIR + "/" + platform_name + " /flp:--verbosity:diag /flp:logfile=build/build.log"
+def build_for_platform(base_build_command, platform):
+    print("Building " + platform["name"])
+    build_command = base_build_command + " -r " + platform["arch"] + " -o " + BUILD_DIR + "/" + platform["folder"] + " /flp:--verbosity:diag /flp:logfile=build/build.log"
     build_process_output = subprocess.run(build_command, shell=True, check=True)
     print(build_process_output)
-    executable_path = os.path.join(BUILD_DIR, platform_name, EXECUTABLE_NAME + executable_extension)
+    executable_path = os.path.join(BUILD_DIR, platform["folder"], platform["executable_name"])
     executable_stat = os.stat(executable_path)
     os.chmod(executable_path, executable_stat.st_mode | stat.S_IEXEC)
 
diff --git a/test.runsettings b/test.runsettings
index 80c944e..3ec2901 100644
--- a/test.runsettings
+++ b/test.runsettings
@@ -2,6 +2,7 @@
   <RunConfiguration>  
     <ResultsDirectory>./TestResults</ResultsDirectory>
     <SolutionDirectory>./TestResults</SolutionDirectory>
+    <TestSessionTimeout>1800000</TestSessionTimeout>
   </RunConfiguration>  
   <LoggerRunSettings>
     <Loggers>