@jumoo/usync-expansions 0.0.0-stage → 18.3.0

package/dist/licence/manifest.js

@@ -0,0 +1,30 @@
+import { manifests as localizations } from './lang/manifests.js';
+import { UMB_CURRENT_USER_IS_ADMIN_CONDITION_ALIAS } from '@umbraco-cms/backoffice/current-user';
+const licenceContext = {
+    type: 'globalContext',
+    alias: 'usync.licence.context',
+    name: 'uSync licence context',
+    js: () => import('./licence.context.js'),
+};
+const licenceView = {
+    type: 'workspaceView',
+    alias: 'usync-extensions-licence-view',
+    name: 'uSync Licence view',
+    js: () => import('./licence.element.js'),
+    weight: 100,
+    meta: {
+        label: 'Licence',
+        pathname: 'licence',
+        icon: 'icon-certificate',
+    },
+    conditions: [
+        {
+            alias: 'Umb.Condition.WorkspaceAlias',
+            match: 'usync.workspace',
+        },
+        {
+            alias: UMB_CURRENT_USER_IS_ADMIN_CONDITION_ALIAS,
+        },
+    ],
+};
+export const manifests = [licenceContext, licenceView, ...localizations];

package/dist/licence/source/licence.source.d.ts

@@ -0,0 +1,15 @@
+import { UmbDataSourceResponse } from '@umbraco-cms/backoffice/repository';
+import { Licence, LicenceInfo, LicenceStatusView } from '@jumoo/usync-expansions';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+export interface uSyncLicenceSource {
+}
+export declare class uSyncLicenceSource implements uSyncLicenceSource {
+    #private;
+    constructor(host: UmbControllerHost);
+    checkLegacy(product: string, version: string): Promise<UmbDataSourceResponse<string>>;
+    getLicence(product: string, version: string): Promise<UmbDataSourceResponse<Licence>>;
+    getLicenceInfo(product: string, version: string): Promise<UmbDataSourceResponse<LicenceInfo>>;
+    getLicenceStatus(product: string, version: string): Promise<UmbDataSourceResponse<LicenceStatusView>>;
+    isLicenced(product: string, version: string): Promise<UmbDataSourceResponse<boolean>>;
+    saveLicence(licence: LicenceInfo): Promise<UmbDataSourceResponse<boolean>>;
+}

package/dist/licence/source/licence.source.js

@@ -0,0 +1,39 @@
+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 _uSyncLicenceSource_host;
+import { LicenceService, } from '@jumoo/usync-expansions';
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
+export class uSyncLicenceSource {
+    constructor(host) {
+        _uSyncLicenceSource_host.set(this, void 0);
+        __classPrivateFieldSet(this, _uSyncLicenceSource_host, host, "f");
+    }
+    async checkLegacy(product, version) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.checkLegacy({ query: { product: product, version: version } }));
+    }
+    async getLicence(product, version) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.getLicence({ query: { product: product, version: version } }));
+    }
+    async getLicenceInfo(product, version) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.getLicence({ query: { product: product, version: version } }));
+    }
+    async getLicenceStatus(product, version) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.getLicenceStatus({ query: { product: product, version: version } }));
+    }
+    async isLicenced(product, version) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.isLicenced({ query: { product: product, version: version } }));
+    }
+    async saveLicence(licence) {
+        return await tryExecute(__classPrivateFieldGet(this, _uSyncLicenceSource_host, "f"), LicenceService.saveLicence({ body: licence }));
+    }
+}
+_uSyncLicenceSource_host = new WeakMap();

package/dist/menu/manifest.d.ts

@@ -0,0 +1 @@
+export declare const manifests: import("@jumoo/usync").ManifestuSyncMenuItem[];

package/dist/menu/manifest.js

@@ -0,0 +1,12 @@
+const menuItem = {
+    type: 'usync-menuItem',
+    alias: 'usync.menu.extensions',
+    name: 'extensions',
+    meta: {
+        label: 'Extensions',
+        icon: 'icon-brick',
+        entityType: 'usync-menu-entry',
+        menus: ['usync.menu'],
+    },
+};
+export const manifests = [menuItem];

package/dist/restore/components/index.d.ts

@@ -0,0 +1 @@
+export * from './restore-point-table.element';

package/dist/restore/components/index.js

@@ -0,0 +1 @@
+export * from './restore-point-table.element';

package/dist/restore/components/restore-point-table.element.d.ts

