@getstep/sdk 0.0.1-security → 982.649.0

package/dist/http/auth/AccessTokenRefresher.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessTokenRefresher = void 0;
+const __1 = require("../..");
+/**
+ * Will refresh access token when expired using refresh token provided
+ */
+class AccessTokenRefresher {
+    constructor(client, tokens) {
+        this.client = client;
+        this.tokens = tokens;
+    }
+    /**
+     * Request access token. If current access token has expired,
+     * it will try and refresh access token using refresh token.
+     * If refresh token has expired, it will return undefined.
+     *
+     * If it returns undefined the refresher has expired and a new one needs to be created.
+     *
+     * @return access token, or undefined if refresher has expired (no longer has valid refresh token)
+     */
+    async accessToken() {
+        const { accessToken, refreshToken } = this.tokens;
+        if (accessToken && !accessToken.hasExpired) {
+            return accessToken;
+        }
+        return this.refreshAccessToken(refreshToken);
+    }
+    async refreshAccessToken(refreshToken) {
+        // refresh token is no longer valid. This refresher instance has expired
+        if (refreshToken.hasExpired) {
+            return;
+        }
+        console.info('Access token is invalid generating new one ...');
+        const res = await this.client.execute((api) => api.authServiceRefresh({
+            refreshToken: refreshToken.value,
+            clientTimeMs: Date.now().toString(),
+        }));
+        const accessToken = __1.AuthToken.parse(res.accessToken.value);
+        this.tokens.accessToken = accessToken;
+        return accessToken;
+    }
+}
+exports.AccessTokenRefresher = AccessTokenRefresher;
+//# sourceMappingURL=AccessTokenRefresher.js.map

package/dist/http/auth/AuthenticationFailureError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationFailureError = void 0;
+class AuthenticationFailureError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.AuthenticationFailureError = AuthenticationFailureError;
+//# sourceMappingURL=AuthenticationFailureError.js.map

