paytonz-node-api-sdk 1.0.0

package/lib/PaytonzSDK.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaytonzSDK = void 0;
+const auth_1 = require("./auth/auth");
+const checkout_1 = __importDefault(require("./checkout/checkout"));
+const currency_1 = require("./currency/currency");
+const external_1 = __importDefault(require("./external/external"));
+const multisend_1 = require("./multisend/multisend");
+const swap_1 = require("./swap/swap");
+const transaction_1 = __importDefault(require("./transaction/transaction"));
+const wallet_1 = require("./wallet/wallet");
+const withdrawal_1 = require("./withdrawal/withdrawal");
+class PaytonzSDK {
+    /**
+     * @param parameters
+     */
+    constructor(parameters) {
+        this.wallet = new wallet_1.Wallet(parameters);
+        this.currency = new currency_1.Currency(parameters);
+        this.withdrawal = new withdrawal_1.Withdrawal(parameters);
+        this.multisend = new multisend_1.Multisend(parameters);
+        this.checkout = new checkout_1.default(parameters);
+        this.transaction = new transaction_1.default(parameters);
+        this.externalCall = new external_1.default(parameters);
+        this.auth = new auth_1.Auth(parameters);
+        this.swap = new swap_1.Swap(parameters);
+    }
+}
+exports.PaytonzSDK = PaytonzSDK;
+exports.default = PaytonzSDK;

package/lib/PaytonzSDKBase.d.ts

@@ -0,0 +1,30 @@
+import { PaytonzToken } from "./interfaces/paytonz.interface";
+import { Options as HttpOptions } from "./utils/httpClient";
+export interface PaytonzSDKBaseOptions {
+    publicKey?: string;
+    privateKey?: string;
+    walletId?: string;
+    passphrase?: string;
+    errLogger?: (mssage: string, ...arg: any[]) => void;
+    outLogger?: (mssage: string, ...arg: any[]) => void;
+    httpOptions?: HttpOptions;
+    url?: {
+        rest?: string;
+    };
+}
+export declare class PaytonzSDKBase {
+    protected options: Required<PaytonzSDKBaseOptions>;
+    constructor(options?: Partial<PaytonzSDKBaseOptions>);
+    protected setOptions(options?: Partial<PaytonzSDKBaseOptions>): void;
+    protected _request: <T>(path: string, options: HttpOptions) => Promise<T>;
+    protected request: <T>(path: string, options: HttpOptions) => Promise<T>;
+    protected auth_get: <T = any>(path: string, params: Record<string, any>, token: string) => Promise<T>;
+    protected auth_post: <T = any>(path: string, data: Record<string, any>, token: string) => Promise<T>;
+    protected post: <T = any>(path: string, data: Record<string, any>) => Promise<T>;
+    protected auth_delete: <T = any>(path: string, data: Record<string, any>, token: string) => Promise<T>;
+    protected auth_patch: <T = any>(path: string, data: Record<string, any>, token: string) => Promise<T>;
+    protected errLogger: (msg: string, ...arg: any[]) => void;
+    protected outLogger: (msg: string, ...arg: any[]) => void;
+    protected auth(publicKey: string, privateKey: string, walletId?: string, passphrase?: string): Promise<PaytonzToken>;
+    protected getToken(isWallet?: boolean): Promise<string>;
+}

package/lib/PaytonzSDKBase.js

