@actual-app/api 5.1.2 → 6.0.0

package/dist/app/query.d.ts

@@ -0,0 +1,19 @@
+export default function q(table: any): Query;
+declare class Query {
+    constructor(state: any);
+    state: any;
+    filter(expr: any): Query;
+    unfilter(exprs: any): Query;
+    select(exprs?: any[]): Query;
+    calculate(expr: any): Query;
+    groupBy(exprs: any): Query;
+    orderBy(exprs: any): Query;
+    limit(num: any): Query;
+    offset(num: any): Query;
+    raw(): Query;
+    withDead(): Query;
+    withoutValidatedRefs(): Query;
+    options(opts: any): Query;
+    serialize(): any;
+}
+export {};

package/dist/app/query.js

@@ -0,0 +1,102 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Query = /** @class */ (function () {
+    function Query(state) {
+        this.state = __assign({ filterExpressions: state.filterExpressions || [], selectExpressions: state.selectExpressions || [], groupExpressions: state.groupExpressions || [], orderExpressions: state.orderExpressions || [], calculation: false, rawMode: false, withDead: false, validateRefs: true, limit: null, offset: null }, state);
+    }
+    Query.prototype.filter = function (expr) {
+        return new Query(__assign(__assign({}, this.state), { filterExpressions: __spreadArray(__spreadArray([], __read(this.state.filterExpressions), false), [expr], false) }));
+    };
+    Query.prototype.unfilter = function (exprs) {
+        var exprSet = new Set(exprs);
+        return new Query(__assign(__assign({}, this.state), { filterExpressions: this.state.filterExpressions.filter(function (expr) { return !exprSet.has(Object.keys(expr)[0]); }) }));
+    };
+    Query.prototype.select = function (exprs) {
+        if (exprs === void 0) { exprs = []; }
+        if (!Array.isArray(exprs)) {
+            exprs = [exprs];
+        }
+        var query = new Query(__assign(__assign({}, this.state), { selectExpressions: exprs }));
+        query.state.calculation = false;
+        return query;
+    };
+    Query.prototype.calculate = function (expr) {
+        var query = this.select({ result: expr });
+        query.state.calculation = true;
+        return query;
+    };
+    Query.prototype.groupBy = function (exprs) {
+        if (!Array.isArray(exprs)) {
+            exprs = [exprs];
+        }
+        return new Query(__assign(__assign({}, this.state), { groupExpressions: __spreadArray(__spreadArray([], __read(this.state.groupExpressions), false), __read(exprs), false) }));
+    };
+    Query.prototype.orderBy = function (exprs) {
+        if (!Array.isArray(exprs)) {
+            exprs = [exprs];
+        }
+        return new Query(__assign(__assign({}, this.state), { orderExpressions: __spreadArray(__spreadArray([], __read(this.state.orderExpressions), false), __read(exprs), false) }));
+    };
+    Query.prototype.limit = function (num) {
+        return new Query(__assign(__assign({}, this.state), { limit: num }));
+    };
+    Query.prototype.offset = function (num) {
+        return new Query(__assign(__assign({}, this.state), { offset: num }));
+    };
+    Query.prototype.raw = function () {
+        return new Query(__assign(__assign({}, this.state), { rawMode: true }));
+    };
+    Query.prototype.withDead = function () {
+        return new Query(__assign(__assign({}, this.state), { withDead: true }));
+    };
+    Query.prototype.withoutValidatedRefs = function () {
+        return new Query(__assign(__assign({}, this.state), { validateRefs: false }));
+    };
+    Query.prototype.options = function (opts) {
+        return new Query(__assign(__assign({}, this.state), { tableOptions: opts }));
+    };
+    Query.prototype.serialize = function () {
+        return this.state;
+    };
+    return Query;
+}());
+function q(table) {
+    return new Query({ table: table });
+}
+exports.default = q;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export function init(config?: {}): Promise<any>;
+export function shutdown(): Promise<void>;
+export const internal: any;
+export * as methods from "./methods";
+export * as utils from "./utils";

package/dist/index.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shutdown = exports.init = exports.utils = exports.methods = exports.internal = void 0;
+var node_fetch_1 = __importDefault(require("node-fetch"));
+var bundle = __importStar(require("./app/bundle.api"));
+var injected = __importStar(require("./injected"));
+var actualApp;
+exports.internal = bundle.lib;
+exports.methods = __importStar(require("./methods"));
+exports.utils = __importStar(require("./utils"));
+function init(config) {
+    if (config === void 0) { config = {}; }
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (actualApp) {
+                        return [2 /*return*/];
+                    }
+                    global.fetch = node_fetch_1.default;
+                    return [4 /*yield*/, bundle.init(config)];
+                case 1:
+                    _a.sent();
+                    actualApp = bundle.lib;
+                    injected.override(bundle.lib.send);
+                    return [2 /*return*/, bundle.lib];
+            }
+        });
+    });
+}
+exports.init = init;
+function shutdown() {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!actualApp) return [3 /*break*/, 2];
+                    return [4 /*yield*/, actualApp.send('close-budget')];
+                case 1:
+                    _a.sent();
+                    actualApp = null;
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.shutdown = shutdown;

