wallet

Access to this module is presently restricted to customers of Wallet Inc. Reach out on Discord for help.

Summary

This module provides a server-side SDK for integrating with the CRM & Digital Payments platform provided by Wallet Inc. For details about the Wallet Platform, please visit https://wallet.inc

For detailed API documentation and detailed steps to create your API key for authenticated requests, please visit the Wallet Developer Hub (https://wallet.dev)

Install

npm install wallet

To test examples

cd examples
npm install # Install ts-node to run typescript examples without transpilation

Usage

Create and manipulate Membership Tiers

import * as api from "wallet";
import * as constants from "./constants";

membershipTiers();

async function membershipTiers() {
    let tiersClient = new api.MembershipTiersApi(constants.domain);

    // Create new membership tier
    let tier = await tiersClient.createMembershipTier({
        tierNumber: "1",
        tierName: "GOLD",
        tierDiscount: 20,
        tierDesignID: "JSUilOPE98",
        pointsDesignID: "L918AJ7356"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // The membership tier that has just been created
    console.log(tier);

    // Fetch the created tier
    tier = (await tiersClient.fetchMembershipTierById(tier.id, constants.headers)).body;
    console.log(tier);

    tier = await tiersClient.updateMembershipTier(tier.id, {
        ...tier,
        tierName: "SILVER"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // Archive the membership tier
    tier = await tiersClient.archiveMembershipTier(tier.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(tier.isActive); // This will be false, since the tier has just been archived

    // Restore the membership tier
    tier = await tiersClient.restoreMembershipTier(tier.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(tier.isActive); // This will be true, since the tier has just been restored

    // Fetch paginated tier history logs
    let historyLogs = (await tiersClient.fetchMembershipTierHistoryLog({
        pageSize: 10,
        pageNum: 1,
        id: tier.id
    }, constants.headers)).body;

    console.log(historyLogs);

    let redemptionLogs = (await tiersClient.fetchMembershipTierRedemptionLog({
        pageSize: 10,
        pageNum: 1,
        id: tier.id
    }, constants.headers)).body;

    console.log(redemptionLogs);

    // Fetch the list of tiers with members
    let tiersList = ((await (tiersClient.fetchAllMembershipTiersWithMemberCount(false, constants.headers))).body);
    console.log(tiersList);
}

Create and manipulate Payment Designs

import * as api from "wallet";
import * as constants from "./constants";

paymentDesigns();

async function paymentDesigns() {
    let designClient = new api.PaymentDesignsApi(constants.domain);

    // Create a new payment design
    let design = await designClient.createPaymentDesign({
        borderColor: "#f0f0f0",
        borderStyleType: "Dashed",
        borderSize: "4px",
        borderRadius: 2,
        fontColor: "#777777",
        fontType: "Arial",
        abbreviation: "ABBR",
        acronym: "AR",
        icon: "fa-anchor",
        designName: "Thanksgiving Design",
        displayName: "Decorator",
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // The payment design that has just been created
    console.log(design);

    // Fetch the created design
    design = (await designClient.fetchPaymentDesignById(design.id, constants.headers)).body;
    console.log(design);

    // Change the borderColor and borderSize of the payment design
    design = await designClient.updatePaymentDesign(design.id, {
        ...design,
        borderColor: "#050505",
        borderSize: "6px",
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // Archive the payment design
    design = await designClient.archivePaymentDesign(design.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(design.isActive); // This will be false, since the design has just been archived

    // Restore the payment design
    design = await designClient.restorePaymentDesign(design.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });
    console.log(design.isActive); // This will be true, since the design has just been restored

    // Fetch all payment designs
    let designs = (await designClient.fetchAllPaymentDesigns(false, constants.headers)).body;
    console.log(designs);
}

Create and manipulate Club Members

import * as api from "wallet";
import { PaginationRequestWithSortOptions } from "wallet";
import * as constants from "./constants";

clubMembers();

async function clubMembers() {
    let membersClient = new api.ClubMembersPointsApi(constants.domain);

    // Create new club member
    let member = await membersClient.createMember({
        firstName: "John",
        lastName: "Doe",
        membershipTierID: "HDywI893LQ",
        mobileNumber: "[phone]",
        pointsAccrued: 2000,
        memberID: "MEM001"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // The club member that has just been created
    console.log(member);

    // Fetch the created member
    member = (await membersClient.fetchMemberById(member.id, constants.headers)).body;
    console.log(member);

    member = await membersClient.updateMember(member.id, {
        ...member,
        mobileNumber: "[phone]"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // Archive the club member
    member = await membersClient.archiveMember(member.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(member.isActive); // This will be false, since the member has just been archived

    // Restore the club member
    member = await membersClient.restoreMember(member.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(member.isActive); // This will be true, since the member has just been restored

    // Fetch members by page
    let members = (await membersClient.fetchMembersByPage({
        pageSize: 10, pageNum: 1, sortKey: PaginationRequestWithSortOptions.SortKeyEnum.CreatedAt
    })).body;

    console.log(members);

    // Fetch paginated member history logs
    let historyLogs = (await membersClient.fetchMemberHistoryLog({
        pageSize: 10,
        pageNum: 1,
        id: member.id
    }, constants.headers)).body;

    console.log(historyLogs);

    let redemptionLogs = (await membersClient.fetchMemberRedemptionLog({
        pageSize: 10,
        pageNum: 1,
        id: member.id
    }, constants.headers)).body;

    console.log(redemptionLogs);

    // Fetch the count of members
    let membersCount = ((await (membersClient.fetchMembersCount(constants.headers))).body).count;
    console.log(membersCount);
}

Create and manipulate Advertisement Credits

import * as api from "wallet";
import * as constants from "./constants";

advertisementCredits();

async function advertisementCredits() {
    let client = new api.AdvertisementCreditsApi(constants.domain);

    let title = "Ad Credit API Client (New Headers)";

    // Create a new advertisement credit
    let adCredit = await client.createAdvertisementCredit({
        title: title,
        valueType: "percent",
        paymentDesignID: "jbkVgPTgoo",
        maxUses: 5,
        discountValue: 500,
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // The advertisement credit that has just been created
    console.log(adCredit);

    // Fetch the advertisement credit that has just been created
    adCredit = (await client.fetchAdvertisementCreditById(adCredit.id, constants.headers)).body;
    console.log(adCredit);

    // Update the advertisement credit with a new maxUses count
    adCredit = await client.updateAdvertisementCredit(adCredit.id, {
        title: `${title} Update`,
        valueType: "percent",
        paymentDesignID: "jbkVgPTgoo",
        maxUses: 10,
        discountValue: 1000,
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // Retrieve all the scans
    let scans = (await client.fetchAdvertisementCreditScans(adCredit.id, constants.headers)).body;
    console.log("All scans: " + JSON.stringify(scans));

    // Archive the advertisement credit
    adCredit = await client.archiveAdvertisementCredit(adCredit.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(adCredit.isActive); // This will be false, since the advertisement credit has just been archived

    // Restore the advertisement credit
    adCredit = await client.restoreAdvertisementCredit(adCredit.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(adCredit.isActive); // This will be true, since the advertisement credit has just been restored

    // Fetch all the active advertisement credits
    let adCredits = (await client.fetchAllAdvertisementCredits(false, constants.headers)).body;
    console.log("Active advertisement credits: ", JSON.stringify(adCredit));
}

Create and manipulate Link Book Links

import * as api from "wallet";
import * as constants from "./constants";

linkBook();

async function linkBook() {
    let client = new api.LinkBookApi(constants.domain);

    // Create a new link book link
    let link = await client.createLinkBook({
        title: "External Link",
        url: "https://example.com",
        icon: "fa-clock",
        orderNumber: 1,
        linkBookSectionID: "",
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // The link book link that has just been created
    console.log(link);

    // Update the link book link with a new url
    link = await client.updateLinkBook(link.id, {
        ...link,
        url: "https://test.com"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // Archive the link book link
    link = await client.archiveLinkBook(link.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(link.isActive); // This will be false, since the link book link has just been archived

    // Restore the link book link
    link = await client.restoreLinkBook(link.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(link.isActive); // This will be true, since the link book link has just been restored

    // Fetch all links
    let links = (await client.fetchAllLinkBook(false, constants.headers)).body;
    console.log(links);
}

Create and manipulate Merchant URLs

import * as api from "wallet";
import * as constants from "./constants";

merchantURLs();

async function merchantURLs() {
    let client = new api.MerchantURLsApi(constants.domain);

    // Create a new merchant URL
    let url = await client.createMerchantURL({
        nickname: "Instagram",
        destinationURL: "https://instagram.com/merchant"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // The merchant URL that has just been created
    console.log(url);

    // Fetch the created url
    url = (await client.fetchMerchantURL(url.id, constants.headers)).body;
    console.log(url);

    // Update the merchant URL with a new destination URL
    url = await client.updateMerchantURL(url.id, {
        ...url,
        destinationURL: "https://instagram.com/redirect/merchant"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // Archive the merchant URL
    url = await client.archiveMerchantURL(url.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(url.isActive); // This will be false, since the merchant URL has just been archived

    // Restore the merchant URL
    url = await client.restoreMerchantURL(url.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(url.isActive); // This will be true, since the merchant URL has just been restored

    // Fetch all merchant urls
    let urls = (await client.fetchAllMerchantURLs(false, constants.headers)).body;
    console.log(urls);

    // Fetch all the wallet page views for the given merchant url
    let pageViews = (await (client.fetchMerchantURLRequests(url.id, constants.headers))).body;
    console.log(pageViews);
}

Create and manipulate News Articles

import * as api from "wallet";
import * as constants from "./constants";

news();

async function news() {
    let client = new api.NewsApi(constants.domain);

    // Create a new news article
    let article = await client.createNewsArticle({
        title: "News Article",
        orderNumber: 1,
        body: "This is a news article related to the merchant",
        url: "https://blog.merchant.com",
        mediaURL: "https://example.com/image"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });


    // The news article that has just been created
    console.log(article);

    // Update the news article with a new title
    article = await client.updateNewsArticle(article.id, {
        ...article,
        title: "News Article Updated"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // Archive the news article
    article = await client.archiveNewsArticle(article.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(article.isActive); // This will be false, since the news article has just been archived

    // Restore the news article
    article = await client.restoreNewsArticle(article.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(article.isActive); // This will be true, since the news article has just been restored

    // Fetch all articles
    let articles = (await client.fetchAllNewsArticles(false, constants.headers)).body;
    console.log(articles);
}

Create and manipulate Performances

import * as api from "wallet";
import * as constants from "./constants";

performances();

async function performances() {
    let client = new api.PerformancesApi(constants.domain);

    // Create a new performance
    let performance = await client.createPerformance({
        title: "Performance",
        body: "Details related to the performance",
        startDateTime: new Date(),
        price: 200,
        url: "https://blog.merchant.com",
        orderNumber: 1,
        mediaURL: "https://example.com/image",
        isSoldOut: false,

    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });


    // The performance that has just been created
    console.log(performance);

    // Update the performance with a new title
    performance = await client.updatePerformance(performance.id, {
        ...performance,
        title: "performance Updated"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // Archive the performance
    performance = await client.archivePerformance(performance.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(performance.isActive); // This will be false, since the performance has just been archived

    // Restore the performance
    performance = await client.restorePerformance(performance.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(performance.isActive); // This will be true, since the performance has just been restored

    // Fetch all performances
    let performances = (await client.fetchAllPerformances(false, constants.headers)).body;
    console.log(performances);
}

Create and manipulate Promo Codes

import * as api from "wallet";
import * as constants from "./constants";

promocodes();

async function promocodes() {
    let client = new api.PromoCodesApi(constants.domain);

    // Create a new promocode
    let promocode = await client.createPromoCode({
        title: "Promo Code",
        description: "Description about Promo Code",
        promoCode: "MON50OFF",
        displayValue: "50OFF",
        orderNumber: 1,
        startDate: new Date(),
        expirationDate: new Date(new Date().getTime() + (5 * 24 * 60 * 60 * 1000))
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // The promocode that has just been created
    console.log(promocode);

    // Update the promocode with a new title
    promocode = await client.updatePromoCode(promocode.id, {
        ...promocode,
        title: "promocode Updated"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // Archive the promocode
    promocode = await client.archivePromoCode(promocode.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(promocode.isActive); // This will be false, since the promocode has just been archived

    // Restore the promocode
    promocode = await client.restorePromoCode(promocode.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(promocode.isActive); // This will be true, since the promocode has just been restored

    // Fetch all promocodes
    let promocodes = (await client.fetchAllPromoCodes(false, constants.headers)).body;
    console.log(promocodes);
}

Create and manipulate Merchant Credits

import * as api from "wallet";
import { PaginationRequestWithSortOptions } from "wallet";
import * as constants from "./constants";

merchantCredits();

async function merchantCredits() {
    let client = new api.MerchantCreditsApi(constants.domain);

    // Create a new merchant credit
    let merchantcredit = await client.createMerchantCredit({
        mobileNumber: "[phone]",
        creditAmount: 2000, // In cents
        memberID: "MEM001"
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // The merchant credit that has just been created
    console.log(merchantcredit);

    // Fetch the created merchantcredit
    merchantcredit = (await client.fetchMerchantCreditById(merchantcredit.id, constants.headers)).body;
    console.log(merchantcredit);

    // Update the merchant credit with a new title
    merchantcredit = await client.updateMerchantCredit(merchantcredit.id, {
        ...merchantcredit,
        creditAmount: 1000, // In cents
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // Archive the merchant credit
    merchantcredit = await client.archiveMerchantCredit(merchantcredit.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(merchantcredit.isActive); // This will be false, since the merchant credit has just been archived

    // Restore the merchant credit
    merchantcredit = await client.restoreMerchantCredit(merchantcredit.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(merchantcredit.isActive); // This will be true, since the merchant credit has just been restored

    // Fetch merchantcredits by page
    let merchantcredits = (await client.fetchMerchantCreditsByPage({
        pageSize: 10, pageNum: 1, sortKey: PaginationRequestWithSortOptions.SortKeyEnum.CreatedAt
    })).body;

    console.log(merchantcredits);

    // Fetch paginated merchantcredit history logs
    let historyLogs = (await client.fetchMerchantCreditHistoryLog({
        pageSize: 10,
        pageNum: 1,
        id: merchantcredit.id
    }, constants.headers)).body;

    console.log(historyLogs);

    let redemptionLogs = (await client.fetchMerchantCreditRedemptionLog({
        pageSize: 10,
        pageNum: 1,
        id: merchantcredit.id
    }, constants.headers)).body;

    console.log(redemptionLogs);

    // Fetch the count of merchantcredits
    let merchantcreditsCount = ((await (client.fetchMerchantCreditCount(constants.headers))).body).count;
    console.log(merchantcreditsCount);
}

Create and manipulate Dynamic Vouchers

import * as api from "wallet";
import * as constants from "./constants";

dynamicVouchers();

async function dynamicVouchers() {
    let client = new api.DynamicVouchersApi(constants.domain);

    // Fetch payment design
    let designClient = new api.PaymentDesignsApi(constants.domain);
    let allDesigns = await designClient.fetchAllPaymentDesigns(false, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });
    let selectedDesign = allDesigns[0];

    let startDate = new Date();
    let expiryDate = new Date((new Date()).setDate((new Date()).getDate() + 5));

    let params: api.WTDynamicVoucherCreateParams = {
        title: "Dynamic Voucher API Client",
        notes: "Example notes",
        paymentDesignID: selectedDesign.id,
        dateTimeStart: startDate,
        dateTimeExpiration: expiryDate,
        startingValue: 1000, // In cents
        maxBudget: 90000, // In cents
        decreaseAmount: 10, // In cents
        frequency: 10, // Every 10 units of the frequencyType
        frequencyType: "Minute(s)", // Possible values are: "Minute(s)", "Hour(s)", "Day(s)", "Week(s)", "Second(s)"
        isActive: true,
    }

    let voucher = await client.createDynamicVoucher(params, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    console.log(voucher);

    // Fetch dynamic voucher by id
    voucher = await client.fetchDynamicVoucherById(voucher.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(voucher);

    // Update dynamic voucher
    voucher = await client.saveDynamicVoucher(voucher.id, {
        ...params,
        title: `${voucher.title} Updated`,
    }, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(voucher);

    // Fetch all dynamic vouchers
    let allVouchers = await client.fetchAllDynamicVouchers(false, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(allVouchers);

    // Fetch all the redemptions
    let allRedemptions = await client.fetchDynamicVoucherRedemptions(voucher.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(allRedemptions);


    // Fetch reach stats of individual dynamic voucher
    let individualVoucherReachStats = await client.fetchReachStatsOfIndividualDynamicVoucher(voucher.id, undefined, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(individualVoucherReachStats);

    // Fetch reach stats of all the dynamic vouchers
    let allVouchersReachStats = await client.fetchReachStatsOfAllDynamicVouchers(undefined, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(allVouchersReachStats);
}

Create and manipulate Static Voucher Campaigns

import * as api from "wallet";
import * as constants from "./constants";

staticVoucherCampaigns();

async function staticVoucherCampaigns() {
    let client = new api.StaticVoucherCampaignsApi(constants.domain);
    // Fetch payment design
    let designClient = new api.PaymentDesignsApi(constants.domain);
    let allDesigns = await designClient.fetchAllPaymentDesigns(false, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });
    let selectedDesign = allDesigns[0];

    let startDate = new Date();
    let expiryDate = new Date((new Date()).setDate((new Date()).getDate() + 5));

    let params: api.CreateStaticVoucherCampaign = {
        startDateTime: startDate,
        expirationDateTime: expiryDate,
        title: "Static Voucher Campaign API Client",
        notes: "Example notes",
        valueType: "currency", // percent or currency
        displayValue: "$5 Off",
        merchantsReferenceID: "",
        validOnlyAtPOSRegisterIDs: [],
        paymentDesignID: selectedDesign.id,
        isActive: true,
        sourceID: 0,
    }
    let campaign = await client.createStaticVoucherCampaign(params, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(campaign);


    // Fetch static voucher campaign by ID
    campaign = await client.fetchStaticVoucherCampaignById(campaign.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(campaign);

    // Fetch all the static voucher campaigns
    let allCampaigns = await client.fetchStaticVoucherCampaigns(false, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(allCampaigns);

    // Fetch all vouchers within a static voucher campaign
    let allVouchers = await client.fetchStaticVouchers(campaign.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(allVouchers);

    // Fetch vouchers within a static voucher campaign by page
    let allVouchersByPage = await client.fetchStaticVouchersPage(campaign.id, 1, 10, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(allVouchersByPage);

    // Fetch performance overview
    let performanceOverview = await client.fetchPerformanceOverview(campaign.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(performanceOverview);

    // Fetch reach stats of individual static voucher campaign
    let individualCampaignReachStats = await client.fetchReachStatsOfIndividualStaticVoucherCampaign(campaign.id, undefined, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(individualCampaignReachStats);

    // Fetch reach stats of all static voucher campaigns
    let allStaticVoucherCampaignStats = await client.fetchReachStatsOfAllStaticVoucherCampaigns(undefined, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(allStaticVoucherCampaignStats);

    // Fetch wallet page views of a static voucher campaign
    let views = await client.fetchViews(campaign.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(views);

    // Fetch redeemed vouchers
    let redeemedVouchers = await client.fetchVouchersRedeemed(campaign.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(redeemedVouchers);

    // Duplicate static voucher campaign
    let duplicatedCampaign = await client.duplicateStaticVoucherCampaignById(campaign.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(duplicatedCampaign);

    // Update static voucher campaign
    campaign = await client.updateStaticVoucherCampaign(campaign.id, {
        ...params,
        title: `${params.title} Updated`
    }, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(campaign);

    // Create static voucher campaign with voucher
    let campaignWithVoucher = await client.createStaticVoucherCampaignWithVoucher({
        ...params,
        cellPhone: "[phone]",
        memberID: "MEM0091",
        offerAmountCents: 1000
    }, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(campaignWithVoucher);

    allVouchers = await client.fetchStaticVouchers(campaignWithVoucher.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    // Update static voucher campaign
    campaignWithVoucher = await client.updateStaticVoucherCampaignWithVoucher(campaignWithVoucher.id, {
        ...params,
        offerAmountCents: 2000,
        voucherID: allVouchers[0].id
    }, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });

    console.log(campaignWithVoucher);
}

Create and manipulate Static Vouchers

import * as api from "wallet";
import * as constants from "./constants";

staticVouchers();

async function staticVouchers() {
    let client = new api.StaticVouchersApi(constants.domain);

    let params: api.WTStaticVoucherCreateParams = {
        offerAmountCents: 1000, // In cents
        memberID: "MEM0090",
        cellPhone: "[phone]",
        campaignID: "",
    }
    // Create a new static voucher
    let voucher = await client.createStaticVoucher(params, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // The static voucher that has just been created
    console.log(voucher);

    // Fetch the static voucher that has just been created
    voucher = (await client.fetchStaticVoucher(voucher.id, constants.headers)).body;
    console.log(voucher);

    // Update the static voucher with a new maxUses count
    voucher = await client.updateStaticVoucher(voucher.id, {
        ...params,
        offerAmountCents: 2000 // In cents
    }, constants.headers).catch(err => {
        throw err;
    }).then(resp => {
        return resp.body
    });

    // Archive the static voucher
    await client.deleteStaticVoucher(voucher.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body
        });


    // Fetch reach stats of individual static voucher
    let individualVoucherReachStats = await client.fetchReachStatsOfIndividualStaticVoucher(voucher.id, undefined, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(individualVoucherReachStats);

    // Fetch reach stats of all the static vouchers
    let allVouchersReachStats = await client.fetchReachStatsOfAllStaticVouchers(undefined, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(allVouchersReachStats);
}

Create and manipulate SMSes

import * as api from "wallet";
import * as constants from "./constants";

smsExample();

async function smsExample() {
    let client = new api.SMSApi(constants.domain);

    // Acquire phone number
    let phoneNumber = await client.acquirePhoneNumber({
        phoneNumber: "[phone]"
    }, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(phoneNumber);

    // Send phone number for verification
    await client.sendPhoneNumberForVerification(phoneNumber.id, {
        helpDeskQueueResponse: "HELPME",
        helpDeskKeyword: "HELP12",
        helpResponse: "Hello, we're here to help.",
        stopResponse: "We're sad to see you go",
        messageFooter: "Subscribe for more info!",
        termsOfServiceURL: "https://example.com/terms-of-service",
        privacyPolicyURL: "https://example.com/privacy-policy",
        companyName: "Fictitious Corporation"
    }, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    // Archive phone number
    phoneNumber = await client.archivePhoneNumber(phoneNumber.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(phoneNumber.isActive); // This will be false

    // Restore phone number
    phoneNumber = await client.restorePhoneNumber(phoneNumber.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(phoneNumber.isActive); // This will be true

    // Create SMS agreement
    let agreement = await client.createSMSAgreement({
        isShortCodeTimelineUnderstood: true,
        isPricingUnderstood: true,
        isShortCodeTransferUnderstood: true,
        isOptInOutUnderstood: true,
        isShortCodeUnderstood: true,
        isStandardsUnderstood: true,
        isCtiaShortCodeRead: true,
        isManualRead: true,
        isStopUnderstood: true,
        isTosOnWebsite: true,
        isPrivacyPolicyOnWebsite: true,
        isTwilioTermsRead: true,
    }, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(agreement);

    // Fetch the agreement
    agreement = await client.fetchSMSAgreement(constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(agreement);

    // Create imported list
    let importedList = await client.createImportedList({
        listName: "Imported List",
        isActive: true,
        phoneNumberID: phoneNumber.id
    }, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(importedList);


    // Create recipient in imported list
    let recipient = await client.createRecipientInImportedList({
        importedListID: importedList.id,
        mobilePhoneNumber: "[phone]"
    }, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(recipient);

    // Count recipients in imported list
    let { count } = await client.countImportedListRecipients(importedList.id, false, undefined, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(count);

    // Fetch recipients
    let importedListRecipients = await client.fetchImportedListRecipients(importedList.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(importedListRecipients);

    // Fetch recipients by page
    let importedListRecipientByPage = await client.fetchImportedListRecipientsByPage(importedList.id, 10, 1, false, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(`Total: ${importedListRecipientByPage.total}, Length: ${importedListRecipientByPage.length}, List: ${JSON.stringify(importedListRecipientByPage.results)}`);

    // Export recipients
    await client.exportImportedListRecipients(importedList.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    // Create opt in list
    let optInList = await client.createOptInList({
        isActive: true,
        listName: "Opt In List",
        phoneNumberID: phoneNumber.id,
        estimatedMessagesPerMonth: 250,
        optInKeyword: "OPTIN",
        optOutKeyword: "OPTOUT",
        optInConfirmedResponse: "You've opted in",
        optOutConfirmedResponse: "You've opted out",
        optInConfirmedCustomerReceives: "You've opted in",
        optOutConfirmedCustomerReceives: "You've opted out",
        isOver21Required: false,
    }, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(optInList);

    // Count opt in list subscribers
    count = await client.countOptInListSubscribers(optInList.id, true, false, false, undefined, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return (resp.body).count;
        });

    console.log(count);

    // Export opt in list subscribers
    await client.exportOptInListSubscribers(optInList.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    // Fetch subscribers
    let optInListRecipients = await client.fetchOptInListSubscribers(optInList.id, true, false, false, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(optInListRecipients);

    // Fetch subscribers by page
    let optInListRecipientByPage = await client.fetchOptInListSubscribersByPage(optInList.id, 10, 1, true, false, false, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(`Total: ${optInListRecipientByPage.total}, Length: ${optInListRecipientByPage.length}, List: ${JSON.stringify(optInListRecipientByPage.results)}`);

    // Fetch all opt in lists associated with the given phone number

    let optInListsAssociatedWithPhoneNumber = await client.fetchOptInListsAssociatedWithPhoneNumber(phoneNumber.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(optInListsAssociatedWithPhoneNumber);

    // Create opt in source
    let optInSource = await client.createOptInListSource({
        sourceName: "Opt In Source",
        listID: optInList.id,
    }, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });
    console.log(optInSource);


    // Count subscribers in opt in list source
    count = await client.countOptInSourceSubscribers(optInSource.id, true, false, false, undefined, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return (resp.body).count;
        });

    console.log(count);

    let optInSourceSubscribers = await client.fetchOptInSourceSubscribers(optInSource.id, true, false, false, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(optInSourceSubscribers);

    let optInSourcesAssociatedWithPhoneNumber = await client.fetchOptInSourcesAssociatedWithPhoneNumber(phoneNumber.id, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });

    console.log(optInSourcesAssociatedWithPhoneNumber);

    // Fetch all outbound SMSes
    let outboundSMSes = await client.fetchOutboundSMS(phoneNumber.id, undefined, undefined, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });
    console.log(outboundSMSes);

    // Fetch outbound SMSes by page
    let outboundSMSesByPage = await client.fetchOutboundSMSByPage(phoneNumber.id, undefined, undefined, 10, 1, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });
    console.log(`Total: ${outboundSMSesByPage.total}, Length: ${outboundSMSesByPage.length}, Messages: ${JSON.stringify(outboundSMSesByPage.results)}`);


    // Count outbound SMSes
    let outboundSMSesCount = await client.countOutboundSMS(phoneNumber.id, undefined, undefined, undefined, constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return (resp.body).count;
        });
    console.log(outboundSMSesCount);

    // Retrieve message limits
    let limits = await client.retrieveSentAndMaxCountOfMessages(constants.headers)
        .catch(err => {
            throw err;
        }).then(resp => {
            return resp.body;
        });
    console.log(`Max: ${limits.max}, Sent: ${limits.sent}`);
}