@@ -0,0 +1,21 @@
+import { nothing } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { RestorePoint } from '@jumoo/usync-expansions';
+import { UmbTableColumn, UmbTableConfig } from '@umbraco-cms/backoffice/components';
+/**
+ * @element usync-restore-point-table
+ * @property {Array<RestorePoint>} restorePoints - The restore points to display
+ * @fires delete-restore-point - When the delete options is selected
+ * @fires restore-restore-point - When the restore options is selected
+ */
+export declare class uSyncRestorePointTableElement extends UmbLitElement {
+    #private;
+    restorePoints?: RestorePoint[];
+    _tableConfig: UmbTableConfig;
+    _tableColumns: UmbTableColumn[];
+    filter: any;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    renderStatus(restorePoint: RestorePoint): import("lit-html").TemplateResult<1>;
+    renderActions(restorePoint: RestorePoint): import("lit-html").TemplateResult<1>;
+}
+export default uSyncRestorePointTableElement;

package/dist/restore/components/restore-point-table.element.js

@@ -0,0 +1,126 @@
+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 _uSyncRestorePointTableElement_instances, _uSyncRestorePointTableElement_onDelete, _uSyncRestorePointTableElement_onRestore;
+import { customElement, html, nothing, property, state, } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { RestorePointStatus } from '@jumoo/usync-expansions';
+import { TimeOptions } from '../constants';
+/**
+ * @element usync-restore-point-table
+ * @property {Array<RestorePoint>} restorePoints - The restore points to display
+ * @fires delete-restore-point - When the delete options is selected
+ * @fires restore-restore-point - When the restore options is selected
+ */
+let uSyncRestorePointTableElement = class uSyncRestorePointTableElement extends UmbLitElement {
+    constructor() {
+        super(...arguments);
+        _uSyncRestorePointTableElement_instances.add(this);
+        this._tableConfig = {
+            allowSelection: false,
+            hideIcon: false,
+        };
+        this._tableColumns = [
+            { name: 'Created', alias: 'created' },
+            { name: 'Name', alias: 'name' },
+            { name: 'Source', alias: 'action' },
+            { name: 'User', alias: 'user' },
+            { name: 'Status', alias: 'status' },
+            { name: '', alias: 'actions' },
+        ];
+    }
+    render() {
+        if (!this.restorePoints || this.restorePoints.length === 0)
+            return nothing;
+        const items = this.restorePoints
+            .map((restorePoint) => {
+            if (!restorePoint)
+                return undefined;
+            return {
+                id: restorePoint.key,
+                icon: 'icon-pushpin',
+                data: [
+                    {
+                        columnAlias: 'created',
+                        value: this.localize.date(restorePoint.created, TimeOptions),
+                    },
+                    { columnAlias: 'name', value: restorePoint.name },
+                    { columnAlias: 'action', value: restorePoint.action },
+                    { columnAlias: 'user', value: restorePoint.user },
+                    { columnAlias: 'status', value: html `${this.renderStatus(restorePoint)}` },
+                    { columnAlias: 'actions', value: html `${this.renderActions(restorePoint)}` },
+                ],
+            };
+        })
+            .filter((item) => item !== undefined);
+        return html `<umb-table
+			.config=${this._tableConfig}
+			.columns=${this._tableColumns}
+			.items=${items}
+			.filter=${this.filter}></umb-table>`;
+    }
+    renderStatus(restorePoint) {
+        switch (restorePoint.status) {
+            case RestorePointStatus.PENDING:
+                return html `<uui-tag color="warning" look="secondary">Compressing</uui-tag>`;
+            case RestorePointStatus.FAILED:
+                return html `<uui-tag color="danger" look="secondary">Failed</uui-tag>`;
+            case RestorePointStatus.COMPLETE:
+            default:
+                return html `<uui-tag color="positive" look="secondary">Complete</uui-tag>`;
+        }
+    }
+    renderActions(restorePoint) {
+        const isComplete = restorePoint.status === RestorePointStatus.COMPLETE || restorePoint.status === undefined;
+        return html ` <uui-button
+				compact
+				label="restore"
+				color="positive"
+				look="default"
+				?disabled=${!isComplete}
+				@click=${() => __classPrivateFieldGet(this, _uSyncRestorePointTableElement_instances, "m", _uSyncRestorePointTableElement_onRestore).call(this, restorePoint)}>
+				<uui-icon name="icon-paper-plane"></uui-icon>
+			</uui-button>
+
+			<uui-button
+				compact
+				label="delete"
+				color="danger"
+				look="default"
+				@click=${() => __classPrivateFieldGet(this, _uSyncRestorePointTableElement_instances, "m", _uSyncRestorePointTableElement_onDelete).call(this, restorePoint)}>
+				<uui-icon name="icon-trash"></uui-icon>
+			</uui-button>`;
+    }
+};
+_uSyncRestorePointTableElement_instances = new WeakSet();
+_uSyncRestorePointTableElement_onDelete = function _uSyncRestorePointTableElement_onDelete(restorePoint) {
+    this.dispatchEvent(new CustomEvent('delete-restore-point', { detail: restorePoint }));
+};
+_uSyncRestorePointTableElement_onRestore = function _uSyncRestorePointTableElement_onRestore(restorePoint) {
+    this.dispatchEvent(new CustomEvent('restore-restore-point', { detail: restorePoint }));
+};
+__decorate([
+    property({ type: Array })
+], uSyncRestorePointTableElement.prototype, "restorePoints", void 0);
+__decorate([
+    state()
+], uSyncRestorePointTableElement.prototype, "_tableConfig", void 0);
+__decorate([
+    state()
+], uSyncRestorePointTableElement.prototype, "_tableColumns", void 0);
+__decorate([
+    state()
+], uSyncRestorePointTableElement.prototype, "filter", void 0);
+uSyncRestorePointTableElement = __decorate([
+    customElement('usync-restore-point-table')
+], uSyncRestorePointTableElement);
+export { uSyncRestorePointTableElement };
+export default uSyncRestorePointTableElement;