package/dist/injected.d.ts

@@ -0,0 +1,2 @@
+export function override(sendImplementation: any): void;
+export let send: any;

package/dist/injected.js

@@ -0,0 +1,8 @@
+"use strict";
+// TODO: comment on why it works this way
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.override = exports.send = void 0;
+function override(sendImplementation) {
+    exports.send = sendImplementation;
+}
+exports.override = override;

package/dist/methods.d.ts

@@ -0,0 +1,35 @@
+export function runImport(name: any, func: any): Promise<void>;
+export function loadBudget(budgetId: any): Promise<any>;
+export function downloadBudget(syncId: any, { password }?: {
+    password: any;
+}): Promise<any>;
+export function batchBudgetUpdates(func: any): Promise<void>;
+export function runQuery(query: any): any;
+export function getBudgetMonths(): any;
+export function getBudgetMonth(month: any): any;
+export function setBudgetAmount(month: any, categoryId: any, value: any): any;
+export function setBudgetCarryover(month: any, categoryId: any, flag: any): any;
+export function addTransactions(accountId: any, transactions: any): any;
+export function importTransactions(accountId: any, transactions: any): any;
+export function getTransactions(accountId: any, startDate: any, endDate: any): any;
+export function filterTransactions(accountId: any, text: any): any;
+export function updateTransaction(id: any, fields: any): any;
+export function deleteTransaction(id: any): any;
+export function getAccounts(): any;
+export function createAccount(account: any, initialBalance: any): any;
+export function updateAccount(id: any, fields: any): any;
+export function closeAccount(id: any, transferAccountId: any, transferCategoryId: any): any;
+export function reopenAccount(id: any): any;
+export function deleteAccount(id: any): any;
+export function createCategoryGroup(group: any): any;
+export function updateCategoryGroup(id: any, fields: any): any;
+export function deleteCategoryGroup(id: any, transferCategoryId: any): any;
+export function getCategories(): any;
+export function createCategory(category: any): any;
+export function updateCategory(id: any, fields: any): any;
+export function deleteCategory(id: any, transferCategoryId: any): any;
+export function getPayees(): any;
+export function createPayee(payee: any): any;
+export function updatePayee(id: any, fields: any): any;
+export function deletePayee(id: any): any;
+export { default as q } from "./app/query";

package/dist/methods.js

