@jumoo/usync 0.0.0-stage → 18.2.0

package/dist/lang/files/fr-fr.js

@@ -0,0 +1,141 @@
+export default {
+    uSync: {
+        section: 'Synchronisation',
+        name: 'uSync',
+        banner: 'uSync pour tout synchroniser',
+        migrate: 'Migrer',
+        defaultView: 'Défaut',
+        settingsView: 'Paramètres',
+        addons: 'Extensions',
+        groupEverything: 'Tout',
+        groupContent: 'Contenu',
+        groupSettings: 'Paramètres',
+        groupForms: 'Formulaires',
+        groupMedia: 'Médias',
+        groupMembers: 'Membres',
+        Report: 'Rapport',
+        Import: 'Importer',
+        Export: 'Exporter',
+        ImportForce: 'Importer (Forcer)',
+        ExportClean: 'Exporter (Propre)',
+        ExportFile: 'Exporter vers fichier',
+        ImportFile: 'Importer depuis fichier',
+        noChange: 'Rien n\'a changé',
+        showAll: 'Afficher tous les éléments',
+        detailHeadline: 'Modifications détectées',
+        detailHeader: 'Ce qui est différent',
+        runningInBackground: 'uSync exécute ce processus en arrière-plan. Si vous quittez cette page, il continuera de fonctionner.',
+        connectionLost: 'La connexion au serveur a été perdue. Le processus continuera de s\'exécuter en arrière-plan, mais vous ne verrez pas les mises à jour ici.',
+        importSingle: 'Importer',
+        importSingleWarning: 'Cela importera cet élément dans Umbraco. Si cet élément a des dépendances, elles ne seront pas importées et devront être résolues manuellement.',
+        importSingleSuccess: 'L\'élément a été importé avec succès',
+        importSingleFailed: `<p>Une erreur s'est produite lors de l'importation de l'élément</p><strong>%0%</strong>`,
+        changeAction: 'Action',
+        changeItem: 'Élément',
+        changeDiffrence: 'Différence',
+        changeCreate: 'Cet élément n\'existe pas dans Umbraco et est en cours de création',
+        noChangesImport: 'Aucune modification n\'a été apportée à cet élément',
+        noChangesReport: 'Aucune modification détectée',
+        noChangesDelete: 'Cet élément a été supprimé d\'Umbraco',
+        importHeader: 'Importer depuis un fichier',
+        success: 'Succès',
+        change: 'Modification',
+        changeType: 'Type',
+        changeName: 'Nom',
+        changeDetail: 'Détail',
+        changeHeading: 'Résultats',
+        changeCount: '{1}/{0} modifications',
+        noChangeCount: '0/{0} modifications',
+        legacyInfo: `<p>uSync a trouvé un dossier uSync hérité à <strong>%0%</strong>.<br />
+						Il est probable que son contenu devra être converti d'une façon ou d'une autre</p>`,
+        legacyObsolete: `<h4>Types de données obsolètes</h4>
+				<ul>%0%</ul>
+				<p>Vous pouvez convertir ces types de données en utilisant
+					<a href="https://github.com/Jumoo/uSyncMigrations" target="_blank">uSync.Migrations</a><br />
+					<em>(Dans la version complète d'uSync, la conversion se fera ici.)</em></p>`,
+        legacyCopy: `<h4>Copier vers uSync/v14</h4>
+					<p>Vous pouvez copier votre dossier %0% vers le dossier ~/uSync/v14<br />et exécuter une importation.</p>
+					<p>Si rien ne nécessite de conversion, tout devrait s'importer correctement.</p>
+					<p><strong>Supprimez ou renommez le dossier %0% pour éviter cette popup</strong></p>`,
+        hmacMismatch: `<h4>Incompatibilité HMAC <uui-icon name="alert"></uui-icon></h4>
+			<p>Il semble que le paramètre <code>Imaging:HMAC</code> utilisé pour générer les fichiers dans le dossier uSync ne corresponde pas au paramètre actuel de ce site.</p>
+			<p>Les images dans les contrôles RTE auront la valeur HMAC ajoutée à l'URL, et sans configuration supplémentaire, ces images pourraient ne pas s'afficher correctement.</p>
+			<ul><li>Vous pouvez activer le "mappage HMAC" dans uSync,</li>
+			<li>ou vous pouvez vous assurer que la valeur HMAC dans le paramètre <code>Imaging:HMAC</code> correspond à la valeur utilisée pour générer les fichiers dans le dossier uSync</li></ul>`,
+        formatMismatch: 'La version du format du fichier de synchronisation ne correspond pas à la version attendue. Cela peut indiquer un problème de compatibilité potentiel.',
+        legacyBanner: 'Ce site contient des fichiers d\'une version précédente d\'uSync. Consultez les détails dans l\'onglet Héritage.',
+        legacyCopyTitle: 'Écraser les fichiers v%0%',
+        legacyCopyContent: 'Êtes-vous sûr de vouloir écraser le contenu du dossier %0% avec les fichiers du dossier uSync hérité ?',
+        legacyIgnoreTitle: 'Ignorer les fichiers hérités',
+        legacyIgnoreContent: 'Êtes-vous sûr de vouloir ignorer les fichiers dans le dossier uSync hérité ?',
+        errorHeader: 'Cet élément a rencontré une erreur lors du processus. Les détails sont ci-dessous :',
+        uploadIntro: 'Sélectionnez un fichier zip contenant les fichiers uSync que vous souhaitez télécharger',
+        uploadSuccess: 'Les fichiers ont été téléchargés et extraits dans le dossier uSync',
+        uploadError: 'Une erreur s\'est produite lors du téléchargement des fichiers',
+        ILanguage: 'Langue',
+        IDictionaryItem: 'Éléments du dictionnaire',
+        IDataType: 'Types de données',
+        ITemplate: 'Modèles',
+        IContentType: 'Types de contenu',
+        IMediaType: 'Types de médias',
+        IMemberType: 'Types de membres',
+        IContent: 'Contenu',
+        IMedia: 'Média',
+        IDomain: 'Domaines',
+        IWebhook: 'Webhooks',
+        IRelationType: 'Types de relations',
+        MediaFile: 'Fichiers médias',
+        XElement: 'Autre',
+        LanguageHandler: 'Langues',
+        DictionaryHandler: 'Éléments du dictionnaire',
+        DataTypeHandler: 'Types de données',
+        TemplateHandler: 'Modèles',
+        ContentTypeHandler: 'Types de contenu',
+        MediaTypeHandler: 'Types de médias',
+        MemberTypeHandler: 'Types de membres',
+        ContentHandler: 'Contenu',
+        MediaHandler: 'Média',
+        RelationTypeHandler: 'Types de relations',
+        EntityContainer: 'Conteneurs',
+    },
+    USyncSettings: {
+        settings: 'Paramètres uSync',
+        filesAndFolders: 'Fichiers et dossiers',
+        handlerDefaults: 'Paramètres par défaut des gestionnaires',
+        processingMode: 'Mode de traitement',
+        processingModeDesc: 'Comment le processus uSync s\'exécute, soit en arrière-plan, soit de manière interactive (Normal)',
+        importAtStartup: 'Importer au démarrage',
+        importAtStartupDesc: 'Exécuter une importation de fichiers depuis le disque au démarrage d\'Umbraco',
+        exportAtStartup: 'Exporter au démarrage',
+        exportAtStartupDesc: 'Exporter les paramètres Umbraco au démarrage du site',
+        exportOnSave: 'Exporter à l\'enregistrement',
+        exportOnSaveDesc: 'Générer des fichiers uSync lors de l\'enregistrement des éléments',
+        uiEnabledGroups: 'Groupes activés dans l\'interface',
+        uiEnabledGroupsDesc: 'Groupes de gestionnaires visibles/utilisables sur le tableau de bord',
+        failOnMissingParent: 'Échec si parent manquant',
+        failOnMissingParentDesc: 'Échec si l\'élément parent est manquant',
+        currentHandlerSet: 'Ensemble actuel',
+        handlerSet: 'Ensemble de gestionnaires par défaut',
+        handlerSetDesc: 'L\'ensemble de gestionnaires par défaut à utiliser pour le site',
+        flatStructure: 'Structure plate',
+        flatStructureDesc: 'Tous les éléments d\'un type sont stockés dans une structure de dossiers plate',
+        guidNames: 'Utiliser les GUID comme noms de fichiers',
+        guidNamesDesc: 'Utiliser le GUID d\'un élément comme nom de fichier',
+        handlerGroups: 'Groupes de gestionnaires',
+        handlerGroupsDesc: 'Groupes pour limiter l\'ensemble de gestionnaires',
+        disabledHandlers: 'Gestionnaires désactivés',
+        disabledHandlersDesc: 'Gestionnaires explicitement désactivés pour cet ensemble de gestionnaires',
+        folders: 'Dossiers',
+        foldersDesc: 'Dossiers dans lesquels uSync recherchera des fichiers (les éléments sont normalement enregistrés dans le dernier dossier de la liste)',
+        rootSite: 'Site racine',
+        rootSiteDesc: 'Ce site est-il une racine pour d\'autres sites.',
+        rootLocked: 'Racine verrouillée',
+        rootLockedDesc: 'Les modifications des éléments provenant du site racine sont-elles verrouillées ?',
+        help: 'Les paramètres sont contrôlés via le fichier appsettings.json. <a href="https://docs.jumoo.co.uk/usync/uSync/reference/config" target="_blank" rel="noopener">Voir notre documentation</a>',
+        bootSettings: 'Paramètres du premier démarrage 🥾',
+        firstBoot: 'Importer au premier démarrage',
+        firstBootDesc: 'Exécuter le processus d\'importation au premier démarrage du site',
+        firstBootGroup: 'Groupes du premier démarrage',
+        firstBootGroupDesc: 'Les groupes à exécuter au premier démarrage',
+    },
+};

package/dist/lang/files/nl-nl.d.ts

@@ -0,0 +1,130 @@
+declare const _default: {
+    uSync: {
+        section: string;
+        name: string;
+        banner: string;
+        migrate: string;
+        defaultView: string;
+        settingsView: string;
+        addons: string;
+        groupEverything: string;
+        groupContent: string;
+        groupSettings: string;
+        groupForms: string;
+        groupMedia: string;
+        groupMembers: string;
+        Report: string;
+        Import: string;
+        Export: string;
+        ImportForce: string;
+        ExportClean: string;
+        ExportFile: string;
+        ImportFile: string;
+        noChange: string;
+        showAll: string;
+        detailHeadline: string;
+        detailHeader: string;
+        runningInBackground: string;
+        connectionLost: string;
+        importSingle: string;
+        importSingleWarning: string;
+        importSingleSuccess: string;
+        importSingleFailed: string;
+        changeAction: string;
+        changeItem: string;
+        changeDiffrence: string;
+        changeCreate: string;
+        noChangesImport: string;
+        noChangesReport: string;
+        noChangesDelete: string;
+        importHeader: string;
+        success: string;
+        change: string;
+        changeType: string;
+        changeName: string;
+        changeDetail: string;
+        changeHeading: string;
+        changeCount: string;
+        noChangeCount: string;
+        legacyInfo: string;
+        legacyObsolete: string;
+        legacyCopy: string;
+        hmacMismatch: string;
+        formatMismatch: string;
+        legacyBanner: string;
+        legacyCopyTitle: string;
+        legacyCopyContent: string;
+        legacyIgnoreTitle: string;
+        legacyIgnoreContent: string;
+        errorHeader: string;
+        uploadIntro: string;
+        uploadSuccess: string;
+        uploadError: string;
+        ILanguage: string;
+        IDictionaryItem: string;
+        IDataType: string;
+        ITemplate: string;
+        IContentType: string;
+        IMediaType: string;
+        IMemberType: string;
+        IContent: string;
+        IMedia: string;
+        IDomain: string;
+        IWebhook: string;
+        IRelationType: string;
+        MediaFile: string;
+        XElement: string;
+        LanguageHandler: string;
+        DictionaryHandler: string;
+        DataTypeHandler: string;
+        TemplateHandler: string;
+        ContentTypeHandler: string;
+        MediaTypeHandler: string;
+        MemberTypeHandler: string;
+        ContentHandler: string;
+        MediaHandler: string;
+        RelationTypeHandler: string;
+        EntityContainer: string;
+    };
+    USyncSettings: {
+        settings: string;
+        filesAndFolders: string;
+        handlerDefaults: string;
+        processingMode: string;
+        processingModeDesc: string;
+        importAtStartup: string;
+        importAtStartupDesc: string;
+        exportAtStartup: string;
+        exportAtStartupDesc: string;
+        exportOnSave: string;
+        exportOnSaveDesc: string;
+        uiEnabledGroups: string;
+        uiEnabledGroupsDesc: string;
+        failOnMissingParent: string;
+        failOnMissingParentDesc: string;
+        currentHandlerSet: string;
+        handlerSet: string;
+        handlerSetDesc: string;
+        flatStructure: string;
+        flatStructureDesc: string;
+        guidNames: string;
+        guidNamesDesc: string;
+        handlerGroups: string;
+        handlerGroupsDesc: string;
+        disabledHandlers: string;
+        disabledHandlersDesc: string;
+        folders: string;
+        foldersDesc: string;
+        rootSite: string;
+        rootSiteDesc: string;
+        rootLocked: string;
+        rootLockedDesc: string;
+        help: string;
+        bootSettings: string;
+        firstBoot: string;
+        firstBootDesc: string;
+        firstBootGroup: string;
+        firstBootGroupDesc: string;
+    };
+};
+export default _default;

package/dist/lang/files/nl-nl.js

@@ -0,0 +1,141 @@
+export default {
+    uSync: {
+        section: 'Synchronisatie',
+        name: 'uSync',
+        banner: 'uSync voor alles',
+        migrate: 'Migreren',
+        defaultView: 'Standaard',
+        settingsView: 'Instellingen',
+        addons: 'Add-ons',
+        groupEverything: 'Alles',
+        groupContent: 'Inhoud',
+        groupSettings: 'Instellingen',
+        groupForms: 'Formulieren',
+        groupMedia: 'Media',
+        groupMembers: 'Leden',
+        Report: 'Rapport',
+        Import: 'Importeren',
+        Export: 'Exporteren',
+        ImportForce: 'Importeren (Forceren)',
+        ExportClean: 'Exporteren (Schoon)',
+        ExportFile: 'Exporteren naar bestand',
+        ImportFile: 'Importeren vanuit bestand',
+        noChange: 'Er is niets veranderd',
+        showAll: 'Alle items weergeven',
+        detailHeadline: 'Gedetecteerde wijzigingen',
+        detailHeader: 'Wat er anders is',
+        runningInBackground: 'uSync voert dit proces op de achtergrond uit. Als u van deze pagina navigeert, blijft het doorlopen.',
+        connectionLost: 'De verbinding met de server is verbroken. Het proces blijft op de achtergrond draaien, maar u ziet hier geen updates.',
+        importSingle: 'Importeren',
+        importSingleWarning: 'Dit importeert dit item in Umbraco. Als dit item afhankelijkheden heeft, worden deze niet geïmporteerd en moeten handmatig worden opgelost.',
+        importSingleSuccess: 'Het item is succesvol geïmporteerd',
+        importSingleFailed: `<p>Er is een fout opgetreden bij het importeren van het item</p><strong>%0%</strong>`,
+        changeAction: 'Actie',
+        changeItem: 'Item',
+        changeDiffrence: 'Verschil',
+        changeCreate: 'Dit item bestaat niet in Umbraco en wordt aangemaakt',
+        noChangesImport: 'Er zijn geen wijzigingen aangebracht aan dit item',
+        noChangesReport: 'Geen wijzigingen gedetecteerd',
+        noChangesDelete: 'Dit item is verwijderd uit Umbraco',
+        importHeader: 'Importeren vanuit bestand',
+        success: 'Succes',
+        change: 'Wijziging',
+        changeType: 'Type',
+        changeName: 'Naam',
+        changeDetail: 'Detail',
+        changeHeading: 'Resultaten',
+        changeCount: '{1}/{0} wijzigingen',
+        noChangeCount: '0/{0} wijzigingen',
+        legacyInfo: `<p>uSync heeft een verouderde uSync-map gevonden op <strong>%0%</strong>.<br />
+						Het is waarschijnlijk dat de inhoud op de een of andere manier geconverteerd moet worden</p>`,
+        legacyObsolete: `<h4>Verouderde gegevenstypen</h4>
+				<ul>%0%</ul>
+				<p>U kunt deze gegevenstypen converteren met
+					<a href="https://github.com/Jumoo/uSyncMigrations" target="_blank">uSync.Migrations</a><br />
+					<em>(In de volledige uSync-release zal de conversie hier plaatsvinden.)</em></p>`,
+        legacyCopy: `<h4>Kopiëren naar uSync/v14</h4>
+					<p>U kunt uw %0%-map kopiëren naar de ~/uSync/v14-map<br />en een import uitvoeren.</p>
+					<p>Als er niets geconverteerd hoeft te worden, zou alles correct moeten importeren.</p>
+					<p><strong>Verwijder of hernoem de %0%-map om deze popup te voorkomen</strong></p>`,
+        hmacMismatch: `<h4>HMAC-mismatch <uui-icon name="alert"></uui-icon></h4>
+			<p>Het lijkt erop dat de <code>Imaging:HMAC</code>-instelling die werd gebruikt om de bestanden in de uSync-map te genereren, niet overeenkomt met de huidige instelling voor deze site.</p>
+			<p>Afbeeldingen in RTE-besturingselementen hebben de HMAC-waarde toegevoegd aan de URL-waarde, en zonder aanvullende configuratie worden deze afbeeldingen mogelijk niet correct weergegeven.</p>
+			<ul><li>U kunt "HMAC-mapping" inschakelen in uSync,</li>
+			<li>of u kunt ervoor zorgen dat de HMAC-waarde in de <code>Imaging:HMAC</code>-instelling overeenkomt met de waarde die werd gebruikt om de bestanden in de uSync-map te genereren</li></ul>`,
+        formatMismatch: 'De versie van het synchronisatiebestandsformaat komt niet overeen met de verwachte versie. Dit kan wijzen op een mogelijk compatibiliteitsprobleem.',
+        legacyBanner: 'Deze site bevat bestanden van een eerdere versie van uSync. Bekijk de details op het tabblad Verouderd.',
+        legacyCopyTitle: 'v%0%-bestanden overschrijven',
+        legacyCopyContent: 'Weet u zeker dat u de inhoud van de map %0% wilt overschrijven met de verouderde uSync-mapbestanden?',
+        legacyIgnoreTitle: 'Verouderde bestanden negeren',
+        legacyIgnoreContent: 'Weet u zeker dat u de bestanden in de verouderde uSync-map wilt negeren?',
+        errorHeader: 'Dit item heeft een fout ondervonden tijdens het proces. De details staan hieronder:',
+        uploadIntro: 'Selecteer een zip-bestand met uSync-bestanden die u wilt uploaden',
+        uploadSuccess: 'De bestanden zijn geüpload en uitgepakt naar de uSync-map',
+        uploadError: 'Er is een fout opgetreden bij het uploaden van de bestanden',
+        ILanguage: 'Taal',
+        IDictionaryItem: 'Woordenboekitems',
+        IDataType: 'Gegevenstypen',
+        ITemplate: 'Sjablonen',
+        IContentType: 'Inhoudstypen',
+        IMediaType: 'Mediatypen',
+        IMemberType: 'Ledentypen',
+        IContent: 'Inhoud',
+        IMedia: 'Media',
+        IDomain: 'Domeinen',
+        IWebhook: 'Webhooks',
+        IRelationType: 'Relatietypen',
+        MediaFile: 'Mediabestanden',
+        XElement: 'Overig',
+        LanguageHandler: 'Talen',
+        DictionaryHandler: 'Woordenboekitems',
+        DataTypeHandler: 'Gegevenstypen',
+        TemplateHandler: 'Sjablonen',
+        ContentTypeHandler: 'Inhoudstypen',
+        MediaTypeHandler: 'Mediatypen',
+        MemberTypeHandler: 'Ledentypen',
+        ContentHandler: 'Inhoud',
+        MediaHandler: 'Media',
+        RelationTypeHandler: 'Relatietypen',
+        EntityContainer: 'Containers',
+    },
+    USyncSettings: {
+        settings: 'uSync-instellingen',
+        filesAndFolders: 'Bestanden en mappen',
+        handlerDefaults: 'Handler-standaardwaarden',
+        processingMode: 'Verwerkingsmodus',
+        processingModeDesc: 'Hoe het uSync-proces wordt uitgevoerd, op de achtergrond of interactief (Normaal)',
+        importAtStartup: 'Importeren bij opstarten',
+        importAtStartupDesc: 'Een import van bestanden van de schijf uitvoeren wanneer Umbraco start',
+        exportAtStartup: 'Exporteren bij opstarten',
+        exportAtStartupDesc: 'De Umbraco-instellingen exporteren wanneer de site opstart',
+        exportOnSave: 'Exporteren bij opslaan',
+        exportOnSaveDesc: 'uSync-bestanden genereren wanneer items worden opgeslagen',
+        uiEnabledGroups: 'UI-ingeschakelde groepen',
+        uiEnabledGroupsDesc: 'Handlergroepen die zichtbaar/bruikbaar zijn op het dashboard',
+        failOnMissingParent: 'Fout bij ontbrekend bovenliggend item',
+        failOnMissingParentDesc: 'Fout bij ontbrekend bovenliggend item',
+        currentHandlerSet: 'Huidige set',
+        handlerSet: 'Standaard handlerset',
+        handlerSetDesc: 'De standaard handlerset voor de site',
+        flatStructure: 'Platte structuur',
+        flatStructureDesc: 'Alle items van een type worden opgeslagen in een platte mappenstructuur',
+        guidNames: 'GUID\'s als bestandsnamen gebruiken',
+        guidNamesDesc: 'De GUID van een item als bestandsnaam gebruiken',
+        handlerGroups: 'Handlergroepen',
+        handlerGroupsDesc: 'Groepen om de handlerset te beperken',
+        disabledHandlers: 'Uitgeschakelde handlers',
+        disabledHandlersDesc: 'Handlers die expliciet zijn uitgeschakeld voor deze handlerset',
+        folders: 'Mappen',
+        foldersDesc: 'Mappen waarin uSync naar bestanden zoekt (items worden normaal opgeslagen in de laatste map in de lijst)',
+        rootSite: 'Rootsite',
+        rootSiteDesc: 'Is deze site een root voor andere sites.',
+        rootLocked: 'Root vergrendeld',
+        rootLockedDesc: 'Zijn wijzigingen voor items van de rootsite vergrendeld?',
+        help: 'Instellingen worden beheerd via het bestand appsettings.json. <a href="https://docs.jumoo.co.uk/usync/uSync/reference/config" target="_blank" rel="noopener">Zie onze documentatie</a>',
+        bootSettings: 'Instellingen voor eerste opstart 🥾',
+        firstBoot: 'Importeren bij eerste opstart',
+        firstBootDesc: 'Het importproces uitvoeren bij de eerste opstart van de site',
+        firstBootGroup: 'Groepen voor eerste opstart',
+        firstBootGroupDesc: 'De groepen die worden uitgevoerd bij de eerste opstart',
+    },
+};

package/dist/lang/manifest.d.ts

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

package/dist/lang/manifest.js

@@ -0,0 +1,63 @@
+const localizations = [
+    {
+        type: 'localization',
+        alias: 'usync.lang.enus',
+        name: 'English',
+        weight: 0,
+        meta: {
+            culture: 'en',
+        },
+        js: () => import('./files/en-us'),
+    },
+    {
+        type: 'localization',
+        alias: 'usync.lang.dadk',
+        name: 'Danish',
+        weight: 0,
+        meta: {
+            culture: 'da',
+        },
+        js: () => import('./files/da-dk'),
+    },
+    {
+        type: 'localization',
+        alias: 'usync.lang.frfr',
+        name: 'French',
+        weight: 0,
+        meta: {
+            culture: 'fr',
+        },
+        js: () => import('./files/fr-fr'),
+    },
+    {
+        type: 'localization',
+        alias: 'usync.lang.eses',
+        name: 'Spanish',
+        weight: 0,
+        meta: {
+            culture: 'es',
+        },
+        js: () => import('./files/es-es'),
+    },
+    {
+        type: 'localization',
+        alias: 'usync.lang.dede',
+        name: 'German',
+        weight: 0,
+        meta: {
+            culture: 'de',
+        },
+        js: () => import('./files/de-de'),
+    },
+    {
+        type: 'localization',
+        alias: 'usync.lang.nlnl',
+        name: 'Dutch',
+        weight: 0,
+        meta: {
+            culture: 'nl',
+        },
+        js: () => import('./files/nl-nl'),
+    },
+];
+export const manifests = [...localizations];

package/dist/manifests.d.ts

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

package/dist/manifests.js

@@ -0,0 +1,14 @@
+import { manifests as trees } from './tree/manifest.js';
+import { manifests as workspace } from './workspace/manifest.js';
+import { manifests as localization } from './lang/manifest.js';
+import { manifests as dialogs } from './dialogs/manifest.js';
+import { manifests as conditions } from './conditions/manifest.js';
+import { manifests as icons } from './icons/manifest.js';
+export const manifests = [
+    ...localization,
+    ...trees,
+    ...workspace,
+    ...dialogs,
+    ...conditions,
+    ...icons,
+];

package/dist/repository/SyncAction.respositoy.d.ts

@@ -0,0 +1,121 @@
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { USyncActionView } from '@jumoo/uSync';
+/**
+ * Request object when peforming an action.
+ */
+export type SyncPerformRequest = {
+    /** Id of the request */
+    id: string;
+    /** group (e.g settings, content) */
+    group: string;
+    /** action (report, export, etc) */
+    action: string;
+    /** current step number */
+    step: number;
+    /** force (import) */
+    force?: boolean;
+    /** clean disk first (export) */
+    clean?: boolean;
+    /** produces or expects a file */
+    file?: boolean;
+    /** name of the set to use */
+    set?: string;
+    /** signalR client id */
+    clientId: string;
+};
+/**
+ * Repository for all things actions.
+ */
+export declare class uSyncActionRepository extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    /**
+     * Get the list of possible actions from the server
+     * @returns Promise
+     */
+    getActions(setName: string): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<import("@jumoo/uSync").SyncActionGroup[]>>;
+    /**
+     * Request of the action to perform
+     * @returns PerformActionResponse.
+     */
+    performAction(request: SyncPerformRequest): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<import("@jumoo/uSync").PerformActionResponse>>;
+    /**
+     * Retreives the current uSync settings
+     * @returns the current uSync settings
+     */
+    getSettings(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<import("@jumoo/uSync").USyncSettings>>;
+    getAddons(): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<({
+        data: import("@jumoo/uSync").USyncAddonInfo;
+        error: undefined;
+    } | {
+        data: undefined;
+        error: unknown;
+    }) & {
+        request?: Request;
+        response?: Response;
+    }>>;
+    /**
+     * Get the handler settings based on the set.
+     * @param setName name of the handler set in the configuration
+     * @returns the settings for the named handler set.
+     */
+    getHandlerSettings(setName: string): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<import("@jumoo/uSync").USyncHandlerSetSettings>>;
+    /**
+     * Checks to see if there are legacy datatypes on disk.
+     * @returns results of a check for legacy files
+     */
+    checkLegacy(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<import("@jumoo/uSync").SyncLegacyCheckResponse>>;
+    /**
+     * sets a .ignore folder in the legacy folder so we don't detect it next time.
+     * @returns true if the legacy folder is ignored.
+     */
+    ignoreLegacy(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<boolean>>;
+    /**
+     * copies the legacy folder to the new v14 folder.
+     * @returns true if the legacy folder is copied to the new folder.
+     */
+    copyLegacy(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<boolean>>;
+    downloadFile(): Promise<import("@jumoo/uSync").FileContentResult | undefined>;
+    /**
+     * Poll the status of a background operation.
+     * @param operationId the operation id returned from performAction when inBackground is true
+     */
+    getOperationStatus(operationId: string): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<import("@jumoo/uSync").SyncOperationStatusResponse>>;
+    /**
+     * Ask the server if there is a background run currently active -
+     * used to reattach to a run this client didn't itself start (e.g. after a reload).
+     */
+    getRunningOperation(): Promise<import("@umbraco-cms/backoffice/repository").UmbDataSourceResponse<import("@jumoo/uSync").SyncRunningOperationResponse>>;
+    processUpload(fileId: string): Promise<import("@jumoo/uSync").UploadImportResult | undefined>;
+    getSets(): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<({
+        data: import("@jumoo/uSync").SyncSelectableSet[];
+        error: undefined;
+    } | {
+        data: undefined;
+        error: unknown;
+    }) & {
+        request?: Request;
+        response?: Response;
+    }>>;
+    importSingle(action: USyncActionView): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<({
+        data: USyncActionView;
+        error: undefined;
+    } | {
+        data: undefined;
+        error: unknown;
+    }) & {
+        request?: Request;
+        response?: Response;
+    }>>;
+    getSyncFileInfo(): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<({
+        data: import("@jumoo/uSync").SyncFileVersionCheckResult;
+        error: undefined;
+    } | {
+        data: undefined;
+        error: unknown;
+    }) & {
+        request?: Request;
+        response?: Response;
+    }>>;
+}