@jumoo/usync-expansions 0.0.0-stage → 18.3.0

package/dist/api/types.gen.d.ts

@@ -0,0 +1,520 @@
+export type ClientOptions = {
+    baseUrl: 'https://localhost:44385/' | (string & {});
+};
+export declare enum ChangeDetailType {
+    NO_CHANGE = "NoChange",
+    CREATE = "Create",
+    UPDATE = "Update",
+    DELETE = "Delete",
+    ERROR = "Error",
+    WARNING = "Warning"
+}
+export declare enum ChangeType {
+    NO_CHANGE = "NoChange",
+    CREATE = "Create",
+    IMPORT = "Import",
+    EXPORT = "Export",
+    UPDATE = "Update",
+    DELETE = "Delete",
+    WILL_CHANGE = "WillChange",
+    INFORMATION = "Information",
+    ROLLEDBACK = "Rolledback",
+    FAIL = "Fail",
+    IMPORT_FAIL = "ImportFail",
+    MISMATCH = "Mismatch",
+    PARENT_MISSING = "ParentMissing",
+    HIDDEN = "Hidden",
+    CLEAN = "Clean",
+    REMOVED = "Removed"
+}
+export type Exception = {
+    targetSite?: MethodBase;
+    message: null | string;
+    data: null | {
+        [key: string]: unknown;
+    };
+    innerException?: Exception;
+    helpLink?: null | string;
+    source?: null | string;
+    hResult: number | string;
+    stackTrace?: null | string;
+};
+export type Licence = {
+    key: string;
+    domains: string;
+    expiry: string;
+    licenceType: LicenceType;
+    lastCheck: string;
+    autoRenews: boolean;
+    products: null | Array<LicencedProduct>;
+    message?: null | string;
+    checkedDomain?: null | string;
+};
+export type LicencedProduct = {
+    name?: null | string;
+    version?: null | string;
+    valid: boolean;
+};
+export type LicenceInfo = {
+    domains: string;
+    key: string;
+};
+export declare enum LicenceStatus {
+    LOADED = "Loaded",
+    BAD_FORMAT = "BadFormat",
+    INVALID = "Invalid",
+    BAD_HOST = "BadHost",
+    EXPIRED = "Expired",
+    TRIAL_EXPIRED = "TrialExpired",
+    UNVERIFIED = "Unverified",
+    MISSING = "Missing",
+    VALID = "Valid",
+    TRIAL = "Trial"
+}
+export type LicenceStatusView = {
+    show: boolean;
+    type?: null | string;
+    message?: null | string;
+    link?: null | string;
+    linkTitle?: null | string;
+    expires: string;
+    status: LicenceStatus;
+    licenceType: LicenceType;
+    checkedDomain?: null | string;
+    hasExpiry: boolean;
+    autoRenews: boolean;
+};
+export declare enum LicenceType {
+    NONE = "None",
+    DOMAIN = "Domain",
+    SUBSCRIPTION = "Subscription",
+    TRIAL = "Trial",
+    LIMITED_EXPIRY = "LimitedExpiry",
+    AGENCY = "Agency",
+    PARTNER = "Partner"
+}
+export type MethodBase = unknown;
+export type RestorePoint = {
+    id: number | string;
+    key: string;
+    machineId: string;
+    machineName: string;
+    name: string;
+    action: string;
+    user: string;
+    created: string;
+    status: RestorePointStatus;
+};
+export type RestorePointProcessingOptions = {
+    source?: null | string;
+    title?: null | string;
+    user?: null | string;
+    key: string;
+    includeMedia: boolean;
+    isInline: boolean;
+    items: Array<{
+        flags: string;
+        change: 'NoChange' | 'Create' | 'Import' | 'Export' | 'Update' | 'Delete' | 'WillChange' | 'Information' | 'Rolledback' | 'Fail' | 'ImportFail' | 'Mismatch' | 'ParentMissing' | 'Hidden' | 'Clean' | 'Removed';
+        name: string;
+        icon?: null | string;
+        udi: {
+            uriValue: null | string;
+            entityType: null | string;
+            isRoot: boolean;
+        };
+        entityType: null | string;
+    }>;
+    options?: {
+        primaryType?: null | string;
+        removeOrphans: boolean;
+        includeFiles: boolean;
+        includeFileHash: boolean;
+        includeContent: boolean;
+        includeSystemFileHash: boolean;
+        includeSystemFiles: boolean;
+        includeMediaFiles: boolean;
+        cultures: Array<string>;
+        custom: {
+            [key: string]: string;
+        };
+        enableRollback: boolean;
+        createRestorePoint: boolean;
+        skipReport: boolean;
+    };
+    attributes?: {
+        orphanTypes: Array<string>;
+        folders: Array<string>;
+        systemFolders: Array<string>;
+        systemExclusions: Array<string>;
+        fileReplacements: Array<string>;
+    };
+    includeDisabledHandlers?: null | boolean;
+    handlerSet?: null | string;
+    handlerGroup?: null | string;
+    isBackgroundRequest?: null | boolean;
+    persistResults: boolean;
+    additionalData?: null | {
+        [key: string]: unknown;
+    };
+};
+export declare enum RestorePointStatus {
+    COMPLETE = "Complete",
+    PENDING = "Pending",
+    FAILED = "Failed"
+}
+export declare enum SyncDependencyFlags {
+    NONE = "None",
+    INCLUDE_CHILDREN = "IncludeChildren",
+    INCLUDE_ANCESTORS = "IncludeAncestors",
+    INCLUDE_DEPENDENCIES = "IncludeDependencies",
+    INCLUDE_VIEWS = "IncludeViews",
+    INCLUDE_MEDIA = "IncludeMedia",
+    INCLUDE_LINKED = "IncludeLinked",
+    INCLUDE_MEDIA_FILES = "IncludeMediaFiles",
+    INCLUDE_CONFIG = "IncludeConfig",
+    ADJACENT_ONLY = "AdjacentOnly",
+    ROOT_SYNC = "RootSync",
+    INCLUDE_CONTENTS = "IncludeContents",
+    PUBLISHED_DEPENDENCIES = "PublishedDependencies"
+}
+export type SyncEntity = {
+    name: string;
+    icon?: null | string;
+    udi: UdiModel;
+    entityType: null | string;
+};
+export type UdiModel = {
+    uriValue: null | string;
+    entityType: null | string;
+    isRoot: boolean;
+};
+export type USyncAction = {
+    handlerAlias?: null | string;
+    success: boolean;
+    itemType: string;
+    message?: null | string;
+    exception?: null | Exception;
+    change: ChangeType;
+    fileName?: null | string;
+    name: string;
+    path?: null | string;
+    requiresPostProcessing: boolean;
+    detailMessage?: null | string;
+    details?: null | Array<USyncChange>;
+    key: string;
+};
+export type USyncActionView = {
+    key: string;
+    name: string;
+    handler: string;
+    itemType: string;
+    change: ChangeType;
+    success: boolean;
+    details: Array<USyncChange>;
+    message?: null | string;
+};
+export type USyncChange = {
+    success: boolean;
+    name: string;
+    path: string;
+    oldValue: string;
+    newValue: string;
+    change: ChangeDetailType;
+};
+export type HasRootFilesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Complete/HasRootFiles';
+};
+export type HasRootFilesErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type HasRootFilesResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type HasRootFilesResponse = HasRootFilesResponses[keyof HasRootFilesResponses];
+export type GetActionViewData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Complete/GetActionViewModel';
+};
+export type GetActionViewErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Not Found
+     */
+    404: unknown;
+};
+export type GetActionViewResponses = {
+    /**
+     * OK
+     */
+    200: USyncActionView;
+};
+export type GetActionViewResponse = GetActionViewResponses[keyof GetActionViewResponses];
+export type GetSyncItemData = {
+    body?: never;
+    path?: never;
+    query?: {
+        entityType?: string;
+        id?: string;
+    };
+    url: '/umbraco/usync/api/v1/Complete/GetSyncItem';
+};
+export type GetSyncItemErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetSyncItemResponses = {
+    /**
+     * OK
+     */
+    200: SyncEntity;
+};
+export type GetSyncItemResponse = GetSyncItemResponses[keyof GetSyncItemResponses];
+export type CheckLegacyData = {
+    body?: never;
+    path?: never;
+    query?: {
+        product?: string;
+        version?: string;
+    };
+    url: '/umbraco/usync/api/v1/Complete/CheckLegacy';
+};
+export type CheckLegacyErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type CheckLegacyResponses = {
+    /**
+     * OK
+     */
+    200: string;
+};
+export type CheckLegacyResponse = CheckLegacyResponses[keyof CheckLegacyResponses];
+export type GetLicenceData = {
+    body?: never;
+    path?: never;
+    query?: {
+        product?: string;
+        version?: string;
+    };
+    url: '/umbraco/usync/api/v1/Complete/GetLicence';
+};
+export type GetLicenceErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetLicenceResponses = {
+    /**
+     * OK
+     */
+    200: Licence;
+};
+export type GetLicenceResponse = GetLicenceResponses[keyof GetLicenceResponses];
+export type GetLicenceStatusData = {
+    body?: never;
+    path?: never;
+    query?: {
+        product?: string;
+        version?: string;
+    };
+    url: '/umbraco/usync/api/v1/Complete/GetLicenceStatus';
+};
+export type GetLicenceStatusErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetLicenceStatusResponses = {
+    /**
+     * OK
+     */
+    200: LicenceStatusView;
+};
+export type GetLicenceStatusResponse = GetLicenceStatusResponses[keyof GetLicenceStatusResponses];
+export type IsLicencedData = {
+    body?: never;
+    path?: never;
+    query?: {
+        product?: string;
+        version?: string;
+    };
+    url: '/umbraco/usync/api/v1/Complete/IsLicenced';
+};
+export type IsLicencedErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type IsLicencedResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type IsLicencedResponse = IsLicencedResponses[keyof IsLicencedResponses];
+export type SaveLicenceData = {
+    body: LicenceInfo;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Complete/SaveLicence';
+};
+export type SaveLicenceErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type SaveLicenceResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type SaveLicenceResponse = SaveLicenceResponses[keyof SaveLicenceResponses];
+export type CleanData = {
+    body?: never;
+    path?: never;
+    query?: {
+        id?: string;
+    };
+    url: '/umbraco/usync/api/v1/Complete/Clean';
+};
+export type CleanErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type CleanResponses = {
+    /**
+     * OK
+     */
+    200: unknown;
+};
+export type GetRestorePointData = {
+    body?: never;
+    path?: never;
+    query?: {
+        key?: string;
+    };
+    url: '/umbraco/usync/api/v1/Complete/Get';
+};
+export type GetRestorePointErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Not Found
+     */
+    404: unknown;
+};
+export type GetRestorePointResponses = {
+    /**
+     * OK
+     */
+    200: RestorePoint;
+};
+export type GetRestorePointResponse = GetRestorePointResponses[keyof GetRestorePointResponses];
+export type GetAllData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Complete/GetAll';
+};
+export type GetAllErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetAllResponses = {
+    /**
+     * OK
+     */
+    200: Array<RestorePoint>;
+};
+export type GetAllResponse = GetAllResponses[keyof GetAllResponses];
+export type GetReportData = {
+    body?: never;
+    path?: never;
+    query?: {
+        id?: string;
+    };
+    url: '/umbraco/usync/api/v1/Complete/GetReport';
+};
+export type GetReportErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetReportResponses = {
+    /**
+     * OK
+     */
+    200: Array<USyncAction>;
+};
+export type GetReportResponse = GetReportResponses[keyof GetReportResponses];
+export type RemoveData = {
+    body?: never;
+    path?: never;
+    query?: {
+        id?: string;
+    };
+    url: '/umbraco/usync/api/v1/Complete/Remove';
+};
+export type RemoveErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type RemoveResponses = {
+    /**
+     * OK
+     */
+    200: unknown;
+};
+export type ScanData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Complete/Scan';
+};
+export type ScanErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type ScanResponses = {
+    /**
+     * OK
+     */
+    200: {
+        [key: string]: number | string;
+    };
+};
+export type ScanResponse = ScanResponses[keyof ScanResponses];