@@ -0,0 +1,258 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deletePayee = exports.updatePayee = exports.createPayee = exports.getPayees = exports.deleteCategory = exports.updateCategory = exports.createCategory = exports.getCategories = exports.deleteCategoryGroup = exports.updateCategoryGroup = exports.createCategoryGroup = exports.deleteAccount = exports.reopenAccount = exports.closeAccount = exports.updateAccount = exports.createAccount = exports.getAccounts = exports.deleteTransaction = exports.updateTransaction = exports.filterTransactions = exports.getTransactions = exports.importTransactions = exports.addTransactions = exports.setBudgetCarryover = exports.setBudgetAmount = exports.getBudgetMonth = exports.getBudgetMonths = exports.runQuery = exports.batchBudgetUpdates = exports.downloadBudget = exports.loadBudget = exports.runImport = exports.q = void 0;
+var injected = __importStar(require("./injected"));
+var query_1 = require("./app/query");
+Object.defineProperty(exports, "q", { enumerable: true, get: function () { return __importDefault(query_1).default; } });
+function send(name, args) {
+    return injected.send(name, args);
+}
+function runImport(name, func) {
+    return __awaiter(this, void 0, void 0, function () {
+        var e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, send('api/start-import', { budgetName: name })];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 4, , 6]);
+                    return [4 /*yield*/, func()];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 6];
+                case 4:
+                    e_1 = _a.sent();
+                    return [4 /*yield*/, send('api/abort-import')];
+                case 5:
+                    _a.sent();
+                    throw e_1;
+                case 6: return [4 /*yield*/, send('api/finish-import')];
+                case 7:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.runImport = runImport;
+function loadBudget(budgetId) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, send('api/load-budget', { id: budgetId })];
+        });
+    });
+}
+exports.loadBudget = loadBudget;
+function downloadBudget(syncId, _a) {
+    var _b = _a === void 0 ? {} : _a, password = _b.password;
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_c) {
+            return [2 /*return*/, send('api/download-budget', { syncId: syncId, password: password })];
+        });
+    });
+}
+exports.downloadBudget = downloadBudget;
+function batchBudgetUpdates(func) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, send('api/batch-budget-start')];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, , 4, 6]);
+                    return [4 /*yield*/, func()];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 6];
+                case 4: return [4 /*yield*/, send('api/batch-budget-end')];
+                case 5:
+                    _a.sent();
+                    return [7 /*endfinally*/];
+                case 6: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.batchBudgetUpdates = batchBudgetUpdates;
+function runQuery(query) {
+    return send('api/query', { query: query.serialize() });
+}
+exports.runQuery = runQuery;
+function getBudgetMonths() {
+    return send('api/budget-months');
+}
+exports.getBudgetMonths = getBudgetMonths;
+function getBudgetMonth(month) {
+    return send('api/budget-month', { month: month });
+}
+exports.getBudgetMonth = getBudgetMonth;
+function setBudgetAmount(month, categoryId, value) {
+    return send('api/budget-set-amount', { month: month, categoryId: categoryId, amount: value });
+}
+exports.setBudgetAmount = setBudgetAmount;
+function setBudgetCarryover(month, categoryId, flag) {
+    return send('api/budget-set-carryover', { month: month, categoryId: categoryId, flag: flag });
+}
+exports.setBudgetCarryover = setBudgetCarryover;
+function addTransactions(accountId, transactions) {
+    return send('api/transactions-add', { accountId: accountId, transactions: transactions });
+}
+exports.addTransactions = addTransactions;
+function importTransactions(accountId, transactions) {
+    return send('api/transactions-import', { accountId: accountId, transactions: transactions });
+}
+exports.importTransactions = importTransactions;
+function getTransactions(accountId, startDate, endDate) {
+    return send('api/transactions-get', { accountId: accountId, startDate: startDate, endDate: endDate });
+}
+exports.getTransactions = getTransactions;
+function filterTransactions(accountId, text) {
+    return send('api/transactions-filter', { accountId: accountId, text: text });
+}
+exports.filterTransactions = filterTransactions;
+function updateTransaction(id, fields) {
+    return send('api/transaction-update', { id: id, fields: fields });
+}
+exports.updateTransaction = updateTransaction;
+function deleteTransaction(id) {
+    return send('api/transaction-delete', { id: id });
+}
+exports.deleteTransaction = deleteTransaction;
+function getAccounts() {
+    return send('api/accounts-get');
+}
+exports.getAccounts = getAccounts;
+function createAccount(account, initialBalance) {
+    return send('api/account-create', { account: account, initialBalance: initialBalance });
+}
+exports.createAccount = createAccount;
+function updateAccount(id, fields) {
+    return send('api/account-update', { id: id, fields: fields });
+}
+exports.updateAccount = updateAccount;
+function closeAccount(id, transferAccountId, transferCategoryId) {
+    return send('api/account-close', {
+        id: id,
+        transferAccountId: transferAccountId,
+        transferCategoryId: transferCategoryId,
+    });
+}
+exports.closeAccount = closeAccount;
+function reopenAccount(id) {
+    return send('api/account-reopen', { id: id });
+}
+exports.reopenAccount = reopenAccount;
+function deleteAccount(id) {
+    return send('api/account-delete', { id: id });
+}
+exports.deleteAccount = deleteAccount;
+function createCategoryGroup(group) {
+    return send('api/category-group-create', { group: group });
+}
+exports.createCategoryGroup = createCategoryGroup;
+function updateCategoryGroup(id, fields) {
+    return send('api/category-group-update', { id: id, fields: fields });
+}
+exports.updateCategoryGroup = updateCategoryGroup;
+function deleteCategoryGroup(id, transferCategoryId) {
+    return send('api/category-group-delete', { id: id, transferCategoryId: transferCategoryId });
+}
+exports.deleteCategoryGroup = deleteCategoryGroup;
+function getCategories() {
+    return send('api/categories-get', { grouped: false });
+}
+exports.getCategories = getCategories;
+function createCategory(category) {
+    return send('api/category-create', { category: category });
+}
+exports.createCategory = createCategory;
+function updateCategory(id, fields) {
+    return send('api/category-update', { id: id, fields: fields });
+}
+exports.updateCategory = updateCategory;
+function deleteCategory(id, transferCategoryId) {
+    return send('api/category-delete', { id: id, transferCategoryId: transferCategoryId });
+}
+exports.deleteCategory = deleteCategory;
+function getPayees() {
+    return send('api/payees-get');
+}
+exports.getPayees = getPayees;
+function createPayee(payee) {
+    return send('api/payee-create', { payee: payee });
+}
+exports.createPayee = createPayee;
+function updatePayee(id, fields) {
+    return send('api/payee-update', { id: id, fields: fields });
+}
+exports.updatePayee = updatePayee;
+function deletePayee(id) {
+    return send('api/payee-delete', { id: id });
+}
+exports.deletePayee = deletePayee;

package/dist/migrations/1632571489012_remove_cache.d.ts

@@ -0,0 +1 @@
+export default function runMigration(db: any, uuid: any): Promise<void>;