@getstep/sdk 0.0.1-security → 982.649.0

package/dist/http/Api.js

@@ -0,0 +1,828 @@
+"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 __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.Api = void 0;
+const __1 = require("..");
+const CommonProto = __importStar(require("../api/generated/CommonProto"));
+const NotificationProto_1 = require("../api/generated/NotificationProto");
+const Alias_1 = require("./models/Alias");
+const AuthToken_1 = require("./models/AuthToken");
+const PersonaFlow_1 = require("./models/PersonaFlow");
+const PublicApi_1 = require("./PublicApi");
+/**
+ * A wrapper around authenticated API calls. Refreshes the JWT tokens as needed before
+ * performing an API call.
+ */
+class Api extends PublicApi_1.PublicApi {
+    constructor(client, settings, storage, auth, keyAuthenticator = __1.NullAuthenticator, device) {
+        super(client);
+        this.settings = settings;
+        this.storage = storage;
+        this.auth = auth;
+        this.keyAuthenticator = keyAuthenticator;
+        this.device = device;
+    }
+    get tokenProvider() {
+        return this.auth;
+    }
+    async verifyStart(alias, otpDeliveryMethod) {
+        return await this.authenticated((api) => api.verificationServiceVerify({ alias, otpDeliveryMethod }));
+    }
+    /**
+     * Initiates alias verification for the given masked alias. Allows user to
+     * continue recovery process.
+     *
+     * @param alias masked alias
+     * @param otpDeliveryMethod optional param to configure OTP delivery methods
+     */
+    async reVerify(alias, otpDeliveryMethod) {
+        await this.restrictedAuthenticated((api) => api.verificationServiceReVerify({ alias, otpDeliveryMethod }));
+    }
+    async addPhone(phone, prompt) {
+        await this.stronglyAuthenticated((api) => api.authServiceUpdate({
+            operations: [{ addPhone: { phone } }],
+        }), prompt);
+    }
+    async removePhone(phone, prompt) {
+        await this.stronglyAuthenticated((api) => api.authServiceUpdate({
+            operations: [{ removePhone: { phone } }],
+        }), prompt);
+    }
+    async addEmail(email, prompt) {
+        await this.stronglyAuthenticated((api) => api.authServiceUpdate({
+            operations: [{ addEmail: { email } }],
+        }), prompt);
+    }
+    async setEmail(email, prompt) {
+        await this.stronglyAuthenticated((api) => api.authServiceUpdate({
+            operations: [{ setEmail: { email } }],
+        }), prompt);
+    }
+    async removeEmail(email, prompt) {
+        await this.stronglyAuthenticated((api) => api.authServiceUpdate({
+            operations: [{ removeEmail: { email } }],
+        }), prompt);
+    }
+    async setUsername(username, prompt) {
+        await this.stronglyAuthenticated((api) => api.authServiceUpdate({
+            operations: [{ setUsername: { username } }],
+        }), prompt);
+    }
+    async setAppleId(clientId, authCode, prompt) {
+        await this.stronglyAuthenticated((api) => api.authServiceUpdate({
+            operations: [{ setAppleId: { clientId, authCode } }],
+        }), prompt);
+    }
+    async removeAppleId(appleId, prompt) {
+        await this.stronglyAuthenticated((api) => api.authServiceUpdate({
+            operations: [{ removeAppleId: { appleId } }],
+        }), prompt);
+    }
+    async setGoogleId(idToken, prompt) {
+        await this.stronglyAuthenticated((api) => api.authServiceUpdate({
+            operations: [{ setGoogleId: { idToken } }],
+        }), prompt);
+    }
+    async removeGoogleId(googleId, prompt) {
+        await this.stronglyAuthenticated((api) => api.authServiceUpdate({
+            operations: [{ removeGoogleId: { googleId } }],
+        }), prompt);
+    }
+    async aliasExists(alias) {
+        const response = await this.authenticated((api) => api.authServiceAliasExists({ alias }));
+        return response.exists;
+    }
+    /**
+     * Resets user keys used for authentication. If the keys are not specified, then
+     * the keys are cleared.
+     *
+     * @param keys new set of keys
+     * @param options additional options for resetting keys, see {@link ResetKeysOptions}
+     */
+    async resetKeys(keys, options = {}) {
+        const { prompt, newPassword } = options;
+        const { userId } = await this.stronglyAuthenticated(async (api, userId) => {
+            const response = await api.authServiceUpdate({
+                operations: keys.publicKeys().map((key) => ({
+                    addKey: {
+                        factors: key.factors,
+                        jwkBase64: key.jwkBase64,
+                        keyId: key.id,
+                        password: key.factors > 1 ? newPassword : undefined,
+                    },
+                })),
+            });
+            return Object.assign(Object.assign({}, response), { data: { userId } });
+        }, prompt);
+        // clear stored refresh token
+        this.storage.refreshToken = undefined;
+        // switch to using keys for authentication
+        this.auth = new __1.KeySetAccessTokenProvider(this.client, this.settings, userId, keys, this.keyAuthenticator, this.device);
+    }
+    /**
+     * Verify User via MFA using specified factor
+     *
+     * @param factor verification factor {@see EnableAccountMethod}
+     */
+    async verifyUser(factor) {
+        const { accessToken, refreshToken, } = await this.restrictedAuthenticated((api) => api.userServiceVerify(Object.assign({ sessionLifetimeMs: __1.STRONG_AUTH_TOKEN_TTL_MS.toString(10), clientTimeMs: Date.now().toString() }, factor)));
+        const tokens = {
+            accessToken: AuthToken_1.AuthToken.parse(accessToken.value),
+            refreshToken: AuthToken_1.AuthToken.parse(refreshToken.value),
+        };
+        // store refresh token and clockSkew for future use
+        this.storage.refreshToken = tokens.refreshToken;
+        this.settings.clockSkew = tokens.refreshToken.clockSkew;
+        this.auth = new __1.RefreshingAccessTokenProvider(this.client, tokens);
+    }
+    async requestSponsorApproval() {
+        const { otpTtlMs } = await this.restrictedAuthenticated((api) => api.verificationServiceSendSponsorVerification());
+        return parseInt(otpTtlMs, 10);
+    }
+    async getAuthProfile() {
+        const response = await this.authenticated((api) => api.authServiceGetProfile());
+        return Alias_1.fromProfileProto(response.profile);
+    }
+    /* User Requests */
+    async getUser() {
+        const response = await this.authenticated((api) => api.userServiceGet());
+        return response.user;
+    }
+    async createUser() {
+        const response = await this.authenticated((api) => api.userServiceCreate());
+        return response.user;
+    }
+    async verificationMethod() {
+        const response = await this.restrictedAuthenticated((api) => api.userServiceGetVerificationMethod());
+        return response.method;
+    }
+    async getSession() {
+        const response = await this.restrictedAuthenticated((api) => api.authServiceGetSession());
+        return response.session;
+    }
+    async updateUser(update) {
+        const response = await this.authenticated((api) => api.userServiceUpdate(update));
+        return response.user;
+    }
+    async setProfilePicture(image) {
+        const response = await this.authenticated((api) => api.userServiceSetProfilePicture({ image }));
+        return response.pictureUrl;
+    }
+    async removeProfilePicture() {
+        await this.authenticated((api) => api.userServiceRemoveProfilePicture());
+    }
+    async getProfilePictures() {
+        const response = await this.authenticated((api) => api.userServiceGetProfilePictures());
+        return response.pictureUrls;
+    }
+    /**
+     * This will return our own public profile, if we have one.
+     * Make a setPublicProfileVisibility call, if you need one initialized.
+     */
+    async getOwnPublicProfile() {
+        const { profile } = await this.authenticated((api) => api.profileServiceGetProfile());
+        return profile;
+    }
+    /**
+     * This will allow/disallow requests for user's public profile.
+     * DANGER! Be sure to call this and pick the public data responsibly.
+     * This will initialize the profile the first time it is called,
+     * and will update its visibility on subsequent calls.
+     *
+     * @param status profile visibility
+     */
+    async setPublicProfileVisibility(status) {
+        await this.authenticated((api) => api.profileServiceSetProfile({ status }));
+    }
+    /* KYC Requests */
+    async onboard(performKyc, prompt) {
+        const device = this.device && (await this.device());
+        return this.stronglyAuthenticated((api) => api.userServiceOnboard({ device, performKyc }), prompt);
+    }
+    async offboard() {
+        const response = await this.authenticated((api) => api.userServiceOffboard());
+        return response.kycStatus;
+    }
+    async getPersonaFlow(supportedScanDocuments) {
+        const response = await this.authenticated((api) => api.identityServiceGetPersonaFlow({ supportedScanDocuments }));
+        return response.inquiryUrl
+            ? new PersonaFlow_1.PersonaFlow(response.inquiryUrl, undefined)
+            : response.scanDocuments
+                ? new PersonaFlow_1.PersonaFlow(undefined, response.scanDocuments.scanDocuments)
+                : undefined;
+    }
+    /**
+     * governmentId is the only option at the moment
+     *
+     * @param governmentId government id document details
+     * @param frontPhoto data:uri encoded front photo
+     * @param backPhoto optional data:uri encoded back photo
+     */
+    async uploadPersonaDocument(governmentId, frontPhoto, backPhoto) {
+        await this.authenticated((api) => api.identityServiceUploadPersonaDocument({
+            governmentId,
+            frontPhoto,
+            backPhoto,
+        }));
+    }
+    /* Family Requests */
+    async getFamily() {
+        const { members, invites } = await this.authenticated((api) => api.familyServiceGet());
+        return { members, invites };
+    }
+    async updateFamilyMember(userToEditId, isAdmin) {
+        const response = await this.stronglyAuthenticated((api) => api.familyServiceUpdateFamilyMember(userToEditId, {
+            group: isAdmin
+                ? CommonProto.FamilyGroup.ADMIN
+                : CommonProto.FamilyGroup.MEMBER,
+        }));
+        return response.member;
+    }
+    async deleteFamilyMember(userToDeleteId) {
+        await this.stronglyAuthenticated((api) => api.familyServiceRemoveFamilyMember(userToDeleteId));
+    }
+    async inviteFamilyMember(inviteeAlias, group = CommonProto.FamilyGroup.MEMBER) {
+        await this.authenticated((api) => api.familyServiceInviteMember({
+            group,
+            inviteeAlias,
+        }));
+    }
+    async unInviteFamilyMember(inviteeAlias) {
+        await this.authenticated((api) => api.familyServiceUnInviteMember({ inviteeAlias }));
+    }
+    async getFamilyInvites() {
+        const response = await this.authenticated((api) => api.familyServiceGetFamilyInvites());
+        return response.invites;
+    }
+    async acceptFamilyInvite(familyId, prompt) {
+        await this.stronglyAuthenticated((api) => api.familyServiceJoinFamily({
+            familyId,
+        }), prompt);
+    }
+    async rejectFamilyInvite(familyId) {
+        await this.authenticated((api) => api.familyServiceRejectFamilyInvite({
+            familyId,
+        }));
+    }
+    async getFamilyAddress() {
+        const response = await this.authenticated((api) => api.familyServiceGetFamilyAddress());
+        return response.address;
+    }
+    /* Account Requests */
+    async getAccounts(includeClosed) {
+        const response = await this.authenticated((api) => api.accountServiceGet(includeClosed));
+        return response.accounts;
+    }
+    async getDefaultAccount() {
+        const response = await this.authenticated((api) => api.accountServiceGetDefault());
+        return response.account;
+    }
+    async closeAccount(primaryAccountId) {
+        await this.stronglyAuthenticated((api) => api.accountServiceClose(primaryAccountId));
+    }
+    async createSavingsGoal(savings, currency = 'USD') {
+        const response = await this.authenticated((api) => api.savingsGoalServiceCreateSavingsGoal({ savings, currency }));
+        return response.account;
+    }
+    async updateSavingsGoal(subAccountId, savings) {
+        const response = await this.authenticated((api) => api.savingsGoalServiceUpdateSavingsGoal(subAccountId, { savings }));
+        return response.account;
+    }
+    async canCloseSavingsGoal(subAccountId) {
+        const response = await this.authenticated((api) => api.savingsGoalServiceCanCloseSavingsGoal(subAccountId));
+        return response.closability;
+    }
+    async closeSavingsGoal(subAccountId) {
+        const response = await this.authenticated((api) => api.savingsGoalServiceCloseSavingsGoal(subAccountId));
+        return response.account;
+    }
+    async getSuggestedSavingsGoals() {
+        return await this.authenticated((api) => api.savingsGoalServiceGetSuggestedSavingsGoals());
+    }
+    /* Transaction Requests */
+    async getTransactions(primaryAccountId, statuses, prevOffset, nextOffset, limit) {
+        if (prevOffset && nextOffset) {
+            throw Error('Either next or prev offsets must be defined');
+        }
+        const { transactions, updatedTransactions, paging, } = await this.authenticated((api) => api.transactionServiceGetTransactions(primaryAccountId, statuses, limit, nextOffset, prevOffset));
+        return {
+            transactions,
+            updatedTransactions,
+            nextOffset: paging === null || paging === void 0 ? void 0 : paging.nextOffset,
+            prevOffset: paging === null || paging === void 0 ? void 0 : paging.prevOffset,
+        };
+    }
+    async getPayment(primaryAccountId, paymentId, statuses) {
+        const response = await this.authenticated((api) => api.transactionServiceGetPayment(primaryAccountId, paymentId, statuses));
+        return response.payment;
+    }
+    async getBalance(primaryAccountId, subAccountId) {
+        const response = await this.authenticated((api) => api.transactionServiceGetBalance(primaryAccountId, subAccountId));
+        return response.available;
+    }
+    /* Card Requests */
+    async getCardTemplate() {
+        const response = await this.authenticated((api) => api.cardServiceGetCardTemplate());
+        return response.template || {};
+    }
+    async setCardTemplate(update) {
+        await this.authenticated((api) => api.cardServiceSetCardTemplate(update));
+    }
+    async issueCard(primaryAccountId, cardType, nameOnCard, prompt) {
+        const response = await this.stronglyAuthenticated((api) => api.cardServiceIssue({
+            primaryAccountId,
+            cardType,
+            nameOnCard,
+        }), prompt);
+        return response.card;
+    }
+    async replaceCard(cardId, reason, prompt) {
+        return this.stronglyAuthenticated((api) => api.cardServiceReplace(cardId, { reason }), prompt);
+    }
+    async activateCard(cardId, prompt) {
+        const response = await this.stronglyAuthenticated((api) => api.cardServiceActivate(cardId), prompt);
+        return response.card;
+    }
+    async updateCard(cardId, cardStatus, prompt) {
+        const response = await this.stronglyAuthenticated((api) => api.cardServiceUpdate(cardId, { cardStatus }), prompt);
+        return response.card;
+    }
+    async listCards(primaryAccountId, includeCanceled = false) {
+        const response = await this.authenticated((api) => api.cardServiceGet(primaryAccountId, includeCanceled));
+        return response.cards;
+    }
+    async cancelCard(cardId, prompt) {
+        await this.stronglyAuthenticated((api) => api.cardServiceUpdate(cardId, {
+            cardStatus: CommonProto.CardStatus.CANCELED,
+        }), prompt);
+    }
+    /* External Accounts */
+    async listExternalAccounts() {
+        const response = await this.authenticated((api) => api.externalAccountServiceGetExternalAccounts());
+        return response.accounts;
+    }
+    async addExternalCard(token, name, entryMethod) {
+        const response = await this.authenticated((api) => api.cardAcquiringServiceAddCard({ name, token, entryMethod }));
+        return response.account;
+    }
+    async getBankLinkingToken(provider) {
+        const response = await this.authenticated((api) => api.achServiceGetLinkingToken(provider));
+        return response.linkingToken;
+    }
+    async getBankRelinkingToken(externalAccountId) {
+        const response = await this.authenticated((api) => api.achServiceGetRelinkingToken(externalAccountId));
+        return response.linkingToken;
+    }
+    async addExternalBank(request, name) {
+        const response = await this.authenticated((api) => api.achServiceAddAccount({ name, request }));
+        return response.account;
+    }
+    async relinkExternalBank(externalAccountId) {
+        const response = await this.authenticated((api) => api.achServiceRelink(externalAccountId));
+        return response.account;
+    }
+    async getCardProviderKey(provider) {
+        return this.authenticated((api) => api.cardAcquiringServiceGetProviderKey(provider));
+    }
+    async updateExternalAccount(externalAccountId, name) {
+        const response = await this.authenticated((api) => api.externalAccountServiceUpdateExternalAccount(externalAccountId, {
+            name,
+        }));
+        return response.externalAccount;
+    }
+    async removeExternalAccount(externalAccountId) {
+        await this.authenticated((api) => api.externalAccountServiceRemoveExternalAccount(externalAccountId));
+    }
+    async refreshExternalAccountBalance(externalAccountId) {
+        const response = await this.authenticated((api) => api.achServiceRefreshBalance(externalAccountId));
+        return response.account;
+    }
+    /* Stripe Card Operations */
+    async initiateVerification(cardId) {
+        const response = await this.authenticated((api) => api.stripeCardServiceInitiateVerification(cardId));
+        return response.verification;
+    }
+    async createEphemeralKey(cardId, apiVersion, prompt) {
+        const { bankCardId, encodedKey } = await this.stronglyAuthenticated((api) => api.stripeCardServiceCreateEphemeralKey(cardId, { apiVersion }), prompt);
+        return { bankCardId, encodedKey };
+    }
+    /* ATM access management */
+    async updateCardAtm(cardId, enabled, prompt) {
+        const result = await this.stronglyAuthenticated((api) => api.cardServiceUpdateCardAtm(cardId, {
+            enabled,
+        }), prompt);
+        return result.card;
+    }
+    async updateCardPinStatus(cardId, pinStatus) {
+        const result = await this.stronglyAuthenticated((api) => api.cardServiceUpdateCardAtm(cardId, {
+            pinStatus,
+        }));
+        return result.card;
+    }
+    async updateCardPin(cardId, encryptedNumber, prompt) {
+        await this.stronglyAuthenticated((api) => api.stripeCardServiceUpdatePin(cardId, { encryptedNumber }), prompt);
+    }
+    /* Push Notifications */
+    async subscribeToPush(instanceId, token, type) {
+        await this.authenticated((api) => api.notificationServiceSubscribeToPush({
+            instanceId,
+            token,
+            type: NotificationProto_1.SubscribeToPushRequestType[type],
+        }));
+    }
+    async unsubscribeToPush(instanceId) {
+        await this.authenticated((api) => api.notificationServiceUnsubscribeToPush({ instanceId }));
+    }
+    async sendTestNotification(delayMs) {
+        await this.authenticated((api) => api.notificationServiceSendTestNotification(delayMs ? { delayMs: delayMs.toString() } : {}));
+    }
+    /* Referral Requests */
+    async migrate() {
+        const response = await this.authenticated((api) => api.referralServiceMigrate());
+        return response.migrated;
+    }
+    async getReferralCode() {
+        return this.authenticated((api) => api.referralServiceReferralCode());
+    }
+    async redeemReferralCode(code) {
+        return await this.authenticated((api) => api.referralServiceRedeem(code));
+    }
+    async getReferralCampaign() {
+        return this.authenticated((api) => api.referralServiceGetReferralCampaign());
+    }
+    async getStepSquadRewards() {
+        const response = await this.authenticated((api) => api.referralServiceGetStepSquadRewards());
+        return response.rewards;
+    }
+    async trackReferralInvite(trackReferralInviteRequest) {
+        await this.authenticated((api) => api.referralServiceTrackReferralInvite(trackReferralInviteRequest));
+    }
+    async verifyReferralInvite(verifyReferralInviteRequest) {
+        await this.authenticated((api) => api.referralServiceVerifyReferralInvite(verifyReferralInviteRequest));
+    }
+    async getReferralInvites(status, pagingLimit, pagingNextOffset, pagingPrevOffset) {
+        return await this.authenticated((api) => api.referralServiceGetReferralInvites(status, pagingLimit, pagingNextOffset, pagingPrevOffset));
+    }
+    /* Contacts Sync */
+    async getDataHash(addressBookId) {
+        const response = await this.authenticated((api) => api.contactsServiceDataHash(addressBookId));
+        return response.hash;
+    }
+    async getBucketsHashes(addressBookId, bucketCount) {
+        const response = await this.authenticated((api) => api.contactsServiceBucketsHashes(addressBookId, {
+            bucketCount,
+        }));
+        return new Map(Object.entries(response.hashes).map(([key, val]) => [
+            parseInt(key),
+            val,
+        ]));
+    }
+    async getRecordsHashes(addressBookId, bucketIndex, bucketCount) {
+        const response = await this.authenticated((api) => api.contactsServiceRecordsHashes(addressBookId, {
+            bucketIndex,
+            bucketCount,
+        }));
+        return new Map(Object.entries(response.hashes));
+    }
+    async putContacts(addressBookId, contacts) {
+        const response = await this.authenticated((api) => api.contactsServicePutContacts(addressBookId, {
+            contacts,
+        }));
+        return response.contacts;
+    }
+    async getContacts(addressBookId, referenceIds) {
+        const response = await this.authenticated((api) => api.contactsServiceGetContacts(addressBookId, {
+            referenceIds,
+        }));
+        return response.contacts;
+    }
+    async deleteContacts(addressBookId, referenceIds) {
+        await this.authenticated((api) => api.contactsServiceDeleteContacts(addressBookId, {
+            referenceIds,
+        }));
+    }
+    /**
+     * Authenticates user for Intercom.
+     *
+     * @param env intercom environment to use
+     * @param keyType key type to use
+     */
+    async intercomAuthenticate(env, keyType) {
+        const response = await this.authenticated((api) => api.intercomServiceAuthenticate({
+            env,
+            keyType,
+        }));
+        return response.userHash;
+    }
+    /**
+     * Returns the features enabled for the user, as well as all available features.
+     *
+     * @param includeUpcoming
+     * @param forceRefresh force a refresh of the features enabled for the user on the server
+     */
+    async getFeatures(includeUpcoming = false, forceRefresh = false) {
+        const { features, availableFeatures, } = await this.restrictedAuthenticated((api) => api.featureServiceGetFeatures(includeUpcoming, forceRefresh));
+        return { features, availableFeatures };
+    }
+    /**
+     * Transfer money from/to accounts.
+     *
+     * @param from source account
+     * @param to destination account
+     * @param amount amount to transfer
+     * @param description optional description
+     */
+    async transferSend(from, to, amount, description, prompt) {
+        return await this.stronglyAuthenticated((api) => api.transferServiceSendMoney({
+            amount,
+            description,
+            from,
+            to,
+        }), prompt);
+    }
+    /**
+     * Request money from someone.
+     *
+     * @param fromAlias points to the user the money is being requested from
+     * @param toAccountId specifies account id to deposit funds to
+     * @param amount amount to transfer
+     * @param description optional description
+     */
+    async transferRequest(fromAlias, toAccountId, amount, description) {
+        return await this.authenticated((api) => api.transferServiceRequestMoney({
+            amount,
+            description,
+            fromAlias,
+            toAccountId,
+        }));
+    }
+    /**
+     * Set a recurring transfer.
+     *
+     * @param from source account
+     * @param to destination account
+     * @param amount amount to transfers
+     * @param schedule of the recurring transfer
+     * @param timeZone of the user for the schedule
+     * @param enabled whether the transfer is paused or not.
+     * @param description optional description
+     */
+    async setRecurringTransfer(from, to, amount, schedule, timeZone, enabled, description) {
+        const response = await this.stronglyAuthenticated((api) => api.transferServiceSetRecurringTransfer({
+            amount,
+            description,
+            from,
+            to,
+            schedule,
+            timeZone,
+            enabled,
+        }));
+        return response.transfer;
+    }
+    /**
+     * Retrieves a recurring transfer if exists.
+     *
+     * @param to destination account
+     */
+    async getRecurringTransfer(to) {
+        const response = await this.authenticated((api) => api.transferServiceGetRecurringTransfer({
+            to,
+        }));
+        return response.transfer;
+    }
+    /**
+     * Retrieves all recurring transfers.
+     */
+    async getRecurringTransfers(activeOnly) {
+        const response = await this.authenticated((api) => api.transferServiceGetRecurringTransfers(activeOnly));
+        return response.transfers;
+    }
+    /**
+     * Computes next payment date for given recurring transfer schedule and source.
+     * @param from source account
+     * @param schedule
+     * @param timeZone
+     */
+    async evaluateRecurringTransferSchedule(from, schedule, timeZone, lastTransferDate) {
+        const response = await this.authenticated((api) => api.transferServiceEvaluateSchedule({
+            from,
+            schedule,
+            timeZone,
+            lastTransferDate,
+        }));
+        return response.nextTransfers || [];
+    }
+    /**
+     * Computes next payment dates for given source for all possible schedules.
+     * @param from source account
+     * @param timeZone
+     */
+    async evaluateRecurringTransferAllSchedules(from, timeZone, lastTransferDate) {
+        var _a, _b;
+        const response = await this.authenticated((api) => api.transferServiceEvaluateAllSchedules({
+            from,
+            timeZone,
+            lastTransferDate,
+        }));
+        return ((_b = (_a = response.nextTransfers) === null || _a === void 0 ? void 0 : _a.map((p) => {
+            return {
+                schedule: p.schedule,
+                date: p.nextTransfer,
+            };
+        })) !== null && _b !== void 0 ? _b : []);
+    }
+    async updateRecurringTransferDateStatus(transferDateId, shouldSkip) {
+        const response = await this.authenticated((api) => api.transferServiceUpdateRecurringTransferDateStatus(transferDateId, {
+            shouldSkip,
+        }));
+        return response.transferDate;
+    }
+    /**
+     * Returns a list of transfer requests enqueued for the user.
+     */
+    async transferGetTransferRequests() {
+        const response = await this.authenticated((api) => api.transferServiceGetTransferRequests());
+        return response.requests;
+    }
+    /**
+     * Retrieves transfer request by ID.
+     *
+     * @param transferRequestId transfer request ID
+     */
+    async transferGetTransferRequest(transferRequestId) {
+        const response = await this.authenticated((api) => api.transferServiceGetTransferRequest(transferRequestId));
+        return response.request;
+    }
+    /**
+     * Sets transfer request status to REJECTED.
+     */
+    async transferDeleteTransferRequest(transferRequestId) {
+        await this.authenticated((api) => api.transferServiceDeleteTransferRequest(transferRequestId));
+    }
+    /**
+     * Updates transfer request status
+     * @param transferRequestId transfer request ID
+     * @param status desired status
+     */
+    async transferUpdateTransferRequestStatus(transferRequestId, status) {
+        await this.authenticated((api) => api.transferServiceUpdateTransferRequestStatus(transferRequestId, {
+            status,
+        }));
+    }
+    /**
+     * Looks up merchant information for the given location id.
+     *
+     * @param locationId location id
+     */
+    async merchantLookup(locationId) {
+        const response = await this.authenticated((api) => api.merchantServiceLookupMerchant(locationId));
+        return response.merchant;
+    }
+    /**
+     * Submits merchant location reports.
+     * Location information will be retrieved on the server side by
+     * payment id.
+     *
+     * @param reports list of [MerchantLocationReport] items
+     */
+    async submitMerchantReports(reports) {
+        await this.authenticated((api) => api.merchantServiceSubmitReports({ reports }));
+    }
+    async getAccountStatements(accountId) {
+        const response = await this.authenticated((api) => api.accountServiceListStatements(accountId));
+        return response.statement;
+    }
+    async getAccountStatementSource(primaryAccountId, statementId) {
+        const accessToken = await this.auth.token(__1.AuthLevel.LOW);
+        const encodedAccountId = encodeURIComponent(primaryAccountId);
+        const encodedStatementId = encodeURIComponent(statementId);
+        return {
+            accessToken: accessToken.value,
+            uri: `${this.client.baseURL}/account/${encodedAccountId}/statement/${encodedStatementId}`,
+        };
+    }
+    async getDirectDepositForm(primaryAccountId) {
+        const accessToken = await this.auth.token(__1.AuthLevel.LOW);
+        const encodedAccountId = encodeURIComponent(primaryAccountId);
+        return {
+            accessToken: accessToken.value,
+            uri: `${this.client.baseURL}/account/${encodedAccountId}/direct-deposit`,
+        };
+    }
+    /**
+     * Checks if the user has an active Plaid Exchange OTP and, if so, returns
+     * the expiry.
+     *
+     * @return expiry of the OTP or undefined if none
+     */
+    async hasPlaidOtp() {
+        const response = await this.authenticated((api) => api.plaidServiceHasOtpCode());
+        return response.expiresAtMs
+            ? new Date(parseInt(response.expiresAtMs, 10))
+            : undefined;
+    }
+    /**
+     * Enables and returns the OTP code used to complete Plaid Exchange linking.
+     *
+     * @return Plaid OTP code and expiry
+     */
+    async enablePlaidOtp() {
+        return await this.stronglyAuthenticated((api) => api.plaidServiceEnableOtpCode());
+    }
+    /**
+     * Opens a dispute for a transaction by a user
+     *
+     * @param openDisputeRequest the transaction and reason for the dispute
+     */
+    async openDispute(openDisputeRequest) {
+        return await this.authenticated((api) => api.disputeServiceOpenDispute(openDisputeRequest));
+    }
+    async assignBarcode() {
+        return await this.authenticated((api) => api.cashDepositServiceAssignBarcode());
+    }
+    async getBarcode(barcode) {
+        return await this.authenticated((api) => api.cashDepositServiceGetBarcode(barcode));
+    }
+    async getActiveBarcode() {
+        return await this.authenticated((api) => api.cashDepositServiceGetActiveBarcode());
+    }
+    async getCashDepositLocations(latitude, longitude, address) {
+        const response = await this.authenticated((api) => api.cashDepositServiceGetLocations(latitude, longitude, address));
+        return response.locations;
+    }
+    /**
+     * Revokes Plaid's access to the user's account.
+     */
+    async revokePlaidAccess() {
+        await this.authenticated((api) => api.plaidServiceRevokeAccess());
+    }
+    /**
+     * List of the ATMs nearest to the provided geolocation.
+     * @param latitude location latitude
+     * @param longitude location longitude
+     * @param noFeesOnly return only no-fee ATMs
+     */
+    async locateAtms(latitude, longitude, noFeesOnly) {
+        const response = await this.authenticated((api) => api.atmServiceLocateAtms(latitude, longitude, noFeesOnly));
+        return response.locations;
+    }
+    /**
+     * Fetches account limits.
+     * @param primaryAccountId account primary id
+     */
+    async getLimitState(primaryAccountId) {
+        var _a;
+        const response = await this.authenticated((api) => api.accountServiceGetLimitState(primaryAccountId));
+        return (_a = response.limits) !== null && _a !== void 0 ? _a : [];
+    }
+    /**
+     * Fetches account activity, either by primary account id or sub-account id.
+     *
+     * @param primaryAccountId account primary id
+     * @param subAccountId sub-account id
+     * @param pagingLimit page size
+     * @param pagingNextOffset next offset
+     * @param pagingPrevOffset prev offset
+     */
+    getAccountActivity(primaryAccountId, subAccountId, pagingLimit, pagingNextOffset, pagingPrevOffset) {
+        return this.authenticated((api) => api.txActivityServiceGetAccountActivity(primaryAccountId, subAccountId, pagingLimit, pagingNextOffset, pagingPrevOffset));
+    }
+    getActivityByPaymentId(primaryAccountId, paymentId) {
+        return this.authenticated((api) => api.txActivityServiceGetActivityByPayment(primaryAccountId, paymentId));
+    }
+    async token(authLevel, prompt) {
+        return this.auth.token(authLevel, prompt);
+    }
+    async authenticated(action, authLevel = __1.AuthLevel.LOW, prompt) {
+        const authToken = await this.auth.token(authLevel, prompt);
+        return this.client.execute((api) => action(api, authToken.subject), {
+            authToken,
+        });
+    }
+    async stronglyAuthenticated(action, prompt) {
+        return this.authenticated(action, __1.AuthLevel.STRONG, prompt);
+    }
+    async restrictedAuthenticated(action) {
+        return this.authenticated(action, __1.AuthLevel.RESTRICTED);
+    }
+}
+exports.Api = Api;
+//# sourceMappingURL=Api.js.map