@@ -0,0 +1,198 @@
+"use strict";
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaytonzSDKBase = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const lodash_1 = __importDefault(require("lodash"));
+const constant_1 = require("./constant");
+const httpClient_1 = require("./utils/httpClient");
+dayjs_1.default.extend(utc_1.default);
+const DEFAUTL_HTTP_OPTIONS = {
+    headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36",
+    },
+    timeout: 6000,
+};
+class PaytonzSDKBase {
+    constructor(options) {
+        this.options = {};
+        this._request = (path, options) => {
+            return (0, httpClient_1.request)(path, lodash_1.default.merge({}, this.options.httpOptions, options))
+                .then((data) => {
+                try {
+                    const json = JSON.parse(data);
+                    if (json) {
+                        return json.data || json;
+                    }
+                    else {
+                        this.errLogger(options.method, "-", path, json.data.message);
+                        return Promise.reject(json.data.message);
+                    }
+                }
+                catch (error) {
+                    this.errLogger(options.method, "-", path, "Parse Error", error);
+                    return Promise.reject(error);
+                }
+            })
+                .catch((err) => {
+                this.errLogger(options.method, "-", path, err);
+                return Promise.reject(err);
+            });
+        };
+        this.request = (path, options) => {
+            if (!this.options.url.rest) {
+                return Promise.reject("Rest url is required.");
+            }
+            return this._request(`${this.options.url.rest}${path}`, options);
+        };
+        this.auth_get = (path, params = {}, token) => {
+            if (!this.options.url.rest) {
+                return Promise.reject("Rest url is required.");
+            }
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+                searchParams: params,
+            });
+        };
+        this.auth_post = (path, data, token) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            const { idempotencyKey } = data, payload = __rest(data, ["idempotencyKey"]);
+            const headers = {
+                Authorization: `Bearer ${token}`,
+            };
+            if (idempotencyKey) {
+                headers["idempotency-key"] = idempotencyKey;
+            }
+            return this._request(PATH, {
+                method: "POST",
+                headers,
+                json: payload,
+            });
+        };
+        this.post = (path, data) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "POST",
+                json: data,
+            });
+        };
+        this.auth_delete = (path, data, token) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "DELETE",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+                json: data,
+            });
+        };
+        this.auth_patch = (path, data, token) => {
+            const PATH = `${this.options.url.rest}${path}`;
+            return this._request(PATH, {
+                method: "PATCH",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+                json: data,
+            });
+        };
+        this.errLogger = (msg, ...arg) => {
+            if (typeof this.options.errLogger === "function") {
+                this.options.errLogger(msg, ...arg);
+                return;
+            }
+            const prefix = `[${(0, dayjs_1.default)()
+                .utcOffset(8)
+                .format("YYYY-MM-DD HH:mm:ss")}] [ERROR] `;
+            console.error(`${prefix} ${msg}`, ...arg);
+        };
+        this.outLogger = (msg, ...arg) => {
+            if (typeof this.options.outLogger === "function") {
+                this.options.outLogger(msg, ...arg);
+                return;
+            }
+            const prefix = `[${(0, dayjs_1.default)()
+                .utcOffset(8)
+                .format("YYYY-MM-DD HH:mm:ss")}] [INFO] `;
+            console.log(`${prefix} ${msg}`, ...arg);
+        };
+        if (!options) {
+            return;
+        }
+        this.setOptions(options);
+    }
+    setOptions(options = {}) {
+        const { httpOptions, url } = options, otherOptions = __rest(options, ["httpOptions", "url"]);
+        lodash_1.default.merge(this.options, {
+            httpOptions: lodash_1.default.merge({}, DEFAUTL_HTTP_OPTIONS, httpOptions || {}),
+            url: Object.assign({ rest: constant_1.REST_URL }, (url || {})),
+        });
+        if (otherOptions) {
+            lodash_1.default.merge(this.options, otherOptions);
+        }
+    }
+    auth(publicKey, privateKey, walletId, passphrase) {
+        if (this.options.publicKey && this.options.privateKey) {
+            const path = `/api/public/auth`;
+            let data = {
+                publicKey,
+                privateKey,
+            };
+            if (walletId) {
+                data = Object.assign(data, { walletId });
+                if (!passphrase) {
+                    throw new Error("Passphrase is required.");
+                }
+                data = Object.assign(data, { passphrase });
+            }
+            return this.request(`${path}`, {
+                method: "POST",
+                json: data,
+            });
+        }
+        else {
+            throw new Error("Keys is required.");
+        }
+    }
+    getToken(isWallet = false) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isWallet) {
+                if (!this.options.walletId || !this.options.passphrase) {
+                    throw new Error("WalletId and passphrase is required.");
+                }
+            }
+            const { token } = yield this.auth(this.options.publicKey, this.options.privateKey, (_a = this.options) === null || _a === void 0 ? void 0 : _a.walletId, (_b = this.options) === null || _b === void 0 ? void 0 : _b.passphrase);
+            return token;
+        });
+    }
+}
+exports.PaytonzSDKBase = PaytonzSDKBase;

package/lib/auth/auth.d.ts

@@ -0,0 +1,9 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import { RegisterInfo, RegisterOptions } from "./auth.interface";
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {
+}
+export declare class Auth extends PaytonzSDKBase {
+    constructor(parameters: PaytonzSDKOptions);
+    register(options: RegisterOptions): Promise<RegisterInfo>;
+    login(): Promise<string>;
+}

