@jumoo/usync 0.0.0-stage → 17.5.1

package/dist/workspace/views/legacy/legacy.element.js

@@ -0,0 +1,187 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SyncLegacyFilesElement_instances, _SyncLegacyFilesElement_actionContext, _SyncLegacyFilesElement_onCopy, _SyncLegacyFilesElement_onIgnore;
+import { css, customElement, html, nothing, state, } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { UMB_CONFIRM_MODAL, UMB_MODAL_MANAGER_CONTEXT, } from '@umbraco-cms/backoffice/modal';
+import { USYNC_CORE_CONTEXT_TOKEN, } from '@jumoo/uSync';
+let SyncLegacyFilesElement = class SyncLegacyFilesElement extends UmbLitElement {
+    constructor() {
+        super();
+        _SyncLegacyFilesElement_instances.add(this);
+        _SyncLegacyFilesElement_actionContext.set(this, void 0);
+        this.consumeContext(USYNC_CORE_CONTEXT_TOKEN, (_instance) => {
+            if (!_instance)
+                return;
+            __classPrivateFieldSet(this, _SyncLegacyFilesElement_actionContext, _instance, "f");
+            this.observe(_instance.legacy, (_legacy) => {
+                this._legacy = _legacy;
+            });
+        });
+    }
+    render() {
+        return html `<umb-body-layout>
+			${this.renderLegacyNote()} ${this.renderActions()}
+		</umb-body-layout>`;
+    }
+    renderLegacyNote() {
+        return html ` <uui-box headline="Legacy uSync files detected">
+			<p>
+				uSync has found an old uSync folder at
+				<strong>${this._legacy?.legacyFolder ?? ''}</strong>. It is likely that the
+				content will need converting in some way.
+			</p>
+			${this.renderLegacyTypes(this._legacy?.legacyTypes)}
+		</uui-box>`;
+    }
+    renderLegacyTypes(legacyTypes) {
+        if (legacyTypes == undefined || legacyTypes.length == 0) {
+            return nothing;
+        }
+        const legacyTypeHtml = legacyTypes.map((datatype) => {
+            return html `<li>${datatype}</li>`;
+        });
+        return html `
+			<div>
+				<h3>Obsolete DataTypes</h3>
+				<p>
+					The following DataTypes - found in the legacy folder - are no longer supported
+					in Umbraco 14+ and will need to be converted.
+				</p>
+				<ul>
+					${legacyTypeHtml}
+				</ul>
+				<p>
+					You can convert these DataTypes using
+					<a href="https://github.com/Jumoo/uSyncMigrations" target="_blank"
+						>uSync.Migrations</a
+					><br />
+				</p>
+			</div>
+		`;
+    }
+    renderActions() {
+        return html `
+			<div class="legacy-actions">
+				<uui-box>
+					<div class="actions">
+						<uui-button
+							label="copy"
+							color="positive"
+							look="primary"
+							@click=${__classPrivateFieldGet(this, _SyncLegacyFilesElement_instances, "m", _SyncLegacyFilesElement_onCopy)}
+							>Overwrite v${this._legacy?.latestVersion} folder</uui-button
+						>
+						<p>
+							Copy the contents of the legacy folder to the new
+							${this._legacy?.latestFolder} folder
+						</p>
+					</div>
+				</uui-box>
+
+				<uui-box>
+					<div class="actions">
+						<uui-button
+							label="ignore"
+							color="warning"
+							look="primary"
+							@click=${__classPrivateFieldGet(this, _SyncLegacyFilesElement_instances, "m", _SyncLegacyFilesElement_onIgnore)}
+							>Ignore legacy folder</uui-button
+						>
+						<p>Ignore the legacy folder and continue</p>
+					</div>
+				</uui-box>
+			</div>
+		`;
+    }
+};
+_SyncLegacyFilesElement_actionContext = new WeakMap();
+_SyncLegacyFilesElement_instances = new WeakSet();
+_SyncLegacyFilesElement_onCopy = async function _SyncLegacyFilesElement_onCopy() {
+    const modalContext = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
+    const confirmContext = modalContext?.open(this, UMB_CONFIRM_MODAL, {
+        data: {
+            headline: this.localize.termOrDefault('uSync_legacyCopyTitle', 'Overwrite files', this._legacy?.latestVersion),
+            content: html `${this.localize.termOrDefault('uSync_legacyCopyContent', 'Are you sure you want to overwrite the contents of the folder with the legacy uSync folder files?', this._legacy?.latestFolder)}`,
+            color: 'danger',
+            confirmLabel: 'Copy',
+        },
+    });
+    confirmContext
+        ?.onSubmit()
+        .then(async () => {
+        await __classPrivateFieldGet(this, _SyncLegacyFilesElement_actionContext, "f")?.copyLegacy();
+        window.location.reload();
+    })
+        .catch(() => {
+        console.log('copy cancelled by user');
+    });
+};
+_SyncLegacyFilesElement_onIgnore = async function _SyncLegacyFilesElement_onIgnore() {
+    const modalContext = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
+    const confirmContext = modalContext?.open(this, UMB_CONFIRM_MODAL, {
+        data: {
+            headline: this.localize.termOrDefault('uSync_legacyIgnoreTitle', 'Ignore legacy files'),
+            content: html `${this.localize.termOrDefault('uSync_legacyIgnoreContent', 'Are you sure you want to ignore the files in the legacy uSync folder?')}`,
+            color: 'danger',
+            confirmLabel: 'Ignore',
+        },
+    });
+    confirmContext
+        ?.onSubmit()
+        .then(async () => {
+        await __classPrivateFieldGet(this, _SyncLegacyFilesElement_actionContext, "f")?.ignoreLegacy();
+        window.location.reload();
+    })
+        .catch(() => {
+        console.log('ignore cancelled by user');
+    });
+};
+SyncLegacyFilesElement.styles = css `
+		uui-box {
+			margin-bottom: var(--uui-size-3);
+		}
+
+		.legacy-actions {
+			display: flex;
+			gap: var(--uui-size-space-4);
+			justify-content: space-between;
+		}
+
+		.legacy-actions uui-box {
+			flex-basis: 50%;
+		}
+
+		.legacy-actions .actions {
+			display: flex;
+			flex-direction: column;
+			align-items: center;
+		}
+
+		uui-button {
+			font-size: var(--uui-type-h5-size);
+		}
+	`;
+__decorate([
+    state()
+], SyncLegacyFilesElement.prototype, "_legacy", void 0);
+SyncLegacyFilesElement = __decorate([
+    customElement('usync-sync-legacy-files')
+], SyncLegacyFilesElement);
+export { SyncLegacyFilesElement };
+export default SyncLegacyFilesElement;

