@telia-ace/widget-services 1.0.0

package/LICENSE.txt

@@ -0,0 +1,6 @@
+Copyright © 2021, Telia Company AB. All rights reserved.
+
+THIS PACKAGE AND CONTAINING SOFTWARE IS PART OF
+THE HUMANY SERVICE. BY USING THIS SOFTWARE YOU
+AGREE TO THE FOLLOWING TERMS AND CONDITIONS:
+http://www.humany.com/legal

package/README.md

@@ -0,0 +1,3 @@
+# `@telia-ace/widget-services`
+
+Services for ACE Widgets.

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { createStorageWriter, LegacyStorage as StorageService, LegacyStorageProvider as StorageProvider, readStorage, StorageCategory, StorageMedium, storagePolicyConfigurationApi, StorageScope, } from './storage';
+export type { Duration, StorageWriter, StorageWriterOptions } from './storage';

package/lib/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageScope = exports.storagePolicyConfigurationApi = exports.StorageMedium = exports.StorageCategory = exports.readStorage = exports.StorageProvider = exports.StorageService = exports.createStorageWriter = void 0;
+var storage_1 = require("./storage");
+Object.defineProperty(exports, "createStorageWriter", { enumerable: true, get: function () { return storage_1.createStorageWriter; } });
+Object.defineProperty(exports, "StorageService", { enumerable: true, get: function () { return storage_1.LegacyStorage; } });
+Object.defineProperty(exports, "StorageProvider", { enumerable: true, get: function () { return storage_1.LegacyStorageProvider; } });
+Object.defineProperty(exports, "readStorage", { enumerable: true, get: function () { return storage_1.readStorage; } });
+Object.defineProperty(exports, "StorageCategory", { enumerable: true, get: function () { return storage_1.StorageCategory; } });
+Object.defineProperty(exports, "StorageMedium", { enumerable: true, get: function () { return storage_1.StorageMedium; } });
+Object.defineProperty(exports, "storagePolicyConfigurationApi", { enumerable: true, get: function () { return storage_1.storagePolicyConfigurationApi; } });
+Object.defineProperty(exports, "StorageScope", { enumerable: true, get: function () { return storage_1.StorageScope; } });

package/lib/storage/index.d.ts

@@ -0,0 +1,5 @@
+export { default as LegacyStorageProvider, LegacyStorage } from './legacy-storage-provider';
+export { createStorageWriter, readStorage } from './storage';
+export { default as storagePolicyConfigurationApi } from './storage-policy-configuration-api';
+export { StorageCategory, StorageMedium, StorageScope } from './types';
+export type { Duration, StorageWriter, StorageWriterOptions } from './types';