package/lib/auth/auth.interface.d.ts

@@ -0,0 +1,25 @@
+export interface RegisterOptions {
+    email: string;
+    password: string;
+    inviterId?: string;
+    roles: string[];
+    agent?: string;
+}
+export interface RegisterInfo {
+    wallets: {
+        id: string;
+        address: string;
+        privateKey: string;
+        mnemonic: string;
+        actualBalance: string;
+        systemBalance: string;
+        passphrase: string;
+        nodeType: string;
+    }[];
+    apiKey: {
+        publicKey: string;
+        privateKey: string;
+    };
+    merchantId: string;
+    userId: string;
+}

package/lib/auth/auth.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/auth/auth.js

@@ -0,0 +1,37 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth = void 0;
+const PaytonzSDKBase_1 = require("../PaytonzSDKBase");
+class Auth extends PaytonzSDKBase_1.PaytonzSDKBase {
+    constructor(parameters) {
+        super(parameters);
+    }
+    register(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const path = `/api/public/auth/register`;
+                return this.post(`${path}`, Object.assign({}, options));
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    login() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { token } = yield this.auth(this.options.publicKey, this.options.privateKey, (_a = this.options) === null || _a === void 0 ? void 0 : _a.walletId, (_b = this.options) === null || _b === void 0 ? void 0 : _b.passphrase);
+            return token;
+        });
+    }
+}
+exports.Auth = Auth;

package/lib/checkout/checkout.d.ts

@@ -0,0 +1,24 @@
+import { PaytonzSDKBase, PaytonzSDKBaseOptions } from "../PaytonzSDKBase";
+import { BasePaginationOptions } from "../interfaces/paytonz.interface";
+import { CheckoutChargeListInfo, CheckoutInfo, CheckoutListInfo, CreateCartOptions, CreateDonationOptions, CreateSaleOptions, CreateSaleTokenOptions, SaleTokenEstimateMaxOptions, UpdateCartOptions, UpdateDonationOptions, UpdateSaleOptions, UpdateSaleTokenOptions } from "./checkout.interface";
+export interface PaytonzSDKOptions extends PaytonzSDKBaseOptions {
+}
+export declare class Checkout extends PaytonzSDKBase {
+    constructor(parameters: PaytonzSDKOptions);
+    list(options: BasePaginationOptions, accessToken?: string): Promise<CheckoutListInfo>;
+    info(checkoutId: string, accessToken?: string): Promise<CheckoutInfo>;
+    remove(checkoutId: string, accessToken?: string): Promise<boolean>;
+    createDonation(options: CreateDonationOptions, accessToken?: string): Promise<CheckoutInfo>;
+    createSale(options: CreateSaleOptions, accessToken?: string): Promise<CheckoutInfo>;
+    createSaleToken(options: CreateSaleTokenOptions, accessToken?: string): Promise<CheckoutInfo>;
+    createCart(options: CreateCartOptions, accessToken?: string): Promise<CheckoutInfo>;
+    saleTokenEstimateMax(options: SaleTokenEstimateMaxOptions, accessToken?: string): Promise<{
+        max: string;
+    }>;
+    updateDonation(checkoutId: string, options: UpdateDonationOptions, accessToken?: string): Promise<CheckoutInfo>;
+    updateSale(checkoutId: string, options: UpdateSaleOptions, accessToken?: string): Promise<CheckoutInfo>;
+    updateSaleToken(checkoutId: string, options: UpdateSaleTokenOptions, accessToken?: string): Promise<CheckoutInfo>;
+    updateCart(checkoutId: string, options: UpdateCartOptions, accessToken?: string): Promise<CheckoutInfo>;
+    chargeList(checkoutId: string, options?: BasePaginationOptions, accessToken?: string): Promise<CheckoutChargeListInfo>;
+}
+export default Checkout;

package/lib/checkout/checkout.interface.d.ts