package/dist/api/types.gen.js

@@ -0,0 +1,74 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export var ChangeDetailType;
+(function (ChangeDetailType) {
+    ChangeDetailType["NO_CHANGE"] = "NoChange";
+    ChangeDetailType["CREATE"] = "Create";
+    ChangeDetailType["UPDATE"] = "Update";
+    ChangeDetailType["DELETE"] = "Delete";
+    ChangeDetailType["ERROR"] = "Error";
+    ChangeDetailType["WARNING"] = "Warning";
+})(ChangeDetailType || (ChangeDetailType = {}));
+export var ChangeType;
+(function (ChangeType) {
+    ChangeType["NO_CHANGE"] = "NoChange";
+    ChangeType["CREATE"] = "Create";
+    ChangeType["IMPORT"] = "Import";
+    ChangeType["EXPORT"] = "Export";
+    ChangeType["UPDATE"] = "Update";
+    ChangeType["DELETE"] = "Delete";
+    ChangeType["WILL_CHANGE"] = "WillChange";
+    ChangeType["INFORMATION"] = "Information";
+    ChangeType["ROLLEDBACK"] = "Rolledback";
+    ChangeType["FAIL"] = "Fail";
+    ChangeType["IMPORT_FAIL"] = "ImportFail";
+    ChangeType["MISMATCH"] = "Mismatch";
+    ChangeType["PARENT_MISSING"] = "ParentMissing";
+    ChangeType["HIDDEN"] = "Hidden";
+    ChangeType["CLEAN"] = "Clean";
+    ChangeType["REMOVED"] = "Removed";
+})(ChangeType || (ChangeType = {}));
+export var LicenceStatus;
+(function (LicenceStatus) {
+    LicenceStatus["LOADED"] = "Loaded";
+    LicenceStatus["BAD_FORMAT"] = "BadFormat";
+    LicenceStatus["INVALID"] = "Invalid";
+    LicenceStatus["BAD_HOST"] = "BadHost";
+    LicenceStatus["EXPIRED"] = "Expired";
+    LicenceStatus["TRIAL_EXPIRED"] = "TrialExpired";
+    LicenceStatus["UNVERIFIED"] = "Unverified";
+    LicenceStatus["MISSING"] = "Missing";
+    LicenceStatus["VALID"] = "Valid";
+    LicenceStatus["TRIAL"] = "Trial";
+})(LicenceStatus || (LicenceStatus = {}));
+export var LicenceType;
+(function (LicenceType) {
+    LicenceType["NONE"] = "None";
+    LicenceType["DOMAIN"] = "Domain";
+    LicenceType["SUBSCRIPTION"] = "Subscription";
+    LicenceType["TRIAL"] = "Trial";
+    LicenceType["LIMITED_EXPIRY"] = "LimitedExpiry";
+    LicenceType["AGENCY"] = "Agency";
+    LicenceType["PARTNER"] = "Partner";
+})(LicenceType || (LicenceType = {}));
+export var RestorePointStatus;
+(function (RestorePointStatus) {
+    RestorePointStatus["COMPLETE"] = "Complete";
+    RestorePointStatus["PENDING"] = "Pending";
+    RestorePointStatus["FAILED"] = "Failed";
+})(RestorePointStatus || (RestorePointStatus = {}));
+export var SyncDependencyFlags;
+(function (SyncDependencyFlags) {
+    SyncDependencyFlags["NONE"] = "None";
+    SyncDependencyFlags["INCLUDE_CHILDREN"] = "IncludeChildren";
+    SyncDependencyFlags["INCLUDE_ANCESTORS"] = "IncludeAncestors";
+    SyncDependencyFlags["INCLUDE_DEPENDENCIES"] = "IncludeDependencies";
+    SyncDependencyFlags["INCLUDE_VIEWS"] = "IncludeViews";
+    SyncDependencyFlags["INCLUDE_MEDIA"] = "IncludeMedia";
+    SyncDependencyFlags["INCLUDE_LINKED"] = "IncludeLinked";
+    SyncDependencyFlags["INCLUDE_MEDIA_FILES"] = "IncludeMediaFiles";
+    SyncDependencyFlags["INCLUDE_CONFIG"] = "IncludeConfig";
+    SyncDependencyFlags["ADJACENT_ONLY"] = "AdjacentOnly";
+    SyncDependencyFlags["ROOT_SYNC"] = "RootSync";
+    SyncDependencyFlags["INCLUDE_CONTENTS"] = "IncludeContents";
+    SyncDependencyFlags["PUBLISHED_DEPENDENCIES"] = "PublishedDependencies";
+})(SyncDependencyFlags || (SyncDependencyFlags = {}));

