@getstep/sdk 0.0.1-security → 982.649.0

package/dist/store/AccountStore.js

@@ -0,0 +1,297 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountStore = void 0;
+const mobx_1 = require("mobx");
+const CommonProto_1 = require("../api/generated/CommonProto");
+const Amount_1 = require("../http/models/Amount");
+const SubAccountType_1 = require("../http/models/SubAccountType");
+const ActivityStore_1 = require("./ActivityStore");
+const common_1 = require("./common");
+const StatementStore_1 = require("./StatementStore");
+const SubAccountStore_1 = require("./SubAccountStore");
+const TransactionsStore_1 = require("./TransactionsStore");
+/**
+ * TODO (notrly): remove TransactionsStore when transaction feed is deprecated.
+ */
+class AccountStore extends common_1.DataStore {
+    constructor(account, api, includeClosed = false, transactionStatuses, loadActivity = false) {
+        super();
+        this.api = api;
+        this.includeClosed = includeClosed;
+        this.transactionStatuses = transactionStatuses;
+        this.loadActivity = loadActivity;
+        this.cards = [];
+        this.balance = Amount_1.emptyAmount();
+        this.subAccounts = [];
+        this.account = account;
+        this.transactions = new TransactionsStore_1.TransactionsStore(account, api, transactionStatuses);
+        this.activity = new ActivityStore_1.ActivityStore({ account }, api);
+        this.statements = new StatementStore_1.StatementStore(account, api);
+        this.subAccounts = account.subAccounts.map((subAccount) => new SubAccountStore_1.SubAccountStore(subAccount, api, loadActivity));
+    }
+    get activeCards() {
+        return this.cards.filter((c) => !c.closedAtMs);
+    }
+    get depositAccountId() {
+        return this.subAccountOfType(SubAccountType_1.SubAccountType.DEPOSIT).account.id;
+    }
+    get creditAccountId() {
+        return this.subAccountOfType(SubAccountType_1.SubAccountType.CREDIT).account.id;
+    }
+    async issueCard(cardType, nameOnCard, prompt) {
+        return this.execute(async () => {
+            const card = await this.api.issueCard(this.account.primaryId, cardType, nameOnCard, prompt);
+            return this.addToCache(card);
+        });
+    }
+    async replaceCard(cardId, reason, prompt) {
+        return this.execute(async () => {
+            const { replacement } = await this.api.replaceCard(cardId, reason, prompt);
+            await this.refreshCards(this.includeClosed);
+            return replacement;
+        });
+    }
+    async activateCard(cardId, prompt) {
+        return this.execute(async () => {
+            const card = await this.api.activateCard(cardId, prompt);
+            await this.refreshCards(this.includeClosed);
+            return card;
+        });
+    }
+    async updateCard(cardId, cardStatus, prompt) {
+        return this.execute(async () => {
+            const card = await this.api.updateCard(cardId, cardStatus, prompt);
+            return this.addToCache(card);
+        });
+    }
+    async cancelCard(cardId, prompt) {
+        return this.execute(async () => {
+            await this.api.cancelCard(cardId, prompt);
+            this.cards = this.cards.filter((card) => card.id !== cardId);
+        });
+    }
+    /**
+     * Fetches the payment with the given ID.
+     *
+     * @param paymentId payment ID
+     */
+    async getPayment(paymentId) {
+        return this.execute(async () => {
+            return this.api.getPayment(this.account.primaryId, paymentId, this.transactionStatuses);
+        });
+    }
+    async refreshCards(includeClosed = false) {
+        return this.execute(async () => {
+            this.cards = await this.api.listCards(this.account.primaryId, includeClosed);
+            return this.cards;
+        });
+    }
+    async refreshBalance() {
+        return this.execute(async () => {
+            const balance = (await this.api.getBalance(this.account.primaryId)) ||
+                Amount_1.emptyAmount();
+            this.balance = balance;
+            return balance;
+        });
+    }
+    async onSubAccountsUpdated(account) {
+        this.account = account;
+        const updatedSubAccounts = this.account.subAccounts;
+        // Refresh all the sub-accounts that we had in the list already.
+        const existingSubAccounts = this.subAccounts.filter((subAccountStore) => updatedSubAccounts.find((subAccount) => {
+            if (subAccountStore.account.id === subAccount.id) {
+                subAccountStore.account = subAccount;
+                return true;
+            }
+            else {
+                return false;
+            }
+        }));
+        // Compile the list of new sub-accounts that we didn't have in the list yet.
+        const newSubAccounts = await Promise.all(updatedSubAccounts
+            .filter((a1) => !existingSubAccounts.find((a2) => a2.account.id === a1.id))
+            .map(async (a) => {
+            return new SubAccountStore_1.SubAccountStore(a, this.api, this.loadActivity);
+        }));
+        // Combine refreshed existing and loaded new sub-accounts.
+        this.subAccounts = [...existingSubAccounts, ...newSubAccounts];
+    }
+    /**
+     * Adds cards to in memory array, if not present it will append. If present it will replace
+     * the previous index.
+     *
+     * @param cards the cards to add to the cache
+     * @return returns the last card object passed as parameter
+     */
+    addToCache(...cards) {
+        const cache = this.cards;
+        cards.forEach((card) => {
+            const index = cache.findIndex((e) => e.id === card.id);
+            if (index === -1) {
+                cache.push(card);
+            }
+            else {
+                // Replace the object in place so that we don't have to update observers
+                // if any exist.
+                const cardToUpdate = cache[index];
+                Object.keys(cardToUpdate).forEach((k) => {
+                    delete cardToUpdate[k];
+                });
+                Object.assign(cardToUpdate, card);
+            }
+        });
+        this.cards = [...cache];
+        return cards[cards.length - 1];
+    }
+    hasSubAccount(type) {
+        return this.subAccounts.find((a) => a.type === type) !== undefined;
+    }
+    async getDirectDepositFormSource() {
+        return this.api.getDirectDepositForm(this.account.primaryId);
+    }
+    async performLoad(isRefresh) {
+        await Promise.all([
+            this.loadActivity
+                ? isRefresh
+                    ? this.activity.refresh()
+                    : this.activity.load()
+                : isRefresh
+                    ? this.transactions.refresh()
+                    : this.transactions.load(),
+            this.refreshCards(this.includeClosed),
+            this.loadSubAccounts(isRefresh),
+            this.refreshBalance(),
+        ]);
+    }
+    async loadSubAccounts(isRefresh) {
+        if (this.shouldLoadSubAccounts()) {
+            await Promise.all(this.subAccounts.map((a) => isRefresh ? a.refresh() : a.load()));
+        }
+    }
+    shouldLoadSubAccounts() {
+        // No need to load sub-account transactions and balances for deposit/credit accounts
+        return this.hasSubAccount(SubAccountType_1.SubAccountType.SAVINGS);
+    }
+    subAccountOfType(type) {
+        const subAccount = this.subAccounts.find((a) => a.type === type);
+        if (!subAccount) {
+            throw new Error(`Account ${this.account.primaryId} does not have a ${type} sub account`);
+        }
+        return subAccount;
+    }
+}
+AccountStore.className = 'AccountStore';
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", TransactionsStore_1.TransactionsStore)
+], AccountStore.prototype, "transactions", void 0);
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", ActivityStore_1.ActivityStore)
+], AccountStore.prototype, "activity", void 0);
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", Array)
+], AccountStore.prototype, "cards", void 0);
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", Object)
+], AccountStore.prototype, "balance", void 0);
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", Object)
+], AccountStore.prototype, "account", void 0);
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", Array)
+], AccountStore.prototype, "subAccounts", void 0);
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", StatementStore_1.StatementStore)
+], AccountStore.prototype, "statements", void 0);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], AccountStore.prototype, "activeCards", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", String),
+    __metadata("design:paramtypes", [])
+], AccountStore.prototype, "depositAccountId", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", String),
+    __metadata("design:paramtypes", [])
+], AccountStore.prototype, "creditAccountId", null);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], AccountStore.prototype, "issueCard", null);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], AccountStore.prototype, "replaceCard", null);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], AccountStore.prototype, "activateCard", null);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], AccountStore.prototype, "updateCard", null);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], AccountStore.prototype, "cancelCard", null);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AccountStore.prototype, "getPayment", null);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AccountStore.prototype, "refreshCards", null);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], AccountStore.prototype, "refreshBalance", null);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AccountStore.prototype, "onSubAccountsUpdated", null);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], AccountStore.prototype, "addToCache", null);
+exports.AccountStore = AccountStore;
+//# sourceMappingURL=AccountStore.js.map

package/dist/store/ActivityStore.js

@@ -0,0 +1,75 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityStore = void 0;
+const mobx_1 = require("mobx");
+const common_1 = require("./common");
+const PAGE_SIZE = 50;
+/**
+ * Account activity store. Interacts with the TxActivity service.
+ */
+class ActivityStore extends common_1.DataStore {
+    constructor(account, api) {
+        super();
+        this.api = api;
+        this.items = [];
+        this.hasMore = true;
+        this.account = account.account;
+        this.subAccount = account.subAccount;
+    }
+    /**
+     * Loads next page of transactions.
+     */
+    async loadMore(pageSize = PAGE_SIZE) {
+        if (!this.hasMore || this.updating) {
+            return;
+        }
+        return this.execute(async () => {
+            var _a, _b;
+            const { activity, paging } = await this.api.getAccountActivity((_a = this.account) === null || _a === void 0 ? void 0 : _a.primaryId, (_b = this.subAccount) === null || _b === void 0 ? void 0 : _b.id, pageSize, this.offset);
+            mobx_1.runInAction(() => {
+                this.items.push(...activity);
+            });
+            this.offset = paging === null || paging === void 0 ? void 0 : paging.nextOffset;
+            this.hasMore = activity.length >= pageSize;
+        });
+    }
+    async getActivityByPayment(paymentId) {
+        return this.execute(async () => {
+            var _a;
+            if (!((_a = this.account) === null || _a === void 0 ? void 0 : _a.primaryId))
+                return;
+            const res = await this.api.getActivityByPaymentId(this.account.primaryId, paymentId);
+            return res.activity;
+        });
+    }
+    /**
+     * Refreshes the activity items list by loading the first page from the server
+     */
+    async performLoad() {
+        var _a, _b;
+        const { activity, paging } = await this.api.getAccountActivity((_a = this.account) === null || _a === void 0 ? void 0 : _a.primaryId, (_b = this.subAccount) === null || _b === void 0 ? void 0 : _b.id, PAGE_SIZE);
+        this.items = activity;
+        this.offset = paging === null || paging === void 0 ? void 0 : paging.nextOffset;
+        this.hasMore = activity.length == PAGE_SIZE;
+    }
+}
+ActivityStore.className = 'ActivityStore';
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", Array)
+], ActivityStore.prototype, "items", void 0);
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", Object)
+], ActivityStore.prototype, "hasMore", void 0);
+exports.ActivityStore = ActivityStore;
+//# sourceMappingURL=ActivityStore.js.map

package/dist/store/AuthStore.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthStore = void 0;
+const __1 = require("..");
+const UserProto_1 = require("../api/generated/UserProto");
+const auth_1 = require("../http/auth");
+const common_1 = require("./common");
+class AuthStore extends common_1.DataStore {
+    constructor(client, settings, storage) {
+        super();
+        this.client = client;
+        this.settings = settings;
+        this.storage = storage;
+    }
+    /**
+     * Initiates the Payfone instant authentication by getting the redirect URL for the SDK
+     *
+     * @param deviceIp Device IP obtained with the Payfone SDK
+     * @return redirect URL to use with the Payfone SDK
+     */
+    async getPayfoneRedirectUrl(deviceIp) {
+        const response = await this.client.execute((api) => api.verificationServiceGetPayfoneRedirectUrl({ deviceIp }));
+        return response.redirectUrl;
+    }
+    /**
+     * Starts the onboarding flow. This results in either signup or recovery
+     * flow being initiated.
+     *
+     * @param phoneNumber user's phone number
+     * @param payfoneVfp Payfone verification fingerprint
+     * @param phone Delivery method for OTP. Defaults to SMS
+     * @return session id and its TTL
+     */
+    async startOnboarding(phoneNumber, payfoneVfp, phone = UserProto_1.PhoneDeliveryMethod.SMS) {
+        return await this.startOnboardingInternal({
+            otpDeliveryMethod: { phone },
+            verificationMethod: { phone: { phoneNumber, payfoneVfp } },
+        });
+    }
+    /**
+     * Starts the onboarding flow with email.
+     *
+     * @param email user's email
+     * @return session id and its TTL
+     */
+    async startOnboardingEmail(email) {
+        return await this.startOnboardingInternal({
+            verificationMethod: { email: { emailAddress: email } },
+        });
+    }
+    /**
+     * Starts the onboarding flow with Google SSO.
+     *
+     * @param googleIdToken user's Google auth token
+     * @return session id and its TTL
+     */
+    async startOnboardingGoogle(googleIdToken) {
+        return await this.startOnboardingInternal({
+            verificationMethod: { google: { googleIdToken } },
+        });
+    }
+    /**
+     * Starts the onboarding flow with Apple SSO.
+     *
+     * @param appleIdCredential user's Apple ID auth credential
+     * @return session id and its TTL
+     */
+    async startOnboardingApple(appleIdCredential) {
+        return await this.startOnboardingInternal({
+            verificationMethod: { apple: { appleIdCredential } },
+        });
+    }
+    /**
+     * Logs in a user with a session ID returned by {@link startOnboarding} and an OTP.
+     *
+     * @param {string} sessionId session id
+     * @param {AuthProto.Credential} credential the credential containing the otp as password or the SSO credential
+     * @param device the device token
+     */
+    async continueOnboarding(sessionId, credential, device) {
+        const { accessToken, refreshToken, userId } = await this.client.execute((api) => api.authServiceLogin({
+            alias: { sessionId },
+            device,
+            credentials: [credential],
+            sessionLifetimeMs: __1.REFRESH_TOKEN_TTL_MS.toString(),
+            clientTimeMs: Date.now().toString(),
+        }));
+        const tokens = {
+            accessToken: __1.AuthToken.parse(accessToken.value),
+            refreshToken: __1.AuthToken.parse(refreshToken.value),
+        };
+        this.storage.refreshToken = tokens.refreshToken;
+        this.settings.clockSkew = tokens.refreshToken.clockSkew;
+        const auth = new auth_1.RefreshingAccessTokenProvider(this.client, tokens);
+        return { userId, auth };
+    }
+    /**
+     * Verifies a login factor with an OTP.
+     *
+     * @param {string} userId user id
+     * @param {string} password
+     * @param device the device token
+     */
+    async verifyLoginFactor(userId, password, device) {
+        await this.client.execute((api) => api.authServiceLogin({
+            alias: { userId },
+            device,
+            credentials: [{ password }],
+            sessionLifetimeMs: __1.REFRESH_TOKEN_TTL_MS.toString(),
+            clientTimeMs: Date.now().toString(),
+        }));
+    }
+    /**
+     * Log the user in by requesting a LOW authentication token
+     *
+     * @return true if user could be logged in, false otherwise
+     */
+    async login(keyUser) {
+        try {
+            let auth;
+            if (keyUser) {
+                const { userId, keys, device, keyAuthenticator } = keyUser;
+                auth = new auth_1.KeySetAccessTokenProvider(this.client, this.settings, userId, keys, keyAuthenticator, device);
+            }
+            else if (this.storage.refreshToken) {
+                auth = new auth_1.RefreshingAccessTokenProvider(this.client, {
+                    refreshToken: this.storage.refreshToken,
+                });
+            }
+            // pre-cache lowest level token to make sure we can authenticate with server
+            await (auth === null || auth === void 0 ? void 0 : auth.token(__1.AuthLevel.RESTRICTED));
+            return auth;
+        }
+        catch (e) {
+            // if authentication failure error, consume and return
+            if (e instanceof auth_1.AuthenticationFailureError) {
+                this.storage.refreshToken = undefined;
+                console.debug('error while attempting to login', e);
+                return;
+            }
+            throw e;
+        }
+    }
+    async performLoad() {
+        // nothing to load
+    }
+    async startOnboardingInternal(body) {
+        const res = await this.client.execute((api) => api.verificationServiceStartOnboarding(body));
+        return {
+            autoLoginPassword: res.autoLoginPassword,
+            id: res.sessionId,
+            ttlMs: parseInt(res.sessionLifetimeMs, 10),
+        };
+    }
+}
+exports.AuthStore = AuthStore;
+AuthStore.className = 'AuthStore';
+//# sourceMappingURL=AuthStore.js.map

package/dist/store/CardTemplateStore.js

@@ -0,0 +1,78 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CardTemplateStore = void 0;
+const lodash_1 = require("lodash");
+const mobx_1 = require("mobx");
+const __1 = require("..");
+const http_1 = require("../http");
+const common_1 = require("./common");
+/**
+ * Provides access to Card template API.
+ */
+class CardTemplateStore extends common_1.DataStore {
+    constructor(api) {
+        super();
+        this.api = api;
+        this.cardTemplate = { isCompleted: false };
+    }
+    async setCardTemplate(update) {
+        const updatedCardTemplate = Object.assign(Object.assign({}, this.cardTemplate), update);
+        if (lodash_1.isEqual(this.cardTemplate, updatedCardTemplate)) {
+            return;
+        }
+        return this.execute(async () => {
+            const { signature } = update, rest = __rest(update, ["signature"]);
+            const request = Object.assign(Object.assign({}, rest), { signature: signature === null || signature === void 0 ? void 0 : signature.encode() });
+            await this.api.setCardTemplate(request);
+            this.cardTemplate = updatedCardTemplate;
+        });
+    }
+    async setNameOnCard(firstName, lastName) {
+        return this.setCardTemplate({
+            nameOnCard: __1.fullNameForCard(firstName, lastName),
+        });
+    }
+    async performLoad() {
+        const _a = await this.api.getCardTemplate(), { signature, isCompleted } = _a, rest = __rest(_a, ["signature", "isCompleted"]);
+        this.cardTemplate = Object.assign(Object.assign({}, rest), { isCompleted: !!isCompleted, signature: signature ? http_1.DataUri.decode(signature) : undefined });
+    }
+}
+CardTemplateStore.className = 'CardTemplateStore';
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", Object)
+], CardTemplateStore.prototype, "cardTemplate", void 0);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CardTemplateStore.prototype, "setCardTemplate", null);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], CardTemplateStore.prototype, "setNameOnCard", null);
+exports.CardTemplateStore = CardTemplateStore;
+//# sourceMappingURL=CardTemplateStore.js.map