package/dist/restore/constants.d.ts

@@ -0,0 +1,23 @@
+export declare const uSyncRestore: {
+    workspace: string;
+    context: string;
+    entity: string;
+    element: string;
+    icon: string;
+    processing: {
+        pipeline: string;
+        strategies: {
+            create: string;
+            restore: string;
+            report: string;
+            createAndRestore: string;
+        };
+    };
+    steps: {
+        restoreCreateStep: string;
+        restoreCreateComplete: string;
+        restoreReportConfigStep: string;
+        restoreReportStep: string;
+    };
+};
+export declare const TimeOptions: Intl.DateTimeFormatOptions;

package/dist/restore/constants.js

@@ -0,0 +1,30 @@
+export const uSyncRestore = {
+    workspace: 'usync.restore.workspace',
+    context: 'usync.restore.workspace.context',
+    entity: 'usync-restore-entry',
+    element: 'usync-restore-workspace-element',
+    icon: 'icon-paper-plane',
+    processing: {
+        pipeline: 'restorePointsPipeline',
+        strategies: {
+            create: 'restorePointCreate',
+            restore: 'restorePointRestore',
+            report: 'restorePointReport',
+            createAndRestore: 'restorePointCreateAndRestore',
+        },
+    },
+    steps: {
+        restoreCreateStep: 'usync-restore-create-config',
+        restoreCreateComplete: 'usync-restore-create-complete',
+        restoreReportConfigStep: 'usync-restore-report-config',
+        restoreReportStep: 'usync-restore-report',
+    },
+};
+export const TimeOptions = {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric',
+};

package/dist/restore/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/restore/index.js

@@ -0,0 +1,8 @@
+// import './components';
+export {};
+// export * from './constants.js';
+// export * from './restore.context.js';
+// export * from './restore.repository.js';
+// export * from './workspace/restore.workspace.context.js';
+// export * from './workspace/restore.workspace.element.js';
+// export * from './workspace/restore.workspace-view.element.js';

package/dist/restore/lang/en.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    uSync: {
+        IUser: string;
+        IUserGroup: string;
+        IMember: string;
+        IMemberGroup: string;
+    };
+    uSyncRestore: {
+        title: string;
+        intro: string;
+        scan: string;
+        restoreLatest: string;
+        create: string;
+        createIntro: string;
+        createSummary: string;
+        restorePoints: string;
+        restoreTitle: string;
+        restoreIntro: string;
+        restoreCheck: string;
+        restoreInfo: string;
+    };
+};
+export default _default;

package/dist/restore/lang/en.js

@@ -0,0 +1,33 @@
+export default {
+    uSync: {
+        IUser: 'Users',
+        IUserGroup: 'User groups',
+        IMember: 'Members',
+        IMemberGroup: 'Member groups',
+    },
+    uSyncRestore: {
+        title: 'Restore points',
+        intro: `<p>
+			Restore points can be created manually, or as part of a process such as a push or pull from
+			another site
+		</p>
+		<p>
+			By default only the last 10 restore points are kept, you can restore from any restore point, but you migth 
+			well loose your current content, setting or files as part of the process.
+		</p>`,
+        scan: 'Scan restore folder',
+        restoreLatest: 'Restore from latest',
+        create: 'Create a restore point',
+        createIntro: 'Type a description to help you identify the restore point.<br/>The current date and time are added automatically',
+        createSummary: 'Your restore point has been created.',
+        restorePoints: 'Restore points',
+        restoreTitle: 'Restore Umbraco settings and content',
+        restoreIntro: `
+			<p>A restore can help fix problems the might be causing your site to not work show the right content</p>
+			<p>A restore will reset all the settings, content and (if included media), back to the way it was at the specified point in time.</p>
+			<p style="color: var(--uui-color-danger)">You will loose any changes that you have made this this restore point, so you should be sure you want to restore.</p>
+			`,
+        restoreCheck: 'Check restore',
+        restoreInfo: 'Restore to this point?',
+    },
+};

