Started project

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessGluonUpdateProgress.cs

@@ -0,0 +1,50 @@
+using System;
+
+using UnityEditor;
+
+using Codice.Client.BaseCommands;
+using GluonGui.WorkspaceWindow.Views.WorkspaceExplorer.Explorer;
+using PlasticGui;
+
+namespace Unity.PlasticSCM.Editor.Toolbar.Headless
+{
+    internal class HeadlessGluonUpdateProgress : IUpdateProgress
+    {
+        void IUpdateProgress.ShowNoCancelableProgress()
+        {
+            if (mProgressId != -1)
+                Progress.Finish(mProgressId);
+
+            mProgressId = Progress.Start(
+                PlasticLocalization.GetString(PlasticLocalization.Name.UpdatingWorkspace));
+        }
+
+        void IUpdateProgress.EndProgress()
+        {
+            Progress.Finish(mProgressId);
+            mProgressId = -1;
+        }
+
+        void IUpdateProgress.RefreshProgress(
+            UpdateProgress updateProgress,
+            UpdateProgressData updateProgressData)
+        {
+            if (mProgressId == -1)
+                return;
+
+            float value = (float)updateProgressData.ProgressValue / 100f;
+
+            Progress.Report(
+                mProgressId,
+                value,
+                updateProgressData.Status);
+        }
+
+        void IUpdateProgress.ShowCancelableProgress()
+        {
+            throw new NotImplementedException();
+        }
+
+        int mProgressId = -1;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessGluonUpdateProgress.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f111698d5aafb61479afc143e389a014
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessGluonUpdateReport.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+
+using Codice.CM.Common;
+using GluonGui.WorkspaceWindow.Views.WorkspaceExplorer.Explorer;
+using PlasticGui.Gluon;
+using Unity.PlasticSCM.Editor.Gluon.UpdateReport;
+
+namespace Unity.PlasticSCM.Editor.Toolbar.Headless
+{
+    internal class HeadlessGluonUpdateReport : IUpdateReport
+    {
+        void IUpdateReport.AppendReport(string updateReport) { }
+
+        UpdateReportResult IUpdateReport.ShowUpdateReport(
+            WorkspaceInfo wkInfo,
+            List<ErrorMessage> errors)
+        {
+            return UpdateReportDialog.ShowUpdateReport(
+                wkInfo, errors, null);
+        }
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessGluonUpdateReport.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d8da5f578b092c047880b2897f1adf08
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessGluonViewHost.cs

@@ -0,0 +1,57 @@
+using GluonGui;
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Toolbar.Headless
+{
+    internal class HeadlessGluonViewHost
+    {
+        internal ViewHost ViewHost { get { return mViewHost; } }
+
+        internal HeadlessGluonViewHost(IRefreshableView branchesListPopupPanel)
+        {
+            mViewHost = new ViewHost();
+
+            mViewHost.AddRefreshableView(
+                ViewType.BranchesListPopup,
+                branchesListPopupPanel);
+            mViewHost.AddRefreshableView(
+                ViewType.PendingChangesView,
+                new RefreshableView(ViewType.PendingChangesView));
+            mViewHost.AddRefreshableView(
+                ViewType.IncomingChangesView,
+                new RefreshableView(ViewType.IncomingChangesView));
+            mViewHost.AddRefreshableView(
+                ViewType.BranchesView,
+                new RefreshableView(ViewType.BranchesView));
+            mViewHost.AddRefreshableView(
+                ViewType.ChangesetsView,
+                new RefreshableView(ViewType.ChangesetsView));
+            mViewHost.AddRefreshableView(
+                ViewType.HistoryView,
+                new RefreshableView(ViewType.HistoryView));
+        }
+
+        ViewHost mViewHost;
+
+        class RefreshableView : IRefreshableView
+        {
+            internal RefreshableView(ViewType viewType)
+            {
+                mViewType = viewType;
+            }
+
+            void IRefreshableView.Refresh()
+            {
+                UVCSWindow window = GetWindowIfOpened.UVCS();
+
+                if (window == null)
+                    return;
+
+                window.ViewHost.RefreshView(mViewType);
+            }
+
+            readonly ViewType mViewType;
+        }
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessGluonViewHost.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a863d083557069b458628045916c1724
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessMergeViewLauncher.cs

@@ -0,0 +1,83 @@
+using Codice.CM.Common;
+
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Merge;
+
+namespace Unity.PlasticSCM.Editor.Toolbar.Headless
+{
+    internal class HeadlessMergeViewLauncher : IMergeViewLauncher
+    {
+        internal HeadlessMergeViewLauncher(UVCSPlugin uvcsPlugin)
+        {
+            mUVCSPlugin = uvcsPlugin;
+        }
+
+        IMergeView IMergeViewLauncher.FromCalculatedMerge(
+            RepositorySpec repSpec,
+            ObjectInfo objectInfo,
+            EnumMergeType mergeType,
+            CalculatedMergeResult calculatedMergeResult,
+            bool showDiscardChangesButton)
+        {
+            UVCSWindow window = SwitchUVCSPlugin.OnIfNeeded(mUVCSPlugin);
+
+            return window.IMergeViewLauncher.FromCalculatedMerge(
+                repSpec,
+                objectInfo,
+                mergeType,
+                calculatedMergeResult,
+                showDiscardChangesButton);
+        }
+
+        IMergeView IMergeViewLauncher.MergeFrom(
+            RepositorySpec repSpec,
+            ObjectInfo objectInfo,
+            EnumMergeType mergeType,
+            bool showDiscardChangesButton)
+        {
+            UVCSWindow window = SwitchUVCSPlugin.OnIfNeeded(mUVCSPlugin);
+
+            return window.IMergeViewLauncher.MergeFrom(
+                repSpec,
+                objectInfo,
+                mergeType,
+                showDiscardChangesButton);
+        }
+
+        IMergeView IMergeViewLauncher.MergeFrom(
+            RepositorySpec repSpec,
+            ObjectInfo objectInfo,
+            EnumMergeType mergeType,
+            ShowIncomingChangesFrom from,
+            bool showDiscardChangesButton)
+        {
+            UVCSWindow window = SwitchUVCSPlugin.OnIfNeeded(mUVCSPlugin);
+
+            return window.IMergeViewLauncher.MergeFrom(
+                repSpec,
+                objectInfo,
+                mergeType,
+                from,
+                showDiscardChangesButton);
+        }
+
+        IMergeView IMergeViewLauncher.MergeFromInterval(
+            RepositorySpec repSpec,
+            ObjectInfo objectInfo,
+            ObjectInfo ancestorChangesetInfo,
+            EnumMergeType mergeType,
+            bool showDiscardChangesButton)
+        {
+            UVCSWindow window = SwitchUVCSPlugin.OnIfNeeded(mUVCSPlugin);
+
+            return window.IMergeViewLauncher.MergeFromInterval(
+                repSpec,
+                objectInfo,
+                ancestorChangesetInfo,
+                mergeType,
+                showDiscardChangesButton);
+        }
+
+        readonly UVCSPlugin mUVCSPlugin;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessMergeViewLauncher.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1b0473213bc885840bb309ebce32b6fb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessProgressControls.cs

@@ -0,0 +1,45 @@
+using UnityEditor;
+
+using PlasticGui;
+
+namespace Unity.PlasticSCM.Editor.Toolbar.Headless
+{
+    internal class HeadlessProgressControls : IProgressControls
+    {
+        void IProgressControls.ShowProgress(string message)
+        {
+            if (mProgressId != -1)
+                Progress.Finish(mProgressId);
+
+            mProgressId = Progress.Start(message, null, Progress.Options.Indefinite);
+        }
+
+        void IProgressControls.HideProgress()
+        {
+            Progress.Finish(mProgressId);
+            mProgressId = -1;
+        }
+
+        void IProgressControls.ShowError(string message)
+        {
+            UnityEngine.Debug.LogError(message);
+        }
+
+        void IProgressControls.ShowNotification(string message)
+        {
+            UnityEngine.Debug.Log(message);
+        }
+
+        void IProgressControls.ShowSuccess(string message)
+        {
+            UnityEngine.Debug.Log(message);
+        }
+
+        void IProgressControls.ShowWarning(string message)
+        {
+            UnityEngine.Debug.LogWarning(message);
+        }
+
+        int mProgressId = -1;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessProgressControls.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f957d659be9dee74fb0f993b67b2d044
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessUpdateProgress.cs

@@ -0,0 +1,59 @@
+using System;
+
+using UnityEditor;
+
+using Codice.Client.BaseCommands;
+using Codice.Client.Commands;
+using PlasticGui.WorkspaceWindow;
+using PlasticGui.WorkspaceWindow.Update;
+
+namespace Unity.PlasticSCM.Editor.Toolbar.Headless
+{
+    internal class HeadlessUpdateProgress
+    {
+        internal void ShowUpdateProgress(string title, UpdateNotifier notifier)
+        {
+            mProgressData = new BuildProgressSpeedAndRemainingTime.ProgressData(DateTime.Now);
+
+            if (mProgressId == -1)
+                Progress.Finish(mProgressId);
+
+            mProgressId = Progress.Start(title);
+            mUpdateProgressNotifier = notifier;
+
+            EditorApplication.update += UpdateProgress;
+        }
+
+        internal void EndUpdateProgress()
+        {
+            EditorApplication.update -= UpdateProgress;
+            Progress.Finish(mProgressId);
+            mProgressId = -1;
+        }
+
+        internal bool IsOperationRunning()
+        {
+            return mProgressId != -1;
+        }
+
+        void UpdateProgress()
+        {
+            if (mProgressId == -1)
+                return;
+
+            UpdateOperationStatus status = mUpdateProgressNotifier.GetUpdateStatus();
+
+            float progress = GetProgressBarPercent.ForTransfer(
+                status.UpdatedSize, status.TotalSize) / 100f;
+
+            Progress.Report(
+                mProgressId,
+                progress,
+                UpdateProgressRender.GetProgressString(status, mProgressData));
+        }
+
+        int mProgressId = -1;
+        UpdateNotifier mUpdateProgressNotifier;
+        BuildProgressSpeedAndRemainingTime.ProgressData mProgressData;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessUpdateProgress.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d7826644a043a9b4cb6b1f06c937cad7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessUpdateReport.cs

@@ -0,0 +1,19 @@
+using System.Collections;
+
+using Codice.CM.Common;
+using PlasticGui.WorkspaceWindow.Update;
+using Unity.PlasticSCM.Editor.Developer.UpdateReport;
+
+namespace Unity.PlasticSCM.Editor.Toolbar.Headless
+{
+    internal class HeadlessUpdateReport : IUpdateReport
+    {
+        void IUpdateReport.Show(WorkspaceInfo wkInfo, IList reportLines)
+        {
+            UpdateReportDialog.ShowReportDialog(
+                wkInfo,
+                reportLines,
+                null);
+        }
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessUpdateReport.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3c1571ec0b185dc428a1df774086a310
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessViewSwitcher.cs

@@ -0,0 +1,98 @@
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Toolbar.Headless
+{
+    internal class HeadlessViewSwitcher : IViewSwitcher
+    {
+        void IViewSwitcher.CloseMergeView()
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return;
+
+            window.IViewSwitcher.CloseMergeView();
+        }
+
+        void IViewSwitcher.DisableMergeView()
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return;
+
+            window.IViewSwitcher.DisableMergeView();
+        }
+
+        IMergeView IViewSwitcher.GetMergeView()
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return null;
+
+            return window.IViewSwitcher.GetMergeView();
+        }
+
+        bool IViewSwitcher.IsIncomingChangesView()
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return false;
+
+            return window.IViewSwitcher.IsIncomingChangesView();
+        }
+
+        void IViewSwitcher.ShowBranchExplorerView()
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return;
+
+            window.IViewSwitcher.ShowBranchExplorerView();
+        }
+
+        void IViewSwitcher.ShowPendingChanges()
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return;
+
+            window.IViewSwitcher.ShowPendingChanges();
+        }
+
+        void IViewSwitcher.ShowShelvesView()
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return;
+
+            window.IViewSwitcher.ShowShelvesView();
+        }
+
+        void IViewSwitcher.ShowSyncView(string syncViewToSelect)
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return;
+
+            window.IViewSwitcher.ShowSyncView(syncViewToSelect);
+        }
+
+        void IViewSwitcher.ShowView(ViewType viewType)
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return;
+
+            window.IViewSwitcher.ShowView(viewType);
+        }
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessViewSwitcher.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e5854d1a1c573e040afdbb54103decf3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessWorkspaceStatusChangeListener.cs

@@ -0,0 +1,30 @@
+using System;
+
+using PlasticGui.Gluon;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Toolbar.Headless
+{
+    internal class HeadlessWorkspaceStatusChangeListener : IWorkspaceStatusChangeListener
+    {
+        internal HeadlessWorkspaceStatusChangeListener(Action refreshWorkspaceWorkingInfo)
+        {
+            mRefreshWorkspaceWorkingInfo = refreshWorkspaceWorkingInfo;
+        }
+
+        void IWorkspaceStatusChangeListener.OnWorkspaceStatusChanged()
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+            {
+                mRefreshWorkspaceWorkingInfo();
+                return;
+            }
+
+            window.IWorkspaceStatusChangeListener.OnWorkspaceStatusChanged();
+        }
+
+        readonly Action mRefreshWorkspaceWorkingInfo;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessWorkspaceStatusChangeListener.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c00693f5365e54a4eb5f9ac96da13749
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessWorkspaceWindow.cs

@@ -0,0 +1,184 @@
+using System;
+using System.Collections.Generic;
+
+using Codice.Client.BaseCommands;
+using Codice.Client.Commands.CheckIn;
+using Codice.CM.Common;
+using Codice.CM.Common.Replication;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow;
+using PlasticGui.WorkspaceWindow.Replication;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Toolbar.Headless
+{
+    internal class HeadlessWorkspaceWindow : IWorkspaceWindow
+    {
+        internal HeadlessWorkspaceWindow(
+            IRefreshableView branchesListPopupPanel,
+            Action refreshWorkspaceWorkingInfo,
+            Action<BranchInfo> setWorkingBranch)
+        {
+            mBranchesListPopupPanel = branchesListPopupPanel;
+            mRefreshWorkspaceWorkingInfo = refreshWorkspaceWorkingInfo;
+            mSetWorkingBranch = setWorkingBranch;
+            mUpdateProgress = new HeadlessUpdateProgress();
+        }
+
+        void IWorkspaceWindow.UpdateTitle()
+        {
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+            {
+                mRefreshWorkspaceWorkingInfo();
+                return;
+            }
+
+            window.IWorkspaceWindow.UpdateTitle();
+        }
+
+        bool IWorkspaceWindow.CheckOperationInProgress()
+        {
+            return mUpdateProgress.IsOperationRunning();
+        }
+
+        bool IWorkspaceWindow.IsOperationInProgress()
+        {
+            return mUpdateProgress.IsOperationRunning();
+        }
+
+        void IWorkspaceWindow.ShowUpdateProgress(string title, UpdateNotifier notifier)
+        {
+            mUpdateProgress.ShowUpdateProgress(title, notifier);
+        }
+
+        void IWorkspaceWindow.EndUpdateProgress()
+        {
+            mUpdateProgress.EndUpdateProgress();
+        }
+
+        void IWorkspaceWindow.RefreshWorkingObjectViews(WorkingObjectInfo workingObjectInfo)
+        {
+            if (workingObjectInfo != null && workingObjectInfo.BranchInfo != null)
+                mSetWorkingBranch(workingObjectInfo.BranchInfo);
+
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return;
+
+            window.IWorkspaceWindow.RefreshWorkingObjectViews(workingObjectInfo);
+        }
+
+        void IWorkspaceWindow.RefreshView(ViewType viewType)
+        {
+            if (viewType == ViewType.BranchesListPopup)
+            {
+                mBranchesListPopupPanel.Refresh();
+                return;
+            }
+
+            UVCSWindow window = GetWindowIfOpened.UVCS();
+
+            if (window == null)
+                return;
+
+            window.IWorkspaceWindow.RefreshView(viewType);
+        }
+
+        void IWorkspaceWindow.EndCheckinProgress()
+        {
+            throw new NotImplementedException();
+        }
+
+        void IWorkspaceWindow.EndProgress()
+        {
+            throw new NotImplementedException();
+        }
+
+        void IWorkspaceWindow.EndReplicationProgress(ReplicationStatus replicationStatus)
+        {
+            throw new NotImplementedException();
+        }
+
+        List<IDisposable> IWorkspaceWindow.GetRegisteredViews()
+        {
+            throw new NotImplementedException();
+        }
+
+        bool IWorkspaceWindow.HasCheckinCancelled()
+        {
+            throw new NotImplementedException();
+        }
+
+        void IWorkspaceWindow.RefreshCheckinProgress(
+            CheckinStatus checkinStatus,
+            BuildProgressSpeedAndRemainingTime.ProgressData progressState)
+        {
+            throw new NotImplementedException();
+        }
+
+        void IWorkspaceWindow.RefreshProgress(ProgressData progressData)
+        {
+            throw new NotImplementedException();
+        }
+
+        void IWorkspaceWindow.RefreshReplicationProgress(
+            BranchReplicationData replicationData,
+            ReplicationStatus replicationStatus,
+            int current,
+            int total)
+        {
+            throw new NotImplementedException();
+        }
+
+        void IWorkspaceWindow.RegisterView(
+            ViewType type,
+            IDisposable disposable,
+            IRefreshableView refreshable,
+            IWorkingObjectRefreshableView workingObjectRefreshableView)
+        {
+            throw new NotImplementedException();
+        }
+
+        EncryptionConfigurationDialogData IWorkspaceWindow.RequestEncryptionPassword(string server)
+        {
+            throw new NotImplementedException();
+        }
+
+        void IWorkspaceWindow.ShowCheckinProgress()
+        {
+            throw new NotImplementedException();
+        }
+
+        void IWorkspaceWindow.ShowProgress()
+        {
+            throw new NotImplementedException();
+        }
+
+        void IWorkspaceWindow.ShowProgress(IProgressOperation progressOperation)
+        {
+            throw new NotImplementedException();
+        }
+
+        void IWorkspaceWindow.ShowReplicationProgress(IReplicationOperation replicationOperation)
+        {
+            throw new NotImplementedException();
+        }
+
+        void IWorkspaceWindow.UnregisterView(
+            ViewType type,
+            IDisposable disposable,
+            IRefreshableView refreshable,
+            IWorkingObjectRefreshableView workingObjectRefreshableView)
+        {
+            throw new NotImplementedException();
+        }
+
+        readonly IRefreshableView mBranchesListPopupPanel;
+        readonly Action mRefreshWorkspaceWorkingInfo;
+        readonly Action<BranchInfo> mSetWorkingBranch;
+        readonly HeadlessUpdateProgress mUpdateProgress;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy@3351acaba9c9/Editor/UVCSToolbar/Headless/HeadlessWorkspaceWindow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fd582245e61fe1f4dba625a9ba7ec139
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: