@wallfree-dev/angular-core 0.0.59-beta.1

package/esm2022/lib/services/ui-event/ui-event.service.mjs

@@ -0,0 +1,198 @@
+import { Injectable, Inject } from '@angular/core';
+import { APP_CONFIG } from '../../config/app-config';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@ionic/angular";
+/**
+ * This class provides helper functions for translated UI elements such as alerts, toasts and loaders.
+ *
+ * This class should most likely not be called directly and instead be wrapped with something like the UiEventElementsService.
+ */
+export class UiEventService {
+    constructor(translateService, alertController, toastController, loadingController, appConfig) {
+        this.translateService = translateService;
+        this.alertController = alertController;
+        this.toastController = toastController;
+        this.loadingController = loadingController;
+        this.appConfig = appConfig;
+    }
+    /**
+     * Create a translated loader and show it. If you want a reference to the loader, use `getTranslatedLoader` instead.
+     *
+     * @param optionsInput
+     */
+    async showTranslatedLoader(optionsInput) {
+        const loader = await this.getTranslatedLoader(optionsInput);
+        return loader.present();
+    }
+    /**
+     * Create a translated loader and return it.
+     *
+     * @param optionsInput
+     */
+    async getTranslatedLoader(optionsInput) {
+        const message = optionsInput.message?.toString();
+        const translationKeys = [message].filter((key) => key !== undefined);
+        const options = {};
+        if (translationKeys.length > 0) {
+            const values = await this.translateService.get(translationKeys, this.appConfig).toPromise();
+            if (message) {
+                options.message = values[message];
+            }
+        }
+        const loader = await this.loadingController.create({
+            backdropDismiss: false, // Apply defaults
+            ...optionsInput, // Overwrite with configuration
+            ...options // Overwrite translations
+        });
+        return loader;
+    }
+    /**
+     * Create a translated toast and show it. If you want a reference to the toast, use `getTranslatedToast` instead.
+     *
+     * @param optionsInput
+     */
+    async showTranslatedToast(optionsInput) {
+        const toast = await this.getTranslatedToast(optionsInput);
+        return toast.present();
+    }
+    /**
+     * Create a translated toast and return it.
+     *
+     * @param optionsInput
+     */
+    async getTranslatedToast(optionsInput) {
+        const header = optionsInput.header;
+        const message = optionsInput.message?.toString();
+        const buttons = optionsInput.buttons ?? [];
+        const translationKeys = [
+            header,
+            message,
+            ...buttons.map((button) => (typeof button === 'string' ? button : button.text))
+        ].filter((key) => key !== undefined);
+        const options = {};
+        if (translationKeys.length > 0) {
+            const values = await this.translateService.get(translationKeys, this.appConfig).toPromise();
+            if (header) {
+                options.header = values[header];
+            }
+            if (message) {
+                options.message = values[message];
+            }
+            const newButtons = await this.translateButtons(buttons, values);
+            if (newButtons) {
+                options.buttons = newButtons;
+            }
+        }
+        const toast = await this.toastController.create({
+            duration: 2000, // Apply defaults
+            ...optionsInput, // Overwrite with configuration
+            ...options // Overwrite translations
+        });
+        return toast;
+    }
+    /**
+     * Create a translated alert and show it. If you want a reference to the alert, use `getTranslatedAlert` instead.
+     *
+     * @param optionsInput
+     */
+    async showTranslatedAlert(optionsInput) {
+        const alert = await this.getTranslatedAlert(optionsInput);
+        return alert.present();
+    }
+    /**
+     * Create a translated alert and return it.
+     *
+     * @param optionsInput
+     */
+    async getTranslatedAlert(optionsInput) {
+        const header = optionsInput.header;
+        const subHeader = optionsInput.subHeader;
+        const message = optionsInput.message?.toString();
+        const inputs = optionsInput.inputs ?? [];
+        const buttons = optionsInput.buttons ?? [];
+        const translationKeys = [
+            header,
+            subHeader,
+            message,
+            ...inputs.map((input) => input.name),
+            ...inputs.map((input) => input.placeholder),
+            ...inputs.map((input) => input.value),
+            ...inputs.map((input) => input.label),
+            ...buttons.map((button) => (typeof button === 'string' ? button : button.text))
+        ].filter((key) => key !== undefined);
+        const options = {};
+        if (translationKeys.length > 0) {
+            const values = await this.translateService.get(translationKeys, this.appConfig).toPromise();
+            if (header) {
+                options.header = values[header];
+            }
+            if (subHeader) {
+                options.subHeader = values[subHeader];
+            }
+            if (message) {
+                options.message = values[message];
+            }
+            if (inputs.length > 0) {
+                inputs.forEach((input) => {
+                    if (input.name !== undefined) {
+                        input.name = values[input.name];
+                    }
+                    if (input.placeholder !== undefined) {
+                        input.placeholder = values[input.placeholder];
+                    }
+                    if (input.value !== undefined) {
+                        input.value = values[input.value];
+                    }
+                    if (input.label !== undefined) {
+                        input.label = values[input.label];
+                    }
+                });
+                options.inputs = inputs;
+            }
+            const newButtons = await this.translateButtons(buttons, values);
+            if (newButtons) {
+                options.buttons = newButtons;
+            }
+        }
+        const alert = await this.alertController.create({
+            backdropDismiss: true, // Apply defaults
+            ...optionsInput, // Overwrite with configuration
+            ...options // Overwrite translations
+        });
+        return alert;
+    }
+    async translateButtons(buttons, values) {
+        if (buttons.length > 0) {
+            const newButtons = [];
+            buttons.forEach((button) => {
+                if (typeof button === 'string') {
+                    // eslint-disable-next-line no-param-reassign
+                    newButtons.push(values[button]);
+                }
+                else {
+                    if (button.text) {
+                        button.text = values[button.text];
+                        newButtons.push(button);
+                    }
+                }
+            });
+            return newButtons;
+        }
+        else {
+            return undefined;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UiEventService, deps: [{ token: i1.TranslateService }, { token: i2.AlertController }, { token: i2.ToastController }, { token: i2.LoadingController }, { token: APP_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UiEventService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UiEventService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }, { type: i2.AlertController }, { type: i2.ToastController }, { type: i2.LoadingController }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [APP_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui-event.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/ui-event/ui-event.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from '@angular/core'\nimport { AlertController, LoadingController, ToastController } from '@ionic/angular'\nimport { AlertInput, AlertButton, AlertOptions, ToastOptions, ToastButton, LoadingOptions } from '@ionic/core'\nimport { TranslateService } from '@ngx-translate/core'\nimport { APP_CONFIG, AppConfig } from '../../config/app-config'\n\n/**\n * This class provides helper functions for translated UI elements such as alerts, toasts and loaders.\n *\n * This class should most likely not be called directly and instead be wrapped with something like the UiEventElementsService.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class UiEventService {\n  constructor(\n    private readonly translateService: TranslateService,\n    private readonly alertController: AlertController,\n    private readonly toastController: ToastController,\n    private readonly loadingController: LoadingController,\n    @Inject(APP_CONFIG) private readonly appConfig: AppConfig\n  ) {}\n\n  /**\n   * Create a translated loader and show it. If you want a reference to the loader, use `getTranslatedLoader` instead.\n   *\n   * @param optionsInput\n   */\n  public async showTranslatedLoader(optionsInput: LoadingOptions): Promise<void> {\n    const loader: HTMLIonLoadingElement = await this.getTranslatedLoader(optionsInput)\n\n    return loader.present()\n  }\n\n  /**\n   * Create a translated loader and return it.\n   *\n   * @param optionsInput\n   */\n  public async getTranslatedLoader(optionsInput: LoadingOptions): Promise<HTMLIonLoadingElement> {\n    const message = optionsInput.message?.toString()\n\n    const translationKeys: string[] = [message].filter((key: string | undefined): key is string => key !== undefined)\n\n    const options: ToastOptions = {}\n\n    if (translationKeys.length > 0) {\n      const values = await this.translateService.get(translationKeys, this.appConfig).toPromise()\n\n      if (message) {\n        options.message = values[message]\n      }\n    }\n\n    const loader = await this.loadingController.create({\n      backdropDismiss: false, // Apply defaults\n      ...optionsInput, // Overwrite with configuration\n      ...options // Overwrite translations\n    })\n\n    return loader\n  }\n\n  /**\n   * Create a translated toast and show it. If you want a reference to the toast, use `getTranslatedToast` instead.\n   *\n   * @param optionsInput\n   */\n  public async showTranslatedToast(optionsInput: ToastOptions): Promise<void> {\n    const toast: HTMLIonToastElement = await this.getTranslatedToast(optionsInput)\n\n    return toast.present()\n  }\n\n  /**\n   * Create a translated toast and return it.\n   *\n   * @param optionsInput\n   */\n  public async getTranslatedToast(optionsInput: ToastOptions): Promise<HTMLIonToastElement> {\n    const header = optionsInput.header\n    const message = optionsInput.message?.toString()\n    const buttons = optionsInput.buttons ?? []\n\n    const translationKeys: string[] = [\n      header,\n      message,\n      ...buttons.map((button: string | ToastButton) => (typeof button === 'string' ? button : button.text))\n    ].filter((key: string | undefined): key is string => key !== undefined)\n\n    const options: ToastOptions = {}\n\n    if (translationKeys.length > 0) {\n      const values = await this.translateService.get(translationKeys, this.appConfig).toPromise()\n\n      if (header) {\n        options.header = values[header]\n      }\n      if (message) {\n        options.message = values[message]\n      }\n\n      const newButtons: (string | ToastButton)[] | undefined = await this.translateButtons<ToastButton>(buttons, values)\n\n      if (newButtons) {\n        options.buttons = newButtons\n      }\n    }\n\n    const toast = await this.toastController.create({\n      duration: 2000, // Apply defaults\n      ...optionsInput, // Overwrite with configuration\n      ...options // Overwrite translations\n    })\n\n    return toast\n  }\n\n  /**\n   * Create a translated alert and show it. If you want a reference to the alert, use `getTranslatedAlert` instead.\n   *\n   * @param optionsInput\n   */\n  public async showTranslatedAlert(optionsInput: AlertOptions): Promise<void> {\n    const alert: HTMLIonAlertElement = await this.getTranslatedAlert(optionsInput)\n\n    return alert.present()\n  }\n\n  /**\n   * Create a translated alert and return it.\n   *\n   * @param optionsInput\n   */\n  public async getTranslatedAlert(optionsInput: AlertOptions): Promise<HTMLIonAlertElement> {\n    const header = optionsInput.header\n    const subHeader = optionsInput.subHeader\n    const message = optionsInput.message?.toString()\n    const inputs = optionsInput.inputs ?? []\n    const buttons = optionsInput.buttons ?? []\n\n    const translationKeys: string[] = [\n      header,\n      subHeader,\n      message,\n      ...inputs.map((input: AlertInput) => input.name),\n      ...inputs.map((input: AlertInput) => input.placeholder),\n      ...inputs.map((input: AlertInput) => input.value),\n      ...inputs.map((input: AlertInput) => input.label),\n      ...buttons.map((button: string | AlertButton) => (typeof button === 'string' ? button : button.text))\n    ].filter((key: string | undefined): key is string => key !== undefined)\n\n    const options: AlertOptions = {}\n\n    if (translationKeys.length > 0) {\n      const values = await this.translateService.get(translationKeys, this.appConfig).toPromise()\n\n      if (header) {\n        options.header = values[header]\n      }\n      if (subHeader) {\n        options.subHeader = values[subHeader]\n      }\n      if (message) {\n        options.message = values[message]\n      }\n\n      if (inputs.length > 0) {\n        inputs.forEach((input: AlertInput) => {\n          if (input.name !== undefined) {\n            input.name = values[input.name]\n          }\n          if (input.placeholder !== undefined) {\n            input.placeholder = values[input.placeholder]\n          }\n          if (input.value !== undefined) {\n            input.value = values[input.value]\n          }\n          if (input.label !== undefined) {\n            input.label = values[input.label]\n          }\n        })\n\n        options.inputs = inputs\n      }\n\n      const newButtons: (string | AlertButton)[] | undefined = await this.translateButtons<AlertButton>(buttons, values)\n\n      if (newButtons) {\n        options.buttons = newButtons\n      }\n    }\n\n    const alert = await this.alertController.create({\n      backdropDismiss: true, // Apply defaults\n      ...optionsInput, // Overwrite with configuration\n      ...options // Overwrite translations\n    })\n\n    return alert\n  }\n\n  private async translateButtons<T extends AlertButton | ToastButton>(\n    buttons: (string | T)[],\n    values: { [key: string]: string }\n  ): Promise<undefined | (string | T)[]> {\n    if (buttons.length > 0) {\n      const newButtons: (string | T)[] = []\n      buttons.forEach((button: string | T) => {\n        if (typeof button === 'string') {\n          // eslint-disable-next-line no-param-reassign\n          newButtons.push(values[button])\n        } else {\n          if (button.text) {\n            button.text = values[button.text]\n            newButtons.push(button)\n          }\n        }\n      })\n\n      return newButtons\n    } else {\n      return undefined\n    }\n  }\n}\n"]}

package/esm2022/lib/services/ui-event-elements/ui-event-elements.service.mjs

@@ -0,0 +1,122 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../ui-event/ui-event.service";
+export class UiEventElementsService {
+    constructor(uiEventService) {
+        this.uiEventService = uiEventService;
+    }
+    async showSuccessfullyCopiedToClipboardToast(message = 'clipboard.toast.success_text') {
+        await this.uiEventService.showTranslatedToast({
+            message,
+            position: 'top',
+            buttons: [
+                {
+                    text: 'clipboard.toast.ok_label',
+                    role: 'cancel'
+                }
+            ]
+        });
+    }
+    async showIACMessageUnknownAlert(relayHandler, copyHandler, cancelHandler) {
+        const relayButton = {
+            text: 'iac.message-unknown_alert.relay_label',
+            handler: relayHandler
+        };
+        const copyButton = {
+            text: 'iac.message-unknown_alert.copy_label',
+            handler: copyHandler
+        };
+        const cancelButton = {
+            text: 'iac.message-unknown_alert.cancel_label',
+            role: 'cancel',
+            handler: cancelHandler
+        };
+        await this.uiEventService.showTranslatedAlert({
+            header: 'iac.message-unknown_alert.header',
+            message: 'iac.message-unknown_alert.message',
+            buttons: [relayButton, copyButton, cancelButton]
+        });
+    }
+    async showIACMessageNotSupportedAlert(relayHandler, copyHandler, cancelHandler) {
+        const relayButton = {
+            text: 'iac.message-not-supported_alert.relay_label',
+            handler: relayHandler
+        };
+        const copyButton = {
+            text: 'iac.message-not-supported_alert.copy_label',
+            handler: copyHandler
+        };
+        const cancelButton = {
+            text: 'iac.message-not-supported_alert.cancel_label',
+            role: 'cancel',
+            handler: cancelHandler
+        };
+        await this.uiEventService.showTranslatedAlert({
+            header: 'iac.message-not-supported_alert.header',
+            message: 'iac.message-not-supported_alert.message',
+            buttons: [relayButton, copyButton, cancelButton]
+        });
+    }
+    async showDeeplinkOnlyAvailableOnDevicesAlert() {
+        await this.uiEventService.showTranslatedAlert({
+            header: 'deeplink.not-supported-alert.title',
+            message: 'deeplink.not-supported-alert.message',
+            buttons: [
+                {
+                    text: 'deeplink.not-supported-alert.ok',
+                    role: 'cancel'
+                }
+            ]
+        });
+    }
+    async invalidDeeplinkAlert() {
+        await this.uiEventService.showTranslatedAlert({
+            header: 'deeplink.invalid.title',
+            message: 'deeplink.invalid.message',
+            buttons: [
+                {
+                    text: 'deeplink.invalid.ok',
+                    role: 'cancel'
+                }
+            ]
+        });
+    }
+    async showOtherAppNotFoundAlert() {
+        await this.uiEventService.showTranslatedAlert({
+            header: 'deeplink.app-not-found.title',
+            message: 'deeplink.app-not-found.message',
+            buttons: [
+                {
+                    text: 'deeplink.app-not-found.ok',
+                    role: 'cancel'
+                }
+            ]
+        });
+    }
+    async showOpenSettingsAlert(openSettingsHandler) {
+        await this.uiEventService.showTranslatedAlert({
+            header: 'Settings',
+            message: 'You can enable the missing permissions in the device settings.',
+            buttons: [
+                {
+                    text: 'Cancel',
+                    role: 'cancel',
+                    handler: () => undefined
+                },
+                {
+                    text: 'Open settings',
+                    handler: openSettingsHandler
+                }
+            ]
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UiEventElementsService, deps: [{ token: i1.UiEventService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UiEventElementsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UiEventElementsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.UiEventService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui-event-elements.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/ui-event-elements/ui-event-elements.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport { UiEventService } from '../ui-event/ui-event.service'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class UiEventElementsService {\n  constructor(private readonly uiEventService: UiEventService) {}\n\n  public async showSuccessfullyCopiedToClipboardToast(message: string = 'clipboard.toast.success_text'): Promise<void> {\n    await this.uiEventService.showTranslatedToast({\n      message,\n      position: 'top',\n      buttons: [\n        {\n          text: 'clipboard.toast.ok_label',\n          role: 'cancel'\n        }\n      ]\n    })\n  }\n\n  public async showIACMessageUnknownAlert(relayHandler: () => void, copyHandler: () => void, cancelHandler: () => void): Promise<void> {\n    const relayButton = {\n      text: 'iac.message-unknown_alert.relay_label',\n      handler: relayHandler\n    }\n\n    const copyButton = {\n      text: 'iac.message-unknown_alert.copy_label',\n      handler: copyHandler\n    }\n\n    const cancelButton = {\n      text: 'iac.message-unknown_alert.cancel_label',\n      role: 'cancel',\n      handler: cancelHandler\n    }\n\n    await this.uiEventService.showTranslatedAlert({\n      header: 'iac.message-unknown_alert.header',\n      message: 'iac.message-unknown_alert.message',\n      buttons: [relayButton, copyButton, cancelButton]\n    })\n  }\n\n  public async showIACMessageNotSupportedAlert(\n    relayHandler: () => void,\n    copyHandler: () => void,\n    cancelHandler: () => void\n  ): Promise<void> {\n    const relayButton = {\n      text: 'iac.message-not-supported_alert.relay_label',\n      handler: relayHandler\n    }\n\n    const copyButton = {\n      text: 'iac.message-not-supported_alert.copy_label',\n      handler: copyHandler\n    }\n\n    const cancelButton = {\n      text: 'iac.message-not-supported_alert.cancel_label',\n      role: 'cancel',\n      handler: cancelHandler\n    }\n\n    await this.uiEventService.showTranslatedAlert({\n      header: 'iac.message-not-supported_alert.header',\n      message: 'iac.message-not-supported_alert.message',\n      buttons: [relayButton, copyButton, cancelButton]\n    })\n  }\n\n  public async showDeeplinkOnlyAvailableOnDevicesAlert(): Promise<void> {\n    await this.uiEventService.showTranslatedAlert({\n      header: 'deeplink.not-supported-alert.title',\n      message: 'deeplink.not-supported-alert.message',\n      buttons: [\n        {\n          text: 'deeplink.not-supported-alert.ok',\n          role: 'cancel'\n        }\n      ]\n    })\n  }\n\n  public async invalidDeeplinkAlert(): Promise<void> {\n    await this.uiEventService.showTranslatedAlert({\n      header: 'deeplink.invalid.title',\n      message: 'deeplink.invalid.message',\n      buttons: [\n        {\n          text: 'deeplink.invalid.ok',\n          role: 'cancel'\n        }\n      ]\n    })\n  }\n\n  public async showOtherAppNotFoundAlert(): Promise<void> {\n    await this.uiEventService.showTranslatedAlert({\n      header: 'deeplink.app-not-found.title',\n      message: 'deeplink.app-not-found.message',\n      buttons: [\n        {\n          text: 'deeplink.app-not-found.ok',\n          role: 'cancel'\n        }\n      ]\n    })\n  }\n\n  public async showOpenSettingsAlert(openSettingsHandler: () => void): Promise<void> {\n    await this.uiEventService.showTranslatedAlert({\n      header: 'Settings',\n      message: 'You can enable the missing permissions in the device settings.',\n      buttons: [\n        {\n          text: 'Cancel',\n          role: 'cancel',\n          handler: () => undefined\n        },\n        {\n          text: 'Open settings',\n          handler: openSettingsHandler\n        }\n      ]\n    })\n  }\n}\n"]}

package/esm2022/lib/services/uri/uri.service.mjs

@@ -0,0 +1,51 @@
+import { HttpRemoteData } from '@wallfree-dev/coinlib-core/utils/remote-data/HttpRemoteData';
+import { IpfsRemoteData } from '@wallfree-dev/coinlib-core/utils/remote-data/IpfsRemoteData';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+const SCHEME = {
+    data: 'data'
+};
+const EXTENSION = {
+    base64: 'base64'
+};
+export class UriService {
+    resolveUriType(uri) {
+        if (uri.startsWith(SCHEME.data)) {
+            return 'data';
+        }
+        else if (IpfsRemoteData.validate(uri) || HttpRemoteData.validate(uri)) {
+            return 'remote';
+        }
+        else {
+            return 'unsupported';
+        }
+    }
+    splitDataUri(uri) {
+        if (!uri.startsWith(SCHEME.data)) {
+            return undefined;
+        }
+        const dataSeparatorIndex = uri.indexOf(',');
+        const extensionSeparatorIndex = uri.indexOf(';');
+        const mediaType = uri.slice(`${SCHEME.data}:`.length, extensionSeparatorIndex !== -1 ? extensionSeparatorIndex : dataSeparatorIndex);
+        const isBinary = uri.includes(EXTENSION.base64);
+        const data = uri.slice(dataSeparatorIndex + 1);
+        return {
+            mediaType: mediaType.length > 0 ? mediaType : undefined,
+            isBinary,
+            data
+        };
+    }
+    data(data, mediaType = '', isBinary = false) {
+        const extension = isBinary ? `;${EXTENSION.base64}` : '';
+        return `${SCHEME.data}:${mediaType}${extension},${data}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UriService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UriService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UriService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/translation/AirGapTranslateLoader.mjs

@@ -0,0 +1,26 @@
+import { forkJoin, of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+export class AirGapTranslateLoader {
+    constructor(httpClient, resources = { prefix: './assets/i18n/', suffix: '.json' }) {
+        this.httpClient = httpClient;
+        const externalResources = Array.isArray(resources) ? resources : [resources];
+        const commonResources = [
+            {
+                prefix: './assets/i18n-common/',
+                suffix: '.json'
+            }
+        ];
+        this.translateResources = commonResources.concat(externalResources);
+    }
+    getTranslation(lang) {
+        return forkJoin(this.translateResources.map((resource) => {
+            const resourcePath = `${resource.prefix}${lang}${resource.suffix}`;
+            return this.httpClient.get(resourcePath).pipe(catchError((error) => {
+                // eslint-disable-next-line no-console
+                console.warn(`[CommonTranslateLoader:getTranslation] could not load translation file ${resourcePath}: ${error}`);
+                return of({});
+            }));
+        })).pipe(map((translations) => translations.reduce((object, next) => Object.assign(object, next), {})));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWlyR2FwVHJhbnNsYXRlTG9hZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi90cmFuc2xhdGlvbi9BaXJHYXBUcmFuc2xhdGVMb2FkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUFFLFFBQVEsRUFBYyxFQUFFLEVBQUUsTUFBTSxNQUFNLENBQUE7QUFDL0MsT0FBTyxFQUFFLFVBQVUsRUFBRSxHQUFHLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQTtBQU9oRCxNQUFNLE9BQU8scUJBQXFCO0lBR2hDLFlBQ21CLFVBQXNCLEVBQ3ZDLFlBQXFELEVBQUUsTUFBTSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUU7UUFEakYsZUFBVSxHQUFWLFVBQVUsQ0FBWTtRQUd2QyxNQUFNLGlCQUFpQixHQUF3QixLQUFLLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUE7UUFDakcsTUFBTSxlQUFlLEdBQXdCO1lBQzNDO2dCQUNFLE1BQU0sRUFBRSx1QkFBdUI7Z0JBQy9CLE1BQU0sRUFBRSxPQUFPO2FBQ2hCO1NBQ0YsQ0FBQTtRQUVELElBQUksQ0FBQyxrQkFBa0IsR0FBRyxlQUFlLENBQUMsTUFBTSxDQUFDLGlCQUFpQixDQUFDLENBQUE7SUFDckUsQ0FBQztJQUVNLGNBQWMsQ0FBQyxJQUFZO1FBQ2hDLE9BQU8sUUFBUSxDQUNiLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxHQUFHLENBQUMsQ0FBQyxRQUEyQixFQUFFLEVBQUU7WUFDMUQsTUFBTSxZQUFZLEdBQUcsR0FBRyxRQUFRLENBQUMsTUFBTSxHQUFHLElBQUksR0FBRyxRQUFRLENBQUMsTUFBTSxFQUFFLENBQUE7WUFFbEUsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQyxJQUFJLENBQzNDLFVBQVUsQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFO2dCQUNuQixzQ0FBc0M7Z0JBQ3RDLE9BQU8sQ0FBQyxJQUFJLENBQUMsMEVBQTBFLFlBQVksS0FBSyxLQUFLLEVBQUUsQ0FBQyxDQUFBO2dCQUVoSCxPQUFPLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQTtZQUNmLENBQUMsQ0FBQyxDQUNILENBQUE7UUFDSCxDQUFDLENBQUMsQ0FDSCxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxZQUFtQixFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUMsTUFBVyxFQUFFLElBQVMsRUFBRSxFQUFFLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ3hILENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIEB0eXBlc2NyaXB0LWVzbGludC9uby1leHBsaWNpdC1hbnkgKi9cbmltcG9ydCB7IEh0dHBDbGllbnQgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCdcbmltcG9ydCB7IFRyYW5zbGF0ZUxvYWRlciB9IGZyb20gJ0BuZ3gtdHJhbnNsYXRlL2NvcmUnXG5pbXBvcnQgeyBmb3JrSm9pbiwgT2JzZXJ2YWJsZSwgb2YgfSBmcm9tICdyeGpzJ1xuaW1wb3J0IHsgY2F0Y2hFcnJvciwgbWFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnXG5cbmludGVyZmFjZSBUcmFuc2xhdGVSZXNvdXJjZSB7XG4gIHByZWZpeDogc3RyaW5nXG4gIHN1ZmZpeDogc3RyaW5nXG59XG5cbmV4cG9ydCBjbGFzcyBBaXJHYXBUcmFuc2xhdGVMb2FkZXIgaW1wbGVtZW50cyBUcmFuc2xhdGVMb2FkZXIge1xuICBwcml2YXRlIHJlYWRvbmx5IHRyYW5zbGF0ZVJlc291cmNlczogVHJhbnNsYXRlUmVzb3VyY2VbXVxuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgcmVhZG9ubHkgaHR0cENsaWVudDogSHR0cENsaWVudCxcbiAgICByZXNvdXJjZXM6IFRyYW5zbGF0ZVJlc291cmNlIHwgVHJhbnNsYXRlUmVzb3VyY2VbXSA9IHsgcHJlZml4OiAnLi9hc3NldHMvaTE4bi8nLCBzdWZmaXg6ICcuanNvbicgfVxuICApIHtcbiAgICBjb25zdCBleHRlcm5hbFJlc291cmNlczogVHJhbnNsYXRlUmVzb3VyY2VbXSA9IEFycmF5LmlzQXJyYXkocmVzb3VyY2VzKSA/IHJlc291cmNlcyA6IFtyZXNvdXJjZXNdXG4gICAgY29uc3QgY29tbW9uUmVzb3VyY2VzOiBUcmFuc2xhdGVSZXNvdXJjZVtdID0gW1xuICAgICAge1xuICAgICAgICBwcmVmaXg6ICcuL2Fzc2V0cy9pMThuLWNvbW1vbi8nLFxuICAgICAgICBzdWZmaXg6ICcuanNvbidcbiAgICAgIH1cbiAgICBdXG5cbiAgICB0aGlzLnRyYW5zbGF0ZVJlc291cmNlcyA9IGNvbW1vblJlc291cmNlcy5jb25jYXQoZXh0ZXJuYWxSZXNvdXJjZXMpXG4gIH1cblxuICBwdWJsaWMgZ2V0VHJhbnNsYXRpb24obGFuZzogc3RyaW5nKTogT2JzZXJ2YWJsZTxhbnk+IHtcbiAgICByZXR1cm4gZm9ya0pvaW4oXG4gICAgICB0aGlzLnRyYW5zbGF0ZVJlc291cmNlcy5tYXAoKHJlc291cmNlOiBUcmFuc2xhdGVSZXNvdXJjZSkgPT4ge1xuICAgICAgICBjb25zdCByZXNvdXJjZVBhdGggPSBgJHtyZXNvdXJjZS5wcmVmaXh9JHtsYW5nfSR7cmVzb3VyY2Uuc3VmZml4fWBcblxuICAgICAgICByZXR1cm4gdGhpcy5odHRwQ2xpZW50LmdldChyZXNvdXJjZVBhdGgpLnBpcGUoXG4gICAgICAgICAgY2F0Y2hFcnJvcigoZXJyb3IpID0+IHtcbiAgICAgICAgICAgIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1jb25zb2xlXG4gICAgICAgICAgICBjb25zb2xlLndhcm4oYFtDb21tb25UcmFuc2xhdGVMb2FkZXI6Z2V0VHJhbnNsYXRpb25dIGNvdWxkIG5vdCBsb2FkIHRyYW5zbGF0aW9uIGZpbGUgJHtyZXNvdXJjZVBhdGh9OiAke2Vycm9yfWApXG5cbiAgICAgICAgICAgIHJldHVybiBvZih7fSlcbiAgICAgICAgICB9KVxuICAgICAgICApXG4gICAgICB9KVxuICAgICkucGlwZShtYXAoKHRyYW5zbGF0aW9uczogYW55W10pID0+IHRyYW5zbGF0aW9ucy5yZWR1Y2UoKG9iamVjdDogYW55LCBuZXh0OiBhbnkpID0+IE9iamVjdC5hc3NpZ24ob2JqZWN0LCBuZXh0KSwge30pKSlcbiAgfVxufVxuIl19

package/esm2022/lib/types/Either.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRWl0aGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi90eXBlcy9FaXRoZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIEVpdGhlcjxULCBSPiA9IFtULCB1bmRlZmluZWRdIHwgW3VuZGVmaW5lZCwgUl1cbiJdfQ==

package/esm2022/lib/types/ExternalAliasResolver.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRXh0ZXJuYWxBbGlhc1Jlc29sdmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi90eXBlcy9FeHRlcm5hbEFsaWFzUmVzb2x2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgRXh0ZXJuYWxBbGlhc1Jlc29sdmVyIHtcbiAgdmFsaWRhdGVSZWNlaXZlcihyZWNlaXZlcjogc3RyaW5nKTogUHJvbWlzZTxib29sZWFuPlxuICByZXNvbHZlQWxpYXMoYWxpYXM6IHN0cmluZyk6IFByb21pc2U8c3RyaW5nIHwgdW5kZWZpbmVkPlxuICBnZXRBbGlhcyhhZGRyZXNzOiBzdHJpbmcpOiBQcm9taXNlPHN0cmluZyB8IHVuZGVmaW5lZD5cbn1cbiJdfQ==

package/esm2022/lib/types/RuntimeMode.mjs

@@ -0,0 +1,6 @@
+export var RuntimeMode;
+(function (RuntimeMode) {
+    RuntimeMode["OFFLINE"] = "offline";
+    RuntimeMode["ONLINE"] = "online";
+})(RuntimeMode || (RuntimeMode = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUnVudGltZU1vZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3R5cGVzL1J1bnRpbWVNb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFdBR1g7QUFIRCxXQUFZLFdBQVc7SUFDckIsa0NBQW1CLENBQUE7SUFDbkIsZ0NBQWlCLENBQUE7QUFDbkIsQ0FBQyxFQUhXLFdBQVcsS0FBWCxXQUFXLFFBR3RCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gUnVudGltZU1vZGUge1xuICBPRkZMSU5FID0gJ29mZmxpbmUnLFxuICBPTkxJTkUgPSAnb25saW5lJ1xufVxuIl19

package/esm2022/lib/types/SupportedLanguage.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3VwcG9ydGVkTGFuZ3VhZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3R5cGVzL1N1cHBvcnRlZExhbmd1YWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBTdXBwb3J0ZWRMYW5ndWFnZSA9ICdlbicgfCAnZGUnIHwgJ2VzJyB8ICd6aCdcbiJdfQ==

package/esm2022/lib/types/Token.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3R5cGVzL1Rva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFRva2VuIHtcbiAgc3ltYm9sOiBzdHJpbmdcbiAgbmFtZTogc3RyaW5nXG4gIG1hcmtldFN5bWJvbDogc3RyaW5nXG4gIGlkZW50aWZpZXI6IHN0cmluZ1xuICBjb250cmFjdEFkZHJlc3M6IHN0cmluZ1xuICBkZWNpbWFsczogbnVtYmVyXG59XG4iXX0=

package/esm2022/lib/types/isolated-modules/IsolatedModule.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSXNvbGF0ZWRNb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3R5cGVzL2lzb2xhdGVkLW1vZHVsZXMvSXNvbGF0ZWRNb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIHNwYWNlZC1jb21tZW50ICovXG5pbXBvcnQge1xuICBCbG9ja0V4cGxvcmVyTWV0YWRhdGEsXG4gIFByb3RvY29sQ29uZmlndXJhdGlvbixcbiAgUHJvdG9jb2xNZXRhZGF0YSxcbiAgUHJvdG9jb2xOZXR3b3JrLFxuICBTdWJQcm90b2NvbFR5cGUsXG4gIFYzU2NoZW1hQ29uZmlndXJhdGlvblxufSBmcm9tICdAd2FsbGZyZWUtZGV2L21vZHVsZS1raXQnXG5cbi8qKioqKiBJc29sYXRlZE1vZHVsZSAqKioqKiovXG5cbmV4cG9ydCB0eXBlIElzb2xhdGVkTW9kdWxlVHlwZSA9ICdzdGF0aWMnIHwgJ2R5bmFtaWMnXG5cbmV4cG9ydCBpbnRlcmZhY2UgSXNvbGF0ZWRNb2R1bGUge1xuICBpZGVudGlmaWVyOiBzdHJpbmdcbiAgdHlwZTogSXNvbGF0ZWRNb2R1bGVUeXBlXG4gIHByb3RvY29sczogSXNvbGF0ZWRQcm90b2NvbFtdXG4gIHYzU2NoZW1hQ29uZmlndXJhdGlvbnM6IFYzU2NoZW1hQ29uZmlndXJhdGlvbltdXG59XG5cbmludGVyZmFjZSBJc29sYXRlZEFueVByb3RvY29sPFQgZXh0ZW5kcyBzdHJpbmc+IHtcbiAgdHlwZTogVFxuICBtb2RlOiBQcm90b2NvbENvbmZpZ3VyYXRpb25bJ3R5cGUnXVxuICBpZGVudGlmaWVyOiBzdHJpbmdcbiAgcHJvdG9jb2xNZXRhZGF0YTogUHJvdG9jb2xNZXRhZGF0YVxuICBibG9ja0V4cGxvcmVyTWV0YWRhdGE6IEJsb2NrRXhwbG9yZXJNZXRhZGF0YSB8IG51bGxcbiAgbmV0d29yazogUHJvdG9jb2xOZXR3b3JrIHwgbnVsbFxuICBtZXRob2RzOiBzdHJpbmdbXVxuICBjYWNoZWRWYWx1ZXM6IFJlY29yZDxzdHJpbmcsIHVua25vd24+XG59XG50eXBlIElzb2xhdGVkTWFpblByb3RvY29sID0gSXNvbGF0ZWRBbnlQcm90b2NvbDwnbWFpbic+XG5pbnRlcmZhY2UgSXNvbGF0ZWRTdWJQcm90b2NvbCBleHRlbmRzIElzb2xhdGVkQW55UHJvdG9jb2w8J3N1Yic+IHtcbiAgc3ViVHlwZTogU3ViUHJvdG9jb2xUeXBlXG4gIG1haW5Qcm90b2NvbElkZW50aWZpZXI6IHN0cmluZ1xuICBjb250cmFjdEFkZHJlc3M6IHN0cmluZyB8IG51bGxcbn1cblxuZXhwb3J0IHR5cGUgSXNvbGF0ZWRQcm90b2NvbCA9IElzb2xhdGVkTWFpblByb3RvY29sIHwgSXNvbGF0ZWRTdWJQcm90b2NvbFxuIl19

package/esm2022/lib/types/isolated-modules/IsolatedModuleManifest.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSXNvbGF0ZWRNb2R1bGVNYW5pZmVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvdHlwZXMvaXNvbGF0ZWQtbW9kdWxlcy9Jc29sYXRlZE1vZHVsZU1hbmlmZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIElzb2xhdGVkTW9kdWxlTWFuaWZlc3Qge1xuICBuYW1lOiBzdHJpbmdcbiAgdmVyc2lvbjogc3RyaW5nXG4gIGF1dGhvcjogc3RyaW5nXG4gIHVybD86IHN0cmluZ1xuICBlbWFpbD86IHN0cmluZ1xuICByZXBvc2l0b3J5Pzogc3RyaW5nXG4gIHB1YmxpY0tleTogc3RyaW5nXG4gIGRlc2NyaXB0aW9uOiBzdHJpbmdcbiAgc3JjPzoge1xuICAgIG5hbWVzcGFjZT86IHN0cmluZ1xuICB9XG4gIHJlcz86IHtcbiAgICBzeW1ib2w/OiB7XG4gICAgICBba2V5OiBzdHJpbmddOiBzdHJpbmdcbiAgICB9XG4gIH1cbiAgaW5jbHVkZTogc3RyaW5nW11cbiAganNlbnY/OiB7XG4gICAgYW5kcm9pZD86ICd3ZWJ2aWV3JyB8ICdqYXZhc2NyaXB0ZW5naW5lJ1xuICAgIGlvcz86ICd3ZWJ2aWV3J1xuICB9XG59XG4iXX0=

package/esm2022/lib/types/isolated-modules/IsolatedModuleMetadata.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSXNvbGF0ZWRNb2R1bGVNZXRhZGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvdHlwZXMvaXNvbGF0ZWQtbW9kdWxlcy9Jc29sYXRlZE1vZHVsZU1ldGFkYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RvcnkgfSBmcm9tICdAY2FwYWNpdG9yL2ZpbGVzeXN0ZW0nXG5pbXBvcnQgeyBJc29sYXRlZE1vZHVsZSB9IGZyb20gJy4vSXNvbGF0ZWRNb2R1bGUnXG5pbXBvcnQgeyBJc29sYXRlZE1vZHVsZU1hbmlmZXN0IH0gZnJvbSAnLi9Jc29sYXRlZE1vZHVsZU1hbmlmZXN0J1xuXG5pbnRlcmZhY2UgQmFzZUlzb2xhdGVkTW9kdWxlTWV0YWRhdGE8VCBleHRlbmRzIHN0cmluZz4ge1xuICB0eXBlOiBUXG4gIG1vZHVsZTogSXNvbGF0ZWRNb2R1bGVcbiAgbWFuaWZlc3Q6IElzb2xhdGVkTW9kdWxlTWFuaWZlc3RcbiAgc291cmNlOiAnYWlyZ2FwJyB8ICczcmRfcGFydHknXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSXNvbGF0ZWRNb2R1bGVQcmV2aWV3TWV0YWRhdGEgZXh0ZW5kcyBCYXNlSXNvbGF0ZWRNb2R1bGVNZXRhZGF0YTwncHJldmlldyc+IHtcbiAgcGF0aDogc3RyaW5nXG4gIHJvb3Q6IHN0cmluZ1xuICBkaXJlY3Rvcnk6IERpcmVjdG9yeVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIElzb2xhdGVkTW9kdWxlSW5zdGFsbGVkTWV0YWRhdGEgZXh0ZW5kcyBCYXNlSXNvbGF0ZWRNb2R1bGVNZXRhZGF0YTwnaW5zdGFsbGVkJz4ge1xuICBpbnN0YWxsZWRBdDogc3RyaW5nXG59XG5cbmV4cG9ydCB0eXBlIElzb2xhdGVkTW9kdWxlQXNzZXRNZXRhZGF0YSA9IEJhc2VJc29sYXRlZE1vZHVsZU1ldGFkYXRhPCdhc3NldCc+XG5cbmV4cG9ydCB0eXBlIElzb2xhdGVkTW9kdWxlTWV0YWRhdGEgPSBJc29sYXRlZE1vZHVsZVByZXZpZXdNZXRhZGF0YSB8IElzb2xhdGVkTW9kdWxlSW5zdGFsbGVkTWV0YWRhdGEgfCBJc29sYXRlZE1vZHVsZUFzc2V0TWV0YWRhdGFcbiJdfQ==

package/esm2022/lib/types/ui/UIAction.mjs

@@ -0,0 +1,6 @@
+export var UIActionStatus;
+(function (UIActionStatus) {
+    UIActionStatus["PENDING"] = "pending";
+    UIActionStatus["HANDLED"] = "handled";
+})(UIActionStatus || (UIActionStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVUlBY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3R5cGVzL3VpL1VJQWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGNBR1g7QUFIRCxXQUFZLGNBQWM7SUFDeEIscUNBQW1CLENBQUE7SUFDbkIscUNBQW1CLENBQUE7QUFDckIsQ0FBQyxFQUhXLGNBQWMsS0FBZCxjQUFjLFFBR3pCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gVUlBY3Rpb25TdGF0dXMge1xuICBQRU5ESU5HID0gJ3BlbmRpbmcnLFxuICBIQU5ETEVEID0gJ2hhbmRsZWQnXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVUlBY3Rpb248VD4ge1xuICBpZDogc3RyaW5nXG4gIHZhbHVlOiBUXG4gIHN0YXR1czogVUlBY3Rpb25TdGF0dXNcbn1cbiJdfQ==

package/esm2022/lib/types/ui/UIResource.mjs

@@ -0,0 +1,8 @@
+export var UIResourceStatus;
+(function (UIResourceStatus) {
+    UIResourceStatus["IDLE"] = "idle";
+    UIResourceStatus["SUCCESS"] = "success";
+    UIResourceStatus["ERROR"] = "error";
+    UIResourceStatus["LOADING"] = "loading";
+})(UIResourceStatus || (UIResourceStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVUlSZXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvdHlwZXMvdWkvVUlSZXNvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxnQkFLWDtBQUxELFdBQVksZ0JBQWdCO0lBQzFCLGlDQUFhLENBQUE7SUFDYix1Q0FBbUIsQ0FBQTtJQUNuQixtQ0FBZSxDQUFBO0lBQ2YsdUNBQW1CLENBQUE7QUFDckIsQ0FBQyxFQUxXLGdCQUFnQixLQUFoQixnQkFBZ0IsUUFLM0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBVSVJlc291cmNlU3RhdHVzIHtcbiAgSURMRSA9ICdpZGxlJyxcbiAgU1VDQ0VTUyA9ICdzdWNjZXNzJyxcbiAgRVJST1IgPSAnZXJyb3InLFxuICBMT0FESU5HID0gJ2xvYWRpbmcnXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVUlSZXNvdXJjZTxUPiB7XG4gIHZhbHVlOiBUIHwgdW5kZWZpbmVkXG4gIHN0YXR1czogVUlSZXNvdXJjZVN0YXR1c1xufVxuIl19