package/dist/restore/lang/manifest.d.ts

@@ -0,0 +1 @@
+export declare const manifests: UmbExtensionManifest[];

package/dist/restore/lang/manifest.js

@@ -0,0 +1,11 @@
+const localizations = [
+    {
+        type: 'localization',
+        alias: 'usync-restore-enus',
+        name: 'uSync Restore English (US)',
+        weight: 0,
+        meta: { culture: 'en' },
+        js: () => import('./en'),
+    },
+];
+export const manifests = [...localizations];

package/dist/restore/manifest.d.ts

@@ -0,0 +1 @@
+export declare const manifests: import("@umbraco-cms/backoffice/extension-api").ManifestBase[];

package/dist/restore/manifest.js

@@ -0,0 +1,63 @@
+import { manifests as stepManifests } from './steps/manifest';
+import { manifests as localizationManifests } from './lang/manifest';
+import { uSyncRestore } from './constants';
+const workspaceAlias = uSyncRestore.workspace;
+const restoreMenuItem = {
+    type: 'usync-menuItem',
+    alias: 'usync.restore.menu.item',
+    name: 'restore',
+    weight: 10,
+    meta: {
+        label: 'Restore',
+        icon: uSyncRestore.icon,
+        entityType: uSyncRestore.element,
+        menus: ['usync.menu'],
+    },
+};
+const restoreWorkspaceContext = {
+    type: 'workspaceContext',
+    alias: uSyncRestore.context,
+    name: 'uSync Restore',
+    js: () => import('./workspace/restore.workspace.context'),
+    conditions: [
+        {
+            alias: 'Umb.Condition.WorkspaceAlias',
+            match: workspaceAlias,
+        },
+    ],
+};
+const restoreWorkspace = {
+    type: 'workspace',
+    alias: workspaceAlias,
+    name: 'uSync Restore',
+    js: () => import('./workspace/restore.workspace.element'),
+    meta: {
+        entityType: uSyncRestore.element,
+    },
+};
+const restoreWorkspaceView = {
+    type: 'workspaceView',
+    alias: 'usync.restore.workspace.view',
+    name: 'uSync Restore points view',
+    js: () => import('./workspace/restore.workspace-view.element'),
+    weight: 100,
+    meta: {
+        label: 'Restore points',
+        pathname: 'restore-points',
+        icon: uSyncRestore.icon,
+    },
+    conditions: [
+        {
+            alias: 'Umb.Condition.WorkspaceAlias',
+            match: workspaceAlias,
+        },
+    ],
+};
+export const manifests = [
+    restoreMenuItem,
+    restoreWorkspaceContext,
+    restoreWorkspace,
+    restoreWorkspaceView,
+    ...stepManifests,
+    ...localizationManifests,
+];

package/dist/restore/restore.context.d.ts

@@ -0,0 +1,10 @@
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+export declare class SyncRestoreContext extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    getRestorePoint(key: string): Promise<import("..").RestorePoint | undefined>;
+}
+export default SyncRestoreContext;
+export declare const USYNC_RESTORE_CONTEXT: UmbContextToken<SyncRestoreContext, SyncRestoreContext>;

package/dist/restore/restore.context.js

@@ -0,0 +1,29 @@
+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 _SyncRestoreContext_respository;
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import SyncRestoreRepository from './restore.repository';
+export class SyncRestoreContext extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        _SyncRestoreContext_respository.set(this, void 0);
+        __classPrivateFieldSet(this, _SyncRestoreContext_respository, new SyncRestoreRepository(this), "f");
+        this.provideContext(USYNC_RESTORE_CONTEXT, this);
+    }
+    async getRestorePoint(key) {
+        return await __classPrivateFieldGet(this, _SyncRestoreContext_respository, "f").get(key);
+    }
+}
+_SyncRestoreContext_respository = new WeakMap();
+export default SyncRestoreContext;
+export const USYNC_RESTORE_CONTEXT = new UmbContextToken('usync-restore-context');

package/dist/restore/restore.repository.d.ts

@@ -0,0 +1,15 @@
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+export declare class SyncRestoreRepository extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    clean(): Promise<unknown>;
+    remove(id: string): Promise<unknown>;
+    getAll(): Promise<import("..").RestorePoint[] | undefined>;
+    get(key: string): Promise<import("..").RestorePoint | undefined>;
+    getReport(id: string): Promise<import("..").USyncAction[] | undefined>;
+    scan(): Promise<{
+        [key: string]: string | number;
+    } | undefined>;
+}
+export default SyncRestoreRepository;

package/dist/restore/restore.repository.js

@@ -0,0 +1,43 @@
+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 _SyncRestoreRepository_host;
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
+import { RestoreService } from '../api';
+export class SyncRestoreRepository extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        _SyncRestoreRepository_host.set(this, void 0);
+        __classPrivateFieldSet(this, _SyncRestoreRepository_host, host, "f");
+    }
+    async clean() {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.clean())).data;
+    }
+    async remove(id) {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.remove({ query: { id } }))).data;
+    }
+    async getAll() {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.getAll())).data;
+    }
+    async get(key) {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.getRestorePoint({ query: { key } }))).data;
+    }
+    async getReport(id) {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.getReport({ query: { id } })))
+            .data;
+    }
+    async scan() {
+        return (await tryExecute(__classPrivateFieldGet(this, _SyncRestoreRepository_host, "f"), RestoreService.scan())).data;
+    }
+}
+_SyncRestoreRepository_host = new WeakMap();
+export default SyncRestoreRepository;

package/dist/restore/steps/manifest.d.ts

@@ -0,0 +1 @@
+export declare const manifests: UmbExtensionManifest[];

package/dist/restore/steps/manifest.js

@@ -0,0 +1,36 @@
+import { uSyncRestore } from '../constants';
+const restoreStepManifests = [
+    {
+        type: 'jumoo-process-step',
+        alias: uSyncRestore.steps.restoreCreateStep,
+        name: 'Create restore point step',
+        weight: 100,
+        js: () => import('./restore-create-element'),
+        elementName: uSyncRestore.steps.restoreCreateStep,
+    },
+    {
+        type: 'jumoo-process-step',
+        alias: uSyncRestore.steps.restoreCreateComplete,
+        name: 'Restore complete',
+        weight: 200,
+        js: () => import('./restore-create-complete'),
+        elementName: uSyncRestore.steps.restoreCreateComplete,
+    },
+    {
+        type: 'jumoo-process-step',
+        alias: uSyncRestore.steps.restoreReportConfigStep,
+        name: 'Restore step',
+        weight: 300,
+        js: () => import('./restore-report-config-element'),
+        elementName: uSyncRestore.steps.restoreReportConfigStep,
+    },
+    {
+        type: 'jumoo-process-step',
+        alias: uSyncRestore.steps.restoreReportStep,
+        name: 'Restore report',
+        weight: 400,
+        js: () => import('./restore-report-element'),
+        elementName: uSyncRestore.steps.restoreReportStep,
+    },
+];
+export const manifests = [...restoreStepManifests];

package/dist/restore/steps/restore-create-complete.d.ts

@@ -0,0 +1,6 @@
+import { ProcessStepElement, ProcessStepElementBase } from '@jumoo/processing';
+export declare class uSyncRestoreCreateCompleteElement extends ProcessStepElementBase implements ProcessStepElement {
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}
+export default uSyncRestoreCreateCompleteElement;

package/dist/restore/steps/restore-create-complete.js

@@ -0,0 +1,33 @@
+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 { ProcessStepElementBase, } from '@jumoo/processing';
+import { customElement, html } from '@umbraco-cms/backoffice/external/lit';
+import { uSyncRestore } from '../constants';
+let uSyncRestoreCreateCompleteElement = class uSyncRestoreCreateCompleteElement extends ProcessStepElementBase {
+    constructor() {
+        super();
+    }
+    render() {
+        const results = this.results;
+        const options = this.options;
+        return html `<uui-box>
+			<p>
+				Restore point created:
+				<strong>${options.title}</strong>
+			</p>
+
+			<umb-localize key="uSyncRestore_createComplete"></umb-localize>
+
+			<p>Contains ${results.results['changes'] ?? 'unknown'} items</p>
+		</uui-box>`;
+    }
+};
+uSyncRestoreCreateCompleteElement = __decorate([
+    customElement(uSyncRestore.steps.restoreCreateComplete)
+], uSyncRestoreCreateCompleteElement);
+export { uSyncRestoreCreateCompleteElement };
+export default uSyncRestoreCreateCompleteElement;