package/dist/workspace/views/settings/components/usyncSettingItem.element.d.ts

@@ -0,0 +1,15 @@
+import { LitElement } from '@umbraco-cms/backoffice/external/lit';
+export declare class uSyncSettingItemElement extends LitElement {
+    #private;
+    name?: string;
+    description?: string;
+    value?: Object | null | undefined;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult;
+}
+export default uSyncSettingItemElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'usync-setting-item': uSyncSettingItemElement;
+    }
+}

package/dist/workspace/views/settings/components/usyncSettingItem.element.js

@@ -0,0 +1,96 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _uSyncSettingItemElement_instances, _uSyncSettingItemElement_renderValue;
+import { LitElement, classMap, css, customElement, html, property, } from '@umbraco-cms/backoffice/external/lit';
+let uSyncSettingItemElement = class uSyncSettingItemElement extends LitElement {
+    constructor() {
+        super(...arguments);
+        _uSyncSettingItemElement_instances.add(this);
+    }
+    render() {
+        return html `
+			<div class="usync-setting-value">
+				<div class="info">
+					<h5>${this.name}</h5>
+					<div>${this.description}</div>
+				</div>
+				<div class="value">${__classPrivateFieldGet(this, _uSyncSettingItemElement_instances, "m", _uSyncSettingItemElement_renderValue).call(this)}</div>
+			</div>
+		`;
+    }
+};
+_uSyncSettingItemElement_instances = new WeakSet();
+_uSyncSettingItemElement_renderValue = function _uSyncSettingItemElement_renderValue() {
+    if (this.value === undefined || this.value === null) {
+        return html `(Not Set)`;
+    }
+    if (typeof this.value == 'boolean') {
+        const classes = { _set: this.value };
+        return html `
+				<uui-icon
+					name=${this.value ? 'icon-check' : 'icon-wrong'}
+					class=${classMap(classes)}></uui-icon>
+			`;
+    }
+    else {
+        if (Array.isArray(this.value)) {
+            const list = this.value.map((v) => {
+                return html `<li>${v}</li>`;
+            });
+            return html `<ul>
+					${list}
+				</ul>`;
+        }
+        else {
+            return html ` <div>${this.value}</div> `;
+        }
+    }
+};
+uSyncSettingItemElement.styles = css `
+		.usync-setting-value {
+			display: flex;
+			justify-content: space-between;
+			padding: var(--uui-size-space-2) 0;
+			border-bottom: 1px solid var(--uui-color-divider);
+		}
+
+		.usync-setting-value h5 {
+			margin: 0;
+			padding: 0;
+		}
+
+		uui-icon {
+			color: var(--uui-color-danger);
+		}
+
+		uui-icon._set {
+			color: var(--uui-color-positive);
+		}
+
+		ul {
+			list-style: none;
+		}
+	`;
+__decorate([
+    property({ type: String })
+], uSyncSettingItemElement.prototype, "name", void 0);
+__decorate([
+    property({ type: String })
+], uSyncSettingItemElement.prototype, "description", void 0);
+__decorate([
+    property()
+], uSyncSettingItemElement.prototype, "value", void 0);
+uSyncSettingItemElement = __decorate([
+    customElement('usync-setting-item')
+], uSyncSettingItemElement);
+export { uSyncSettingItemElement };
+export default uSyncSettingItemElement;