package/lib/storage/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageScope = exports.StorageMedium = exports.StorageCategory = exports.storagePolicyConfigurationApi = exports.readStorage = exports.createStorageWriter = exports.LegacyStorage = exports.LegacyStorageProvider = void 0;
+var legacy_storage_provider_1 = require("./legacy-storage-provider");
+Object.defineProperty(exports, "LegacyStorageProvider", { enumerable: true, get: function () { return __importDefault(legacy_storage_provider_1).default; } });
+Object.defineProperty(exports, "LegacyStorage", { enumerable: true, get: function () { return legacy_storage_provider_1.LegacyStorage; } });
+var storage_1 = require("./storage");
+Object.defineProperty(exports, "createStorageWriter", { enumerable: true, get: function () { return storage_1.createStorageWriter; } });
+Object.defineProperty(exports, "readStorage", { enumerable: true, get: function () { return storage_1.readStorage; } });
+var storage_policy_configuration_api_1 = require("./storage-policy-configuration-api");
+Object.defineProperty(exports, "storagePolicyConfigurationApi", { enumerable: true, get: function () { return __importDefault(storage_policy_configuration_api_1).default; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "StorageCategory", { enumerable: true, get: function () { return types_1.StorageCategory; } });
+Object.defineProperty(exports, "StorageMedium", { enumerable: true, get: function () { return types_1.StorageMedium; } });
+Object.defineProperty(exports, "StorageScope", { enumerable: true, get: function () { return types_1.StorageScope; } });

package/lib/storage/legacy-storage-provider.d.ts

@@ -0,0 +1,25 @@
+import { StorageScope } from './types';
+declare type LegacyOptions = {
+    scope?: StorageScope;
+    expiration?: Date;
+};
+interface LegacyMedium {
+    setItem(key: string, value: any, options?: LegacyOptions): Promise<void>;
+    getItem(key: string): Promise<any>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare class LegacyStorage implements LegacyMedium {
+    private memory;
+    setItem(key: string, value: any, options?: LegacyOptions): Promise<void>;
+    getItem(key: string): Promise<any>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export default class LegacyStorageProvider {
+    cookies: LegacyStorage;
+    session: LegacyStorage;
+    local: LegacyStorage;
+    constructor();
+}
+export {};

package/lib/storage/legacy-storage-provider.js

@@ -0,0 +1,120 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyStorage = void 0;
+var widget_utilities_1 = require("@telia-ace/widget-utilities");
+var _1 = require(".");
+var types_1 = require("./types");
+var utils_1 = require("./utils");
+var LegacyStorage = /** @class */ (function () {
+    function LegacyStorage() {
+        this.memory = {
+            tenant: {},
+            implementation: {},
+            widget: {},
+        };
+    }
+    LegacyStorage.prototype.setItem = function (key, value, options) {
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (0, widget_utilities_1.lock)(this)(function () {
+                        var processedStore = (0, utils_1.processStore)(_this.memory, [_1.StorageCategory.Necessary]);
+                        var _a = options.scope, scope = _a === void 0 ? types_1.StorageScope.Tenant : _a, expiration = options.expiration;
+                        processedStore[scope][key] = (0, utils_1.createValue)(value, _1.StorageCategory.Necessary, (expiration === null || expiration === void 0 ? void 0 : expiration.toISOString()) || (0, utils_1.createExpirationDate)());
+                        _this.memory = processedStore;
+                        if (process.env.NODE_ENV !== 'production') {
+                            widget_utilities_1.Logger.warn("StorageProvider: StorageProvider is deprecated, use createStorageWriter and readStorage instead, value stored temporarily in memory.\n                    Key: ".concat(key, "\n                    Value: ").concat(JSON.stringify(value), "\n                    Options: ").concat(JSON.stringify(options), "\n                    Memory: ").concat(JSON.stringify(processedStore)));
+                        }
+                    })];
+            });
+        });
+    };
+    LegacyStorage.prototype.getItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (0, widget_utilities_1.lock)(this)(function () {
+                        var processedStore = (0, utils_1.processStore)(_this.memory, [_1.StorageCategory.Necessary]);
+                        if (process.env.NODE_ENV !== 'production') {
+                            widget_utilities_1.Logger.warn("StorageProvider: StorageProvider is deprecated, use createStorageWriter and readStorage instead, value fetched from legacy memory storage.\n                    Key: ".concat(key, "\n                    Memory: ").concat(JSON.stringify(processedStore)));
+                        }
+                        var value = (0, utils_1.getValue)(processedStore, key);
+                        _this.memory = processedStore;
+                        return value;
+                    })];
+            });
+        });
+    };
+    LegacyStorage.prototype.removeItem = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (0, widget_utilities_1.lock)(this)(function () {
+                        var processedStore = (0, utils_1.processStore)(_this.memory, [_1.StorageCategory.Necessary]);
+                        delete processedStore.tenant[key];
+                        delete processedStore.implementation[key];
+                        delete processedStore.widget[key];
+                        _this.memory = processedStore;
+                        if (process.env.NODE_ENV !== 'production') {
+                            widget_utilities_1.Logger.warn("StorageProvider: StorageProvider is deprecated, use createStorageWriter and readStorage instead, value removed from memory.\n                    Key: ".concat(key, "\n                    Memory: ").concat(JSON.stringify(processedStore)));
+                        }
+                    })];
+            });
+        });
+    };
+    LegacyStorage.prototype.clear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Promise.resolve()];
+            });
+        });
+    };
+    return LegacyStorage;
+}());
+exports.LegacyStorage = LegacyStorage;
+var LegacyStorageProvider = /** @class */ (function () {
+    function LegacyStorageProvider() {
+        this.cookies = new LegacyStorage();
+        this.session = new LegacyStorage();
+        this.local = new LegacyStorage();
+    }
+    return LegacyStorageProvider;
+}());
+exports.default = LegacyStorageProvider;