@@ -0,0 +1,94 @@
+export interface CheckoutInfo {
+    _id: string;
+    identifier: string;
+    currencies: string[];
+    createdAt: string;
+    updatedAt: string;
+    organizationName?: string;
+    type: string;
+    merchant: string;
+    expireTime: number;
+    description: string;
+    collectName: boolean;
+    collectEmail: boolean;
+    fiatCurrency?: string;
+    price?: string;
+    productName?: string;
+    fixed?: boolean;
+    max?: string;
+    min?: string;
+    tradedCurrency?: string;
+    tradedWallet?: string;
+    accentColor?: string;
+    backgroundColor?: string;
+    logoImage?: string;
+    image?: string;
+    metadata?: Record<string, any>;
+}
+export interface CheckoutListInfo {
+    entities: CheckoutInfo[];
+    page: number;
+    pages: number;
+    countItem: number;
+}
+export interface CheckoutChargeListInfo {
+    entities: {
+        id: boolean;
+        systemStatus: string;
+        createdAt: string;
+    }[];
+    page: number;
+    pages: number;
+    countItem: number;
+}
+export interface CreateCheckoutBaseOptions {
+    expireTime: number;
+    currencies: string[];
+    collectName?: boolean;
+    collectEmail?: boolean;
+    description: string;
+    linkImage?: string;
+    linkLogoImage?: string;
+    metadata?: Record<string, any>;
+    accentColor?: string;
+    backgroundColor?: string;
+}
+export interface UpdateCheckoutBaseOptions {
+    deleteImage?: boolean;
+    deleteLogoImage?: boolean;
+}
+export interface CreateDonationOptions extends CreateCheckoutBaseOptions {
+    organizationName: string;
+}
+export interface UpdateDonationOptions extends CreateDonationOptions, UpdateCheckoutBaseOptions {
+}
+export interface CreateSaleOptions extends CreateCheckoutBaseOptions {
+    productName: string;
+    price: string;
+    fiatCurrency: string;
+}
+export interface UpdateSaleOptions extends CreateSaleOptions, UpdateCheckoutBaseOptions {
+}
+export interface CreateCartOptions extends CreateCheckoutBaseOptions {
+    cartName: string;
+    fiatCurrency: string;
+}
+export interface UpdateCartOptions extends CreateCartOptions, UpdateCheckoutBaseOptions {
+}
+export interface CreateSaleTokenOptions extends CreateCheckoutBaseOptions {
+    productName: string;
+    price?: string;
+    min: string;
+    max: string;
+    fiatCurrency?: string;
+    fixed: string;
+    tradedCurrency: string;
+    tradedWallet: string;
+}
+export interface UpdateSaleTokenOptions extends CreateSaleTokenOptions, UpdateCheckoutBaseOptions {
+}
+export interface SaleTokenEstimateMaxOptions {
+    tradedWallet: string;
+    tradedCurrency: string;
+    checkoutId?: string;
+}

package/lib/checkout/checkout.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/checkout/checkout.js

@@ -0,0 +1,215 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Checkout = void 0;
+const PaytonzSDKBase_1 = require("../PaytonzSDKBase");
+class Checkout extends PaytonzSDKBase_1.PaytonzSDKBase {
+    constructor(parameters) {
+        super(parameters);
+    }
+    list(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout`;
+                return this.auth_get(`${path}`, Object.assign({}, options), accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    info(checkoutId, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/${checkoutId}`;
+                return this.auth_get(`${path}`, {}, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    remove(checkoutId, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/${checkoutId}`;
+                return this.auth_delete(`${path}`, {}, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    createDonation(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/donation`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    createSale(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/sale`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    createSaleToken(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/saleToken`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    createCart(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/cart`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    saleTokenEstimateMax(options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/saleToken/estimateMax`;
+                return this.auth_post(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    updateDonation(checkoutId, options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/${checkoutId}/donation`;
+                return this.auth_patch(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    updateSale(checkoutId, options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/${checkoutId}/sale`;
+                return this.auth_patch(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    updateSaleToken(checkoutId, options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/${checkoutId}/saleToken`;
+                return this.auth_patch(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    updateCart(checkoutId, options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/${checkoutId}/cart`;
+                return this.auth_patch(`${path}`, options, accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    chargeList(checkoutId, options, accessToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!accessToken) {
+                    const { token } = yield this.auth(this.options.publicKey, this.options.privateKey);
+                    accessToken = token;
+                }
+                const path = `/api/public/checkout/${checkoutId}/charge-list`;
+                return this.auth_get(`${path}`, Object.assign({}, options), accessToken);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+}
+exports.Checkout = Checkout;
+exports.default = Checkout;