package/dist/workspace/views/settings/settings.element.d.ts

@@ -0,0 +1,17 @@
+import { LitElement } from '@umbraco-cms/backoffice/external/lit';
+import { USyncHandlerSetSettings, USyncSettings } from '@jumoo/uSync';
+export * from './components/usyncSettingItem.element.js';
+declare const USyncSettingsViewElement_base: import("@umbraco-cms/backoffice/extension-api").HTMLElementConstructor<import("@umbraco-cms/backoffice/element-api").UmbElement> & typeof LitElement;
+export declare class USyncSettingsViewElement extends USyncSettingsViewElement_base {
+    settings?: USyncSettings;
+    handlerSettings?: USyncHandlerSetSettings;
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult;
+}
+export default USyncSettingsViewElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'usync-settings-view': USyncSettingsViewElement;
+    }
+}

package/dist/workspace/views/settings/settings.element.js

@@ -0,0 +1,174 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { UmbElementMixin } from '@umbraco-cms/backoffice/element-api';
+import { LitElement, css, customElement, html, state, when, } from '@umbraco-cms/backoffice/external/lit';
+import { USYNC_CORE_CONTEXT_TOKEN, } from '@jumoo/uSync';
+export * from './components/usyncSettingItem.element.js';
+let USyncSettingsViewElement = class USyncSettingsViewElement extends UmbElementMixin(LitElement) {
+    constructor() {
+        super();
+        this.consumeContext(USYNC_CORE_CONTEXT_TOKEN, (_instance) => {
+            if (!_instance)
+                return;
+            this.observe(_instance.settings, (_settings) => {
+                if (!_settings)
+                    return;
+                this.settings = _settings;
+                _instance.getDefaultHandlerSetSettings(this.settings.defaultSet ?? 'Default');
+            });
+            this.observe(_instance.handlerSettings, (_handlerSettings) => {
+                if (!_handlerSettings)
+                    return;
+                this.handlerSettings = _handlerSettings;
+            });
+            _instance.getSettings();
+        });
+    }
+    render() {
+        return html `
+			<umb-body-layout>
+				<div class="usync-settings-layout">
+					<div>
+						<uui-box headline=${this.localize.termOrDefault('USyncSettings_settings', 'uSync Settings')}>
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_processingMode', 'Processing Mode')}
+								.description=${this.localize.termOrDefault('USyncSettings_processingModeDesc', 'How the uSync process runs, either in the background or interactively (Normal)')}
+								.value=${this.settings?.processingMode}></usync-setting-item>
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_importAtStartup', 'Import at startup')}
+								.description=${this.localize.termOrDefault('USyncSettings_importAtStartupDesc', 'Run an import of files from the disk when Umbraco starts')}
+								.value=${this.settings?.importAtStartup}></usync-setting-item>
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_exportAtStartup', 'Export at startup')}
+								.description=${this.localize.termOrDefault('USyncSettings_exportAtStartupDesc', 'Export the Umbraco settings when the site starts up')}
+								.value=${this.settings?.exportAtStartup}></usync-setting-item>
+
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_exportOnSave', 'Export on save')}
+								.description=${this.localize.termOrDefault('USyncSettings_exportOnSaveDesc', 'Generate uSync files when items are saved')}
+								.value=${this.settings?.exportOnSave}></usync-setting-item>
+
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_uiEnabledGroups', 'UI Enabled groups')}
+								.description=${this.localize.termOrDefault('USyncSettings_uiEnabledGroupsDesc', 'Handler groups that can be seen/used on the dashboard')}
+								.value=${this.settings?.uiEnabledGroups}></usync-setting-item>
+
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_failOnMissingParent', 'Fail on missing parent')}
+								.description=${this.localize.termOrDefault('USyncSettings_failOnMissingParentDesc', 'Fail on missing parent')}
+								.value=${this.settings?.failOnMissingParent}></usync-setting-item>
+						</uui-box>
+
+						<uui-box headline=${this.localize.termOrDefault('USyncSettings_filesAndFolders', 'File and folders')}>
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_rootSite', 'Root Site')}
+								.description=${this.localize.termOrDefault('USyncSettings_rootSiteDesc', 'Is this site a root for other sites.')}
+								.value=${this.settings?.isRootSite}></usync-setting-item>
+
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_rootLocked', 'Root Locked')}
+								.description=${this.localize.termOrDefault('USyncSettings_rootLockedDesc', 'Are changes for items that are from the root site locked?')}
+								.value=${this.settings?.lockRoot}></usync-setting-item>
+
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_folders', 'Folders')}
+								.description=${this.localize.termOrDefault('USyncSettings_foldersDesc', 'Folders uSync will look for files, (items are normally saved into last folder in the list)')}
+								.value=${this.settings?.folders}></usync-setting-item>
+						</uui-box>
+					</div>
+
+					<div>
+						<uui-box headline=${this.localize.termOrDefault('USyncSettings_handlerDefaults', 'Handler defaults')}>
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_handlerSet', 'Default handler set')}
+								.description=${this.localize.termOrDefault('USyncSettings_handlerSetDesc', 'The default handler set to use for the site')}
+								.value=${this.settings?.defaultSet}></usync-setting-item>
+
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_flatStructure', 'Flat structure')}
+								.description=${this.localize.termOrDefault('USyncSettings_flatStructureDesc', 'All items of a type are stored in a flat folder structure')}
+								.value=${this.handlerSettings?.handlerDefaults
+            ?.useFlatStructure}></usync-setting-item>
+
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_guidNames', 'Use guids for filenames')}
+								.description=${this.localize.termOrDefault('USyncSettings_guidNamesDesc', 'Use the GUID of an item as the filename')}
+								.value=${this.handlerSettings?.handlerDefaults
+            ?.guidNames}></usync-setting-item>
+
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_handlerGroups', 'Handler groups')}
+								.description=${this.localize.termOrDefault('USyncSettings_handlerGroupsDesc', 'Groups to limit handler set to')}
+								.value=${this.handlerSettings?.handlerDefaults
+            ?.group}></usync-setting-item>
+
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_failOnMissingParent', 'Fail on missing parent')}
+								.description=${this.localize.termOrDefault('USyncSettings_failOnMissingParentDesc', 'Fail on missing parent')}
+								.value=${this.handlerSettings?.handlerDefaults
+            ?.failOnMissingParent}></usync-setting-item>
+
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_disabledHandlers', 'Disabled Handlers')}
+								.description=${this.localize.termOrDefault('USyncSettings_disabledHandlersDesc', 'Handlers explicitly disabled for this handler set')}
+								.value=${this.handlerSettings?.disabledHandlers}></usync-setting-item>
+						</uui-box>
+						<uui-box headline=${this.localize.termOrDefault('USyncSettings_bootSettings', 'First boot settings')}>
+							<usync-setting-item
+								.name=${this.localize.termOrDefault('USyncSettings_firstBoot', 'Import on First boot')}
+								.description=${this.localize.termOrDefault('USyncSettings_firstBootDesc', 'Run the import process on first boot of the site')}
+								.value=${this.settings?.importOnFirstBoot}></usync-setting-item>
+							${when(this.settings?.importOnFirstBoot, () => html ` <usync-setting-item
+										.name=${this.localize.termOrDefault('USyncSettings_firstBootGroup', 'First boot groups')}
+										.description=${this.localize.termOrDefault('USyncSettings_firstBootGroupDesc', 'The groups to run on first boot')}
+										.value=${this.settings?.firstBootGroup}></usync-setting-item>`)}
+						</uui-box>
+					</div>
+				</div>
+				<div class="setting-link">
+					<umb-localize key="USyncSettings_help"></umb-localize>
+				</div>
+			</umb-body-layout>
+		`;
+    }
+};
+USyncSettingsViewElement.styles = css `
+		:host {
+			display: block;
+		}
+
+		.usync-settings-layout {
+			display: grid;
+			grid-template-columns: 5fr 5fr;
+			grid-template-rows: auto auto;
+			gap: var(--uui-size-space-5);
+			row-gap: var(--uui-size-space-5);
+			grid-auto-flow: row;
+			grid-template-areas: 'settings info', 'handler info';
+		}
+
+		.usync-settings-layout > div {
+			display: flex;
+			flex-direction: column;
+			gap: var(--uui-size-space-6);
+		}
+
+		.setting-link {
+			text-align: center;
+		}
+	`;
+__decorate([
+    state()
+], USyncSettingsViewElement.prototype, "settings", void 0);
+__decorate([
+    state()
+], USyncSettingsViewElement.prototype, "handlerSettings", void 0);
+USyncSettingsViewElement = __decorate([
+    customElement('usync-settings-view')
+], USyncSettingsViewElement);
+export { USyncSettingsViewElement };
+export default USyncSettingsViewElement;