package/dist/background/background-cancel.controller.d.ts

@@ -0,0 +1,16 @@
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+/**
+ * @description confirm, cancel and report - shared by the process and queue lists.
+ */
+export declare class uSyncBackgroundCancelController extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    /**
+     * @param id the pipeline id
+     * @param name what to call it in the confirm dialog (alias, note, etc.)
+     * @returns true if the cancel was accepted (the lists should be refreshed).
+     */
+    cancel(id: string, name?: string | null): Promise<boolean>;
+}
+export default uSyncBackgroundCancelController;

package/dist/background/background-cancel.controller.js

@@ -0,0 +1,83 @@
+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 _uSyncBackgroundCancelController_instances, _uSyncBackgroundCancelController_repository, _uSyncBackgroundCancelController_localize, _uSyncBackgroundCancelController_errorMessage;
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbLocalizationController } from '@umbraco-cms/backoffice/localization-api';
+import { umbConfirmModal } from '@umbraco-cms/backoffice/modal';
+import { UMB_NOTIFICATION_CONTEXT } from '@umbraco-cms/backoffice/notification';
+import { UmbApiError } from '@umbraco-cms/backoffice/resources';
+import { uSyncBackgroundPipelineRepository } from './background-pipeline.repository.js';
+/**
+ * @description confirm, cancel and report - shared by the process and queue lists.
+ */
+export class uSyncBackgroundCancelController extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        _uSyncBackgroundCancelController_instances.add(this);
+        _uSyncBackgroundCancelController_repository.set(this, void 0);
+        _uSyncBackgroundCancelController_localize.set(this, void 0);
+        __classPrivateFieldSet(this, _uSyncBackgroundCancelController_repository, new uSyncBackgroundPipelineRepository(host), "f");
+        __classPrivateFieldSet(this, _uSyncBackgroundCancelController_localize, new UmbLocalizationController(host), "f");
+    }
+    /**
+     * @param id the pipeline id
+     * @param name what to call it in the confirm dialog (alias, note, etc.)
+     * @returns true if the cancel was accepted (the lists should be refreshed).
+     */
+    async cancel(id, name) {
+        try {
+            await umbConfirmModal(this, {
+                headline: __classPrivateFieldGet(this, _uSyncBackgroundCancelController_localize, "f").term('uSyncBackground_cancelHeadline'),
+                content: __classPrivateFieldGet(this, _uSyncBackgroundCancelController_localize, "f").term('uSyncBackground_cancelConfirm', name || id),
+                color: 'danger',
+                confirmLabel: __classPrivateFieldGet(this, _uSyncBackgroundCancelController_localize, "f").term('uSyncBackground_cancelRun'),
+                cancelLabel: __classPrivateFieldGet(this, _uSyncBackgroundCancelController_localize, "f").term('uSyncBackground_keepRun'),
+            });
+        }
+        catch {
+            return false; // closed the dialog.
+        }
+        const { error } = await __classPrivateFieldGet(this, _uSyncBackgroundCancelController_repository, "f").cancelPipeline(id);
+        const notifications = await this.getContext(UMB_NOTIFICATION_CONTEXT);
+        if (!error) {
+            notifications?.peek('positive', {
+                data: {
+                    headline: __classPrivateFieldGet(this, _uSyncBackgroundCancelController_localize, "f").term('uSyncBackground_cancelledHeadline'),
+                    message: __classPrivateFieldGet(this, _uSyncBackgroundCancelController_localize, "f").term('uSyncBackground_cancelledMessage'),
+                },
+            });
+            return true;
+        }
+        notifications?.peek('danger', {
+            data: {
+                headline: __classPrivateFieldGet(this, _uSyncBackgroundCancelController_localize, "f").term('uSyncBackground_cancelFailedHeadline'),
+                message: __classPrivateFieldGet(this, _uSyncBackgroundCancelController_instances, "m", _uSyncBackgroundCancelController_errorMessage).call(this, error),
+            },
+        });
+        return false;
+    }
+}
+_uSyncBackgroundCancelController_repository = new WeakMap(), _uSyncBackgroundCancelController_localize = new WeakMap(), _uSyncBackgroundCancelController_instances = new WeakSet(), _uSyncBackgroundCancelController_errorMessage = function _uSyncBackgroundCancelController_errorMessage(error) {
+    if (UmbApiError.isUmbApiError(error)) {
+        switch (error.status) {
+            case 403:
+                return __classPrivateFieldGet(this, _uSyncBackgroundCancelController_localize, "f").term('uSyncBackground_cancelForbidden');
+            case 404:
+                return __classPrivateFieldGet(this, _uSyncBackgroundCancelController_localize, "f").term('uSyncBackground_cancelNotFound');
+            case 409:
+                return __classPrivateFieldGet(this, _uSyncBackgroundCancelController_localize, "f").term('uSyncBackground_cancelFinished');
+        }
+        return error.problemDetails?.detail ?? error.message;
+    }
+    return error instanceof Error ? error.message : String(error);
+};
+export default uSyncBackgroundCancelController;