package/lib/storage/storage-policy-configuration-api.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@webprovisions/platform").ConfigurationApiDefinition;
+export default _default;

package/lib/storage/storage-policy-configuration-api.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var widget_utilities_1 = require("@telia-ace/widget-utilities");
+var platform_1 = require("@webprovisions/platform");
+var storage_1 = require("./storage");
+var types_1 = require("./types");
+var utils_1 = require("./utils");
+exports.default = (0, platform_1.createConfigurationApi)(function (builder) {
+    builder.createCommand('storage', function (context) { return function (options) {
+        if (options === void 0) { options = {}; }
+        var consent = options.consent;
+        if (typeof consent !== 'undefined') {
+            if (typeof consent !== 'number' &&
+                typeof consent !== 'string' &&
+                !Array.isArray(consent)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    widget_utilities_1.Logger.warn("storagePolicyConfigurationApi: passed consent is not valid. Consent either has to be a number, a string, an array of strings or an array of numbers.\n                        Passed consent: ".concat(JSON.stringify(consent)));
+                }
+                return;
+            }
+            if (Array.isArray(consent) &&
+                !consent.every(function (c) { return typeof c === 'number' || typeof c === 'string'; })) {
+                if (process.env.NODE_ENV !== 'production') {
+                    widget_utilities_1.Logger.warn("storagePolicyConfigurationApi: passed consent is not valid. Consent either has to be a number, a string, an array of strings or an array of numbers.\n                        Passed consent: ".concat(JSON.stringify(consent)));
+                }
+                return;
+            }
+            var policy_1 = [
+                types_1.StorageCategory.Necessary,
+                types_1.StorageCategory.Functional,
+                types_1.StorageCategory.Analytical,
+                types_1.StorageCategory.Marketing,
+            ].filter(function (category, index, array) {
+                if (typeof consent === 'number') {
+                    // Passed consent is a category level (number)
+                    // Include the passed category level and all categories below it
+                    return consent > index;
+                }
+                else if (typeof consent === 'string') {
+                    // Passed consent is a category (string)
+                    // Include the passed category and all categories below its level
+                    return array.indexOf(consent) + 1 > index;
+                }
+                else if (Array.isArray(consent)) {
+                    // Passed consent is an array with category levels (number), categories (string) or both
+                    // Include all categories in passed array
+                    return (consent.findIndex(function (c) {
+                        return c === index + 1 || c === category;
+                    }) > -1);
+                }
+                else {
+                    return true;
+                }
+            });
+            if (policy_1.indexOf(types_1.StorageCategory.Necessary) === -1) {
+                if (process.env.NODE_ENV !== 'production') {
+                    widget_utilities_1.Logger.warn("storagePolicyConfigurationApi: passed consent does not include category: '".concat(types_1.StorageCategory.Necessary, "'. Consent has to atleast include the '").concat(types_1.StorageCategory.Necessary, "' category.\n                        Passed consent: ").concat(JSON.stringify(consent)));
+                }
+                policy_1.unshift(types_1.StorageCategory.Necessary);
+            }
+            return (0, storage_1.createStorageWriter)(context.container, 'storagePolicy', types_1.StorageCategory.Necessary, {
+                medium: types_1.StorageMedium.Cookie,
+                scope: types_1.StorageScope.Tenant,
+                duration: { days: 365 },
+            })
+                .then(function (write) { return write(policy_1); })
+                .then(function () {
+                (0, utils_1.processStorage)(context.container);
+                context.events.dispatch('storage:policy-changed', policy_1);
+            });
+        }
+    }; });
+});

package/lib/storage/storage.d.ts

@@ -0,0 +1,19 @@
+import { Container } from '@webprovisions/platform';
+import { StorageCategory, StorageMedium, StorageWriter, StorageWriterOptions } from './types';
+/**
+ * Creates a writer to be used to write to cookie, local or session storage.
+ * @param container Widget Container.
+ * @param key Key to use when writing.
+ * @param category StorageCategory to use when writing.
+ * @param options StorageWriterOptions to use when writing default {scope: StorageScope.Widget, medium = StorageMedium.Session, duration = {days: 30}}.
+ * @returns a function to be used to write a value to the storage using given settings.
+ */
+export declare const createStorageWriter: (container: Container, key: string, category: StorageCategory, options?: StorageWriterOptions) => Promise<StorageWriter>;
+/**
+ * Read the widget cookie, local or session storage.
+ * @param container Widget Container.
+ * @param key Key to read.
+ * @param medium Storage medium to read from (default: session).
+ * @returns the value stored with passed key.
+ */
+export declare const readStorage: <Type>(container: Container, key: string, medium?: StorageMedium) => Promise<Type | undefined>;

package/lib/storage/storage.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStorage = exports.createStorageWriter = void 0;
+var widget_utilities_1 = require("@telia-ace/widget-utilities");
+var types_1 = require("./types");
+var utils_1 = require("./utils");
+/**
+ * Creates a writer to be used to write to cookie, local or session storage.
+ * @param container Widget Container.
+ * @param key Key to use when writing.
+ * @param category StorageCategory to use when writing.
+ * @param options StorageWriterOptions to use when writing default {scope: StorageScope.Widget, medium = StorageMedium.Session, duration = {days: 30}}.
+ * @returns a function to be used to write a value to the storage using given settings.
+ */
+var createStorageWriter = function (container, key, category, options) {
+    if (options === void 0) { options = {}; }
+    return (0, utils_1.isNotAllowedAsync)(container, category).then(function (notAllowed) {
+        if (process.env.NODE_ENV !== 'production') {
+            if (notAllowed) {
+                widget_utilities_1.Logger.warn("createStorageWriter: Attempted to create storage writer using unallowed category.\n                    Key: ".concat(key, "\n                    Category: ").concat(JSON.stringify(category), "\n                    Options: ").concat(JSON.stringify(options)));
+            }
+        }
+        return function (value) {
+            (0, utils_1.processStorage)(container);
+            return (0, utils_1.isNotAllowedAsync)(container, category).then(function (notAllowed) {
+                if (notAllowed) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        widget_utilities_1.Logger.warn("storageWriter: Attempted to write to storage using unallowed category.\n                                Key: ".concat(key, "\n                                Category: ").concat(JSON.stringify(category), "\n                                Value: ").concat(JSON.stringify(value), "\n                                Options: ").concat(JSON.stringify(options)));
+                    }
+                    return;
+                }
+                var _a = options.scope, scope = _a === void 0 ? types_1.StorageScope.Widget : _a, _b = options.medium, medium = _b === void 0 ? types_1.StorageMedium.Session : _b, _c = options.duration, duration = _c === void 0 ? { days: 30 } : _c;
+                var store = (0, utils_1.createEmptyStore)();
+                store[scope][key] = (0, utils_1.createValue)(value, category, duration);
+                if (medium === types_1.StorageMedium.Cookie)
+                    return (0, utils_1.setCookieStoreAsync)(container, store);
+                else
+                    return (0, utils_1.setApplicationStoreAsync)(container, medium, store);
+            });
+        };
+    });
+};
+exports.createStorageWriter = createStorageWriter;
+/**
+ * Read the widget cookie, local or session storage.
+ * @param container Widget Container.
+ * @param key Key to read.
+ * @param medium Storage medium to read from (default: session).
+ * @returns the value stored with passed key.
+ */
+var readStorage = function (container, key, medium) {
+    if (medium === void 0) { medium = types_1.StorageMedium.Session; }
+    (0, utils_1.processStorage)(container);
+    if (typeof key === 'undefined') {
+        if (process.env.NODE_ENV !== 'production') {
+            widget_utilities_1.Logger.warn('readStorage: Undefined key passed when reading storage. ', key, medium);
+        }
+        return Promise.resolve(undefined);
+    }
+    if (medium === types_1.StorageMedium.Cookie)
+        return (0, utils_1.getCookieStoreAsync)(container).then(function (store) { return (0, utils_1.getValue)(store, key); });
+    else
+        return (0, utils_1.getApplicationStoreAsync)(container, medium).then(function (store) { return (0, utils_1.getValue)(store, key); });
+};
+exports.readStorage = readStorage;

package/lib/storage/types.d.ts