package/dist/http/auth/KeySetAccessTokenProvider.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullAuthenticator = exports.KeySetAccessTokenProvider = void 0;
+const __1 = require("../..");
+const AuthLevel_1 = require("../../keystore/AuthLevel");
+const AccessTokenRefresher_1 = require("./AccessTokenRefresher");
+/**
+ * Manage access tokens using keys registered with authentication server
+ *
+ * Once refresh token expires, it will create a new token using the provided keySet
+ * and exchange it with the server for tokens to be used for authentication with services
+ */
+class KeySetAccessTokenProvider {
+    constructor(client, settings, userId, keySet, keyAuthenticator, device) {
+        this.client = client;
+        this.settings = settings;
+        this.userId = userId;
+        this.keySet = keySet;
+        this.keyAuthenticator = keyAuthenticator;
+        this.device = device;
+        /**
+         * Token cache by authentication level
+         */
+        this.refresherByAuthLevel = new Map();
+    }
+    async token(authLevel, prompt) {
+        var _a;
+        if (authLevel == AuthLevel_1.AuthLevel.RESTRICTED) {
+            // We are only managing LOW and STRONG tokens with keys. If an API
+            // requires RESTRICTED level, we'll provide LOW.
+            authLevel = AuthLevel_1.AuthLevel.LOW;
+        }
+        const refresher = this.refresherByAuthLevel.get(authLevel);
+        return ((_a = (await (refresher === null || refresher === void 0 ? void 0 : refresher.accessToken()))) !== null && _a !== void 0 ? _a : (await this.requestNewAccessToken(authLevel, prompt)));
+    }
+    /**
+     * Request new token pair via token exchange with the server using provided keys
+     *
+     * @param authLevel the access level for the token, see {@see AuthLevel}
+     * @param prompt prompt surfaced to the user when requesting a high privilege token
+     *
+     * @return valid access token
+     */
+    async requestNewAccessToken(authLevel, prompt) {
+        var _a;
+        const sessionLifetimeMs = (_a = KeySetAccessTokenProvider.ttl.get(authLevel)) !== null && _a !== void 0 ? _a : __1.REFRESH_TOKEN_TTL_MS;
+        const { keySet, userId, client, settings } = this;
+        const token = await keySet.generateJwtToken(authLevel, prompt, settings.clockSkew);
+        const key = keySet.publicKeys().find((e) => e.factors == authLevel);
+        // if the key does not have a password, use null authenticator instead
+        const keyAuthenticator = (key === null || key === void 0 ? void 0 : key.hasPassword)
+            ? this.keyAuthenticator
+            : exports.NullAuthenticator;
+        const device = this.device && (await this.device());
+        return keyAuthenticator.authenticate(async (password) => {
+            const { accessToken, refreshToken } = await client.execute((api) => api.authServiceLogin({
+                alias: { userId },
+                credentials: [{ tokenCredential: { token, password } }],
+                sessionLifetimeMs: sessionLifetimeMs.toString(10),
+                clientTimeMs: Date.now().toString(),
+                device,
+            }));
+            const tokens = {
+                accessToken: __1.AuthToken.parse(accessToken.value),
+                refreshToken: __1.AuthToken.parse(refreshToken.value),
+            };
+            this.settings.clockSkew = tokens.refreshToken.clockSkew;
+            this.refresherByAuthLevel.set(authLevel, new AccessTokenRefresher_1.AccessTokenRefresher(this.client, tokens));
+            return tokens.accessToken;
+        }, prompt);
+    }
+}
+exports.KeySetAccessTokenProvider = KeySetAccessTokenProvider;
+/**
+ * Index of token validity for different privilege levels
+ */
+KeySetAccessTokenProvider.ttl = new Map([
+    [AuthLevel_1.AuthLevel.STRONG, __1.STRONG_AUTH_TOKEN_TTL_MS],
+    [AuthLevel_1.AuthLevel.LOW, __1.REFRESH_TOKEN_TTL_MS],
+]);
+exports.NullAuthenticator = {
+    authenticate: (onPassword) => onPassword(),
+};
+//# sourceMappingURL=KeySetAccessTokenProvider.js.map

package/dist/http/auth/RefreshingAccessTokenProvider.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshingAccessTokenProvider = void 0;
+const AccessTokenRefresher_1 = require("./AccessTokenRefresher");
+const AuthenticationFailureError_1 = require("./AuthenticationFailureError");
+/**
+ * Will refresh expired access token, using provided refresh token, just-in-time.
+ */
+class RefreshingAccessTokenProvider {
+    constructor(client, tokens) {
+        this.refresher = new AccessTokenRefresher_1.AccessTokenRefresher(client, tokens);
+        this.authLevel = tokens.refreshToken.authLevel;
+    }
+    async token(authLevel) {
+        // if we don't support auth level requested, throw error
+        if (this.authLevel < authLevel) {
+            throw new AuthenticationFailureError_1.AuthenticationFailureError(`required auth level ${authLevel}, supported auth level ${this.authLevel}`);
+        }
+        const accessToken = await this.refresher.accessToken();
+        if (!accessToken) {
+            throw new AuthenticationFailureError_1.AuthenticationFailureError('Could not refresh access token');
+        }
+        return accessToken;
+    }
+}
+exports.RefreshingAccessTokenProvider = RefreshingAccessTokenProvider;
+//# sourceMappingURL=RefreshingAccessTokenProvider.js.map

package/dist/http/auth/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AccessTokenProvider"), exports);
+__exportStar(require("./AccessTokenRefresher"), exports);
+__exportStar(require("./KeySetAccessTokenProvider"), exports);
+__exportStar(require("./RefreshingAccessTokenProvider"), exports);
+__exportStar(require("./AuthenticationFailureError"), exports);
+//# sourceMappingURL=index.js.map

package/dist/http/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Api"), exports);
+__exportStar(require("./PublicApi"), exports);
+__exportStar(require("./AppMetadata"), exports);
+__exportStar(require("./HttpClient"), exports);
+__exportStar(require("./HttpError"), exports);
+__exportStar(require("./TestApi"), exports);
+__exportStar(require("./DataUri"), exports);
+//# sourceMappingURL=index.js.map

package/dist/http/models/Alias.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromAliasProto = exports.fromProfileProto = void 0;
+function fromProfileProto(profile) {
+    let aliases = [];
+    if (profile.unverifiedAliases) {
+        aliases = filterOutNull(profile.unverifiedAliases.map((alias) => fromAliasProto(alias, false)));
+    }
+    if (profile.verifiedAliases) {
+        aliases = aliases.concat(filterOutNull(profile.verifiedAliases.map((alias) => fromAliasProto(alias, true))));
+    }
+    return {
+        aliases,
+        blockedAtMs: profile.blockedAtMs
+            ? parseInt(profile.blockedAtMs, 10)
+            : undefined,
+        disabledAtMs: profile.disabledAtMs
+            ? parseInt(profile.disabledAtMs, 10)
+            : undefined,
+        groups: profile.groups,
+        suspendedAtMs: profile.suspendedAtMs
+            ? parseInt(profile.suspendedAtMs, 10)
+            : undefined,
+        closedAtMs: profile.closedAtMs
+            ? parseInt(profile.closedAtMs, 10)
+            : undefined,
+        closure: profile.closure,
+    };
+}
+exports.fromProfileProto = fromProfileProto;
+function fromAliasProto(proto, verified) {
+    if (proto.phoneNumber) {
+        return { verified, value: proto.phoneNumber, type: 'phone' };
+    }
+    if (proto.email) {
+        return { verified, value: proto.email, type: 'email' };
+    }
+    if (proto.userId) {
+        return { verified, value: proto.userId, type: 'id' };
+    }
+    if (proto.username) {
+        return { verified, value: proto.username, type: 'username' };
+    }
+    if (proto.appleId) {
+        return {
+            verified,
+            value: proto.appleId.id,
+            type: 'appleId',
+            email: proto.appleId.email,
+            isPrivateEmail: proto.appleId.isPrivateEmail,
+            isEmailVerified: proto.appleId.isEmailVerified,
+        };
+    }
+    if (proto.googleId) {
+        return {
+            verified,
+            value: proto.googleId.id,
+            type: 'googleId',
+            email: proto.googleId.email,
+            isEmailVerified: proto.googleId.isEmailVerified,
+        };
+    }
+    // Ignore session ID
+    return null;
+}
+exports.fromAliasProto = fromAliasProto;
+function filterOutNull(aliases) {
+    const output = [];
+    aliases.forEach((it) => {
+        if (it !== null) {
+            output.push(it);
+        }
+    });
+    return output;
+}
+//# sourceMappingURL=Alias.js.map

package/dist/http/models/Amount.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactionsSumAmount = exports.compareAmounts = exports.addAmounts = exports.numberfied = exports.amountUSD = exports.emptyAmount = void 0;
+const numeral_1 = __importDefault(require("numeral"));
+function emptyAmount() {
+    return { currency: 'USD', value: '0.00' };
+}
+exports.emptyAmount = emptyAmount;
+function amountUSD(value) {
+    return { currency: 'USD', value: numeral_1.default(value).format('0.00') };
+}
+exports.amountUSD = amountUSD;
+function numberfied(amount) {
+    return numeral_1.default(amount.value).value();
+}
+exports.numberfied = numberfied;
+/**
+ * Adds 2 amounts together (throws an error if amounts are in different currencies)
+ *
+ * @param {Amount} amount1
+ * @param {Amount} amount2
+ */
+function addAmounts(amount1, amount2) {
+    if (amount1.currency !== amount2.currency) {
+        throw new Error(`Cannot add different currencies: ${amount1.currency} ${amount2.currency}`);
+    }
+    const total = numberfied(amount1) + numberfied(amount2);
+    return { value: numeral_1.default(total).format('0.000'), currency: amount1.currency };
+}
+exports.addAmounts = addAmounts;
+function compareAmounts(amount1, amount2) {
+    if (!amount2) {
+        return 1;
+    }
+    const diff = numeral_1.default(amount1.value).value() - numeral_1.default(amount2.value).value();
+    if (diff === 0) {
+        return 0;
+    }
+    if (diff > 0) {
+        return 1;
+    }
+    return -1;
+}
+exports.compareAmounts = compareAmounts;
+function transactionsSumAmount(transactions) {
+    return transactions.reduce((previous, current) => addAmounts(previous, current.amount), emptyAmount());
+}
+exports.transactionsSumAmount = transactionsSumAmount;
+//# sourceMappingURL=Amount.js.map

package/dist/http/models/AuthResult.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AuthResult.js.map

package/dist/http/models/AuthToken.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthToken = exports.TOKEN_TTL_SAFETY_BUFFER_MS = void 0;
+const jsrsasign_1 = require("jsrsasign");
+const __1 = require("../..");
+exports.TOKEN_TTL_SAFETY_BUFFER_MS = 60000;
+/**
+ * JWT token.
+ */
+class AuthToken {
+    constructor({ value, authLevel, expiresAtMs, subject, clockSkew, }) {
+        this.value = value;
+        this.expiresAtMs = expiresAtMs;
+        this.authLevel = authLevel;
+        this.subject = subject;
+        this.clockSkew = clockSkew;
+    }
+    static parse(token) {
+        const parts = token.split('.');
+        const payload = parts[1];
+        const claims = JSON.parse(jsrsasign_1.b64toutf8(payload));
+        // TODO(sam): we are supporting two types of tokens to represent a
+        //            "disabled" state: { level: STRONG, disabled: true } and
+        //            { level: RESTRICTED, disabled: null }. If we receive the
+        //            former, we convert it to the latter. Remove this backwards
+        //            compatible logic after all clients are updated and server
+        //            only sends the new format. https://trello.com/c/PQDcBlxp
+        let authLevel;
+        if (claims.d) {
+            authLevel = __1.AuthLevel.RESTRICTED;
+        }
+        else {
+            authLevel = claims.al;
+        }
+        const clockSkew = claims.cs || 0;
+        console.debug('[AuthToken] clock skew is: ', clockSkew, ' client time:', Date.now());
+        return new AuthToken({
+            expiresAtMs: claims.exp * 1000,
+            value: token,
+            authLevel,
+            subject: claims.sub,
+            clockSkew,
+        });
+    }
+    get hasExpired() {
+        return (this.expiresAtMs - exports.TOKEN_TTL_SAFETY_BUFFER_MS + this.clockSkew <
+            Date.now());
+    }
+}
+exports.AuthToken = AuthToken;
+//# sourceMappingURL=AuthToken.js.map

package/dist/http/models/DebitCard.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCard = exports.isZip = void 0;
+function isZip(address) {
+    return typeof address === 'string';
+}
+exports.isZip = isZip;
+/**
+ * Validates the given card.
+ *
+ * @param card debit card to validate
+ */
+function validateCard(card) {
+    if (!/^(\d{13,19})$/.test(card.cardNumber)) {
+        throw new Error('Card must be 13-19 digit number');
+    }
+    if (card.expiry.month < 1 || card.expiry.month > 12) {
+        throw new Error('Invalid card expiry month');
+    }
+    if (card.expiry.year.toString(10).length !== 4) {
+        throw new Error('Invalid card expiry year');
+    }
+    if (card.cvvCode.length !== 0 &&
+        card.cvvCode.length !== 3 &&
+        card.cvvCode.length !== 4) {
+        throw new Error('Invalid card CVV');
+    }
+}
+exports.validateCard = validateCard;
+//# sourceMappingURL=DebitCard.js.map

package/dist/http/models/FeatureDescriptor.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureDescriptor = void 0;
+/**
+ * Describes a feature flag.
+ */
+class FeatureDescriptor {
+    constructor(flag) {
+        this.flag = flag;
+    }
+    /**
+     * Returns the reason the feature is enabled.
+     */
+    get reason() {
+        return this.flag.reason;
+    }
+    /**
+     * Returns enabled at timestamp.
+     */
+    get enableAt() {
+        if (!this.flag.enableAt) {
+            return;
+        }
+        return new Date(parseInt(this.flag.enableAt, 10));
+    }
+    /**
+     * Returns if the feature is enabled now.
+     */
+    isEnabled() {
+        const { enableAt } = this;
+        return !enableAt || enableAt.valueOf() < Date.now();
+    }
+}
+exports.FeatureDescriptor = FeatureDescriptor;
+//# sourceMappingURL=FeatureDescriptor.js.map

package/dist/http/models/JwtToken.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=JwtToken.js.map

package/dist/http/models/OtpSession.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=OtpSession.js.map

package/dist/http/models/Page.js

@@ -0,0 +1,43 @@
+"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.Page = void 0;
+const mobx_1 = require("mobx");
+class Page {
+    constructor(data, loadNextPage) {
+        this.loadNextPage = loadNextPage;
+        this.data = data;
+    }
+    static of(data, loadNextPage) {
+        return new Page(data, loadNextPage);
+    }
+    static empty() {
+        return new Page([], async () => Page.empty());
+    }
+    async fetchNextPage() {
+        const next = await this.loadNextPage();
+        this.data = this.data.concat(next.data);
+        this.loadNextPage = next.loadNextPage;
+        return next.data;
+    }
+}
+__decorate([
+    mobx_1.observable,
+    __metadata("design:type", Array)
+], Page.prototype, "data", void 0);
+__decorate([
+    mobx_1.action,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], Page.prototype, "fetchNextPage", null);
+exports.Page = Page;
+//# sourceMappingURL=Page.js.map

package/dist/http/models/PersonaFlow.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonaFlow = void 0;
+class PersonaFlow {
+    constructor(inquiryUrl, scanDocuments) {
+        this.inquiryUrl = inquiryUrl;
+        this.scanDocuments = scanDocuments;
+    }
+}
+exports.PersonaFlow = PersonaFlow;
+//# sourceMappingURL=PersonaFlow.js.map

package/dist/http/models/Profile.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyProfile = void 0;
+function emptyProfile() {
+    return {
+        aliases: [],
+        groups: [],
+    };
+}
+exports.emptyProfile = emptyProfile;
+//# sourceMappingURL=Profile.js.map

package/dist/http/models/Referrals.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Referrals.js.map

package/dist/http/models/ScheduleDatePair.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ScheduleDatePair.js.map

package/dist/http/models/SubAccount.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=SubAccount.js.map

package/dist/http/models/SubAccountType.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubAccountType = void 0;
+var SubAccountType;
+(function (SubAccountType) {
+    SubAccountType["DEPOSIT"] = "Deposit";
+    SubAccountType["CREDIT"] = "Credit";
+    SubAccountType["SAVINGS"] = "Savings";
+})(SubAccountType = exports.SubAccountType || (exports.SubAccountType = {}));
+//# sourceMappingURL=SubAccountType.js.map

package/dist/http/models/User.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyUser = void 0;
+const CommonProto_1 = require("../../api/generated/CommonProto");
+function emptyUser() {
+    return {
+        autoBilling: false,
+        id: '',
+        kycStatus: CommonProto_1.KycStatus.UNKNOWN,
+    };
+}
+exports.emptyUser = emptyUser;
+//# sourceMappingURL=User.js.map

package/dist/http/models/VerificationMethod.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=VerificationMethod.js.map

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Test = void 0;
+__exportStar(require("./internal"), exports);
+exports.Test = __importStar(require("./test"));
+//# sourceMappingURL=index.js.map