package/dist/workspace/workspace.context.d.ts

@@ -0,0 +1,74 @@
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { SyncActionGroup, SyncHandlerSummary, SyncLegacyCheckResponse, USyncActionView, USyncHandlerSetSettings, USyncSettings, SyncPerformActionOptions, SyncSelectableSet, SyncFileVersionCheckResult } from '@jumoo/uSync';
+import { UmbWorkspaceContext } from '@umbraco-cms/backoffice/workspace';
+/**
+ * Context for getting and seting up actions.
+ */
+export declare class uSyncWorkspaceContext extends UmbControllerBase implements UmbWorkspaceContext {
+    #private;
+    readonly workspaceAlias: string;
+    getEntityType(): string;
+    readonly actions: import("rxjs").Observable<SyncActionGroup[]>;
+    private _currentSetName;
+    readonly workingGroup: import("rxjs").Observable<SyncActionGroup | undefined>;
+    readonly currentAction: import("rxjs").Observable<SyncHandlerSummary[]>;
+    readonly working: import("rxjs").Observable<boolean>;
+    readonly inBackground: import("rxjs").Observable<boolean>;
+    readonly completed: import("rxjs").Observable<boolean>;
+    readonly results: import("rxjs").Observable<USyncActionView[]>;
+    readonly settings: import("rxjs").Observable<USyncSettings | undefined>;
+    readonly handlerSettings: import("rxjs").Observable<USyncHandlerSetSettings | undefined>;
+    readonly sets: import("rxjs").Observable<SyncSelectableSet[]>;
+    readonly legacy: import("rxjs").Observable<SyncLegacyCheckResponse | undefined>;
+    readonly syncFileInfo: import("rxjs").Observable<SyncFileVersionCheckResult | undefined>;
+    constructor(host: UmbControllerHost);
+    hostDisconnected(): void;
+    /**
+     * Return the current actions from the repository
+     */
+    getActions(setName: string): Promise<void>;
+    /**
+     * Get the current uSync settings
+     */
+    getSettings(): Promise<USyncSettings | undefined>;
+    getAddons(): Promise<import("@jumoo/uSync").USyncAddonInfo>;
+    getSyncFileInfo(): Promise<SyncFileVersionCheckResult>;
+    /**
+     * Check to see if there is a legacy uSync folder on disk.
+     */
+    checkLegacy(): Promise<SyncLegacyCheckResponse | undefined>;
+    ignoreLegacy(): Promise<boolean>;
+    copyLegacy(): Promise<boolean>;
+    /**
+     * Get handler defaults.
+     */
+    getDefaultHandlerSetSettings(setName: string): Promise<void>;
+    getHandlerSets(): Promise<void>;
+    /**
+     * Perform an action (e.g import, export, etc) with options
+     * @param options options for the action
+     */
+    performAction(options: SyncPerformActionOptions): Promise<void>;
+    /**
+     * Manually clear a stuck "running in background" state - a workaround for
+     * when the server that was running the sync crashed or restarted and this
+     * client is left showing it as still active. This only resets what THIS
+     * client shows; it does not (and cannot - Umbraco's long-running-operation
+     * service has no cancel API) force the server-side operation to end. If
+     * the run really is still active elsewhere, starting a new one will still
+     * be rejected until the server-side run actually finishes or its
+     * expiration window passes (a few minutes by default).
+     */
+    dismissBackgroundRun(): void;
+    uploadFile(): Promise<boolean | undefined>;
+    downloadFile(): Promise<void>;
+    importSingle(item: USyncActionView): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: USyncActionView;
+        request: Request;
+        response: Response;
+    }> | undefined>;
+}
+export default uSyncWorkspaceContext;
+export declare const USYNC_CORE_CONTEXT_TOKEN: UmbContextToken<uSyncWorkspaceContext, uSyncWorkspaceContext>;