@@ -0,0 +1,45 @@
+export declare enum StorageMedium {
+    Cookie = "cookie",
+    Local = "local",
+    Session = "session"
+}
+export declare enum StorageScope {
+    Tenant = "tenant",
+    Implementation = "implementation",
+    Widget = "widget"
+}
+export declare type Store = {
+    tenant: StorageContainer;
+    implementation: StorageContainer;
+    widget: StorageContainer;
+};
+export declare type StorageContainer = {
+    [key: string]: StoredValue;
+};
+export declare type StoredValue = {
+    value: any;
+    expiration: string;
+    category: StorageCategory;
+};
+export declare enum StorageCategory {
+    Necessary = "necessary",
+    Functional = "functional",
+    Analytical = "analytical",
+    Marketing = "marketing"
+}
+export declare type StorageWriter = (value?: any) => Promise<void>;
+export declare type StorageConfigurationOptions = {
+    consent?: StorageConsent;
+};
+export declare type StorageConsent = number | number[] | StorageCategory | StorageCategory[];
+export declare type Duration = {
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+};
+export declare type StorageWriterOptions = {
+    scope?: StorageScope;
+    duration?: Duration;
+    medium?: StorageMedium;
+};

package/lib/storage/types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageCategory = exports.StorageScope = exports.StorageMedium = void 0;
+var StorageMedium;
+(function (StorageMedium) {
+    StorageMedium["Cookie"] = "cookie";
+    StorageMedium["Local"] = "local";
+    StorageMedium["Session"] = "session";
+})(StorageMedium = exports.StorageMedium || (exports.StorageMedium = {}));
+var StorageScope;
+(function (StorageScope) {
+    StorageScope["Tenant"] = "tenant";
+    StorageScope["Implementation"] = "implementation";
+    StorageScope["Widget"] = "widget";
+})(StorageScope = exports.StorageScope || (exports.StorageScope = {}));
+var StorageCategory;
+(function (StorageCategory) {
+    StorageCategory["Necessary"] = "necessary";
+    StorageCategory["Functional"] = "functional";
+    StorageCategory["Analytical"] = "analytical";
+    StorageCategory["Marketing"] = "marketing";
+})(StorageCategory = exports.StorageCategory || (exports.StorageCategory = {}));

package/lib/storage/utils.d.ts

@@ -0,0 +1,36 @@
+import { Container } from '@webprovisions/platform';
+import { Duration, StorageCategory, StorageMedium, Store, StoredValue } from './types';
+export declare const createEmptyStore: () => Store;
+export declare const isExpired: (isoDateString: string) => boolean;
+export declare const getValue: <Type>(store: Store, key: string) => Type | undefined;
+export declare const createValue: (value: any, category: StorageCategory, duration: Duration | string) => StoredValue;
+export declare const processStore: (store: Store, policy?: StorageCategory[] | undefined) => Store;
+/**
+ * @param category Storage Category.
+ * @param policy Current Storage Policy.
+ * @returns true if not allowed, false if allowed.
+ */
+export declare const isNotAllowedAsync: (container: Container, category?: StorageCategory | undefined) => Promise<boolean>;
+/**
+ * @param category Storage Category.
+ * @param policy Current Storage Policy.
+ * @returns true if not allowed, false if allowed.
+ */
+export declare const isNotAllowed: (policy?: StorageCategory[], category?: StorageCategory | undefined) => boolean;
+/**
+ * Processes storage and removes items if they are expired or if
+ * the storage policy is defined and the category of the stored
+ * value is not allowed.
+ * @param container Widget Container
+ */
+export declare const processStorage: (container: Container) => void;
+/**
+ * Creates an expiration date string with the passed options.
+ * @param options Duration options.
+ * @returns ISO formatted date string.
+ */
+export declare const createExpirationDate: (options?: Duration) => string;
+export declare const getCookieStoreAsync: (container: Container) => Promise<Store>;
+export declare const setCookieStoreAsync: (container: Container, store: Store) => Promise<any>;
+export declare const getApplicationStoreAsync: (container: Container, type: StorageMedium.Local | StorageMedium.Session) => Promise<Store>;
+export declare const setApplicationStoreAsync: (container: Container, type: StorageMedium.Local | StorageMedium.Session, store: Store) => Promise<void>;