@internxt/sdk 1.4.76

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Internxt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# Getting Started
+
+## Installation
+
+- Create a `.npmrc` file from the `.npmrc.template` example provided in the repo.
+- Replace `TOKEN` with your own [Github Personal Access Token](https://docs.github.com/en/github/authenticating-to-github/keeping-your-account-and-data-secure/creating-a-personal-access-token) with `read:packages` permission **ONLY**
+- Use `yarn` to install project dependencies.

package/dist/auth/index.d.ts

@@ -0,0 +1,81 @@
+import { Token, CryptoProvider, Keys, LoginDetails, RegisterDetails, SecurityDetails, TwoFactorAuthQR } from './types';
+import { UserSettings, UUID } from '../shared/types/userSettings';
+import { TeamsSettings } from '../shared/types/teams';
+import { ApiSecurity, ApiUrl, AppDetails } from '../shared';
+export * from './types';
+export declare class Auth {
+    private readonly client;
+    private readonly appDetails;
+    private readonly apiSecurity?;
+    private readonly apiUrl;
+    static client(apiUrl: ApiUrl, appDetails: AppDetails, apiSecurity?: ApiSecurity): Auth;
+    private constructor();
+    /**
+     * Tries to register a new user
+     * @param registerDetails
+     */
+    register(registerDetails: RegisterDetails): Promise<{
+        token: Token;
+        user: Omit<UserSettings, 'bucket'> & {
+            referralCode: string;
+        };
+        uuid: UUID;
+    }>;
+    /**
+     * Tries to log in a user given its login details
+     * @param details
+     * @param cryptoProvider
+     */
+    login(details: LoginDetails, cryptoProvider: CryptoProvider): Promise<{
+        token: Token;
+        newToken: Token;
+        user: UserSettings;
+        userTeam: TeamsSettings | null;
+    }>;
+    /**
+     * Updates the asymmetric keys
+     * @param keys
+     * @param token
+     */
+    updateKeys(keys: Keys, token: Token): Promise<unknown>;
+    /**
+     * Returns general security details
+     * @param email
+     */
+    securityDetails(email: string): Promise<SecurityDetails>;
+    /**
+     * Generates a new TwoFactorAuth code
+     */
+    generateTwoFactorAuthQR(): Promise<TwoFactorAuthQR>;
+    /**
+     * Disables TwoFactorAuthentication
+     * @param pass
+     * @param code
+     */
+    disableTwoFactorAuth(pass: string, code: string): Promise<void>;
+    /**
+     * Store TwoFactorAuthentication details
+     * @param backupKey
+     * @param code
+     */
+    storeTwoFactorAuthKey(backupKey: string, code: string): Promise<void>;
+    /**
+     * Sends request to send the email to delete the account
+     * @param email
+     */
+    sendDeactivationEmail(email: string): Promise<void>;
+    /**
+     * Confirms the account deactivation
+     * @param token
+     */
+    confirmDeactivation(token: string): Promise<void>;
+    /**
+     * Checks if the password is correct for this email
+     * @param email
+     * @param hashedPassword
+     * @returns
+     */
+    areCredentialsCorrect(email: string, hashedPassword: string): Promise<boolean>;
+    private basicHeaders;
+    private headersWithToken;
+}

package/dist/auth/index.js

@@ -0,0 +1,233 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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 (_) 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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth = void 0;
+var types_1 = require("./types");
+var headers_1 = require("../shared/headers");
+var client_1 = require("../shared/http/client");
+__exportStar(require("./types"), exports);
+var Auth = /** @class */ (function () {
+    function Auth(apiUrl, appDetails, apiSecurity) {
+        this.client = client_1.HttpClient.create(apiUrl, apiSecurity === null || apiSecurity === void 0 ? void 0 : apiSecurity.unauthorizedCallback);
+        this.appDetails = appDetails;
+        this.apiSecurity = apiSecurity;
+        this.apiUrl = apiUrl;
+    }
+    Auth.client = function (apiUrl, appDetails, apiSecurity) {
+        return new Auth(apiUrl, appDetails, apiSecurity);
+    };
+    /**
+     * Tries to register a new user
+     * @param registerDetails
+     */
+    Auth.prototype.register = function (registerDetails) {
+        return this.client.post('/users', {
+            name: registerDetails.name,
+            captcha: registerDetails.captcha,
+            lastname: registerDetails.lastname,
+            email: registerDetails.email,
+            password: registerDetails.password,
+            mnemonic: registerDetails.mnemonic,
+            salt: registerDetails.salt,
+            privateKey: registerDetails.keys.privateKeyEncrypted,
+            publicKey: registerDetails.keys.publicKey,
+            revocationKey: registerDetails.keys.revocationCertificate,
+            referral: registerDetails.referral,
+            referrer: registerDetails.referrer,
+        }, this.basicHeaders());
+    };
+    /**
+     * Tries to log in a user given its login details
+     * @param details
+     * @param cryptoProvider
+     */
+    Auth.prototype.login = function (details, cryptoProvider) {
+        return __awaiter(this, void 0, void 0, function () {
+            var securityDetails, encryptedSalt, encryptedPasswordHash, keys;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.securityDetails(details.email)];
+                    case 1:
+                        securityDetails = _a.sent();
+                        encryptedSalt = securityDetails.encryptedSalt;
+                        encryptedPasswordHash = cryptoProvider.encryptPasswordHash(details.password, encryptedSalt);
+                        return [4 /*yield*/, cryptoProvider.generateKeys(details.password)];
+                    case 2:
+                        keys = _a.sent();
+                        return [2 /*return*/, this.client
+                                .post('/access', {
+                                email: details.email,
+                                password: encryptedPasswordHash,
+                                tfa: details.tfaCode,
+                                privateKey: keys.privateKeyEncrypted,
+                                publicKey: keys.publicKey,
+                                revocateKey: keys.revocationCertificate,
+                            }, this.basicHeaders())
+                                .then(function (data) {
+                                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                                // @ts-ignore
+                                data.user.revocationKey = data.user.revocateKey; // TODO : remove when all projects use SDK
+                                return data;
+                            })
+                                .catch(function (error) {
+                                throw new types_1.UserAccessError(error.message);
+                            })];
+                }
+            });
+        });
+    };
+    /**
+     * Updates the asymmetric keys
+     * @param keys
+     * @param token
+     */
+    Auth.prototype.updateKeys = function (keys, token) {
+        return this.client.patch('/user/keys', {
+            publicKey: keys.publicKey,
+            privateKey: keys.privateKeyEncrypted,
+            revocationKey: keys.revocationCertificate,
+        }, this.headersWithToken(token));
+    };
+    /**
+     * Returns general security details
+     * @param email
+     */
+    Auth.prototype.securityDetails = function (email) {
+        return this.client
+            .post('/login', {
+            email: email,
+        }, this.basicHeaders())
+            .then(function (data) {
+            return {
+                encryptedSalt: data.sKey,
+                tfaEnabled: data.tfa === true,
+            };
+        });
+    };
+    /**
+     * Generates a new TwoFactorAuth code
+     */
+    Auth.prototype.generateTwoFactorAuthQR = function () {
+        var _a;
+        return this.client
+            .get('/tfa', this.headersWithToken((_a = this.apiSecurity) === null || _a === void 0 ? void 0 : _a.token))
+            .then(function (data) {
+            return {
+                qr: data.qr,
+                backupKey: data.code,
+            };
+        });
+    };
+    /**
+     * Disables TwoFactorAuthentication
+     * @param pass
+     * @param code
+     */
+    Auth.prototype.disableTwoFactorAuth = function (pass, code) {
+        var _a;
+        return this.client.delete('/tfa', this.headersWithToken((_a = this.apiSecurity) === null || _a === void 0 ? void 0 : _a.token), {
+            pass: pass,
+            code: code,
+        });
+    };
+    /**
+     * Store TwoFactorAuthentication details
+     * @param backupKey
+     * @param code
+     */
+    Auth.prototype.storeTwoFactorAuthKey = function (backupKey, code) {
+        var _a;
+        return this.client.put('/tfa', {
+            key: backupKey,
+            code: code,
+        }, this.headersWithToken((_a = this.apiSecurity) === null || _a === void 0 ? void 0 : _a.token));
+    };
+    /**
+     * Sends request to send the email to delete the account
+     * @param email
+     */
+    Auth.prototype.sendDeactivationEmail = function (email) {
+        return this.client.get("/deactivate/" + email, this.basicHeaders());
+    };
+    /**
+     * Confirms the account deactivation
+     * @param token
+     */
+    Auth.prototype.confirmDeactivation = function (token) {
+        return this.client.get("/confirmDeactivation/" + token, this.basicHeaders());
+    };
+    /**
+     * Checks if the password is correct for this email
+     * @param email
+     * @param hashedPassword
+     * @returns
+     */
+    Auth.prototype.areCredentialsCorrect = function (email, hashedPassword) {
+        var _a;
+        // Uses fetch instead of httpClient since a 401 response
+        // would log out the user
+        return fetch(this.apiUrl + "/are-credentials-correct?email=" + email + "&hashedPassword=" + hashedPassword, { headers: this.headersWithToken((_a = this.apiSecurity) === null || _a === void 0 ? void 0 : _a.token) }).then(function (res) {
+            if (res.ok) {
+                return true;
+            }
+            else if (res.status === 401) {
+                return false;
+            }
+            else
+                throw new Error("Request failed with error " + res.status);
+        });
+    };
+    Auth.prototype.basicHeaders = function () {
+        return (0, headers_1.basicHeaders)(this.appDetails.clientName, this.appDetails.clientVersion);
+    };
+    Auth.prototype.headersWithToken = function (token) {
+        return (0, headers_1.headersWithToken)(this.appDetails.clientName, this.appDetails.clientVersion, token);
+    };
+    return Auth;
+}());
+exports.Auth = Auth;

package/dist/auth/types.d.ts

@@ -0,0 +1,43 @@
+export declare type Password = string;
+export declare type Email = string;
+export declare type Token = string;
+export interface LoginDetails {
+    email: Email;
+    password: Password;
+    tfaCode: string | undefined;
+}
+export interface RegisterDetails {
+    name: string;
+    lastname: string;
+    email: Email;
+    password: Password;
+    mnemonic: string;
+    salt: string;
+    keys: Keys;
+    captcha: string;
+    referrer?: string;
+    referral?: string;
+}
+export interface Keys {
+    privateKeyEncrypted: string;
+    publicKey: string;
+    revocationCertificate: string;
+}
+export interface CryptoProvider {
+    encryptPasswordHash: (password: Password, encryptedSalt: string) => string;
+    generateKeys: (password: Password) => Promise<Keys>;
+}
+export declare class UserAccessError extends Error {
+}
+export interface SecurityDetails {
+    encryptedSalt: string;
+    tfaEnabled: boolean;
+}
+export interface TwoFactorAuthQR {
+    qr: string;
+    backupKey: string;
+}
+export interface BasicAuth {
+    username: string;
+    password: string;
+}

package/dist/auth/types.js

@@ -0,0 +1,26 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAccessError = void 0;
+var UserAccessError = /** @class */ (function (_super) {
+    __extends(UserAccessError, _super);
+    function UserAccessError() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return UserAccessError;
+}(Error));
+exports.UserAccessError = UserAccessError;

package/dist/drive/backups/index.d.ts

@@ -0,0 +1,18 @@
+import { ApiSecurity, ApiUrl, AppDetails } from '../../shared';
+import { Device, DeviceBackup } from './types';
+export declare class Backups {
+    private readonly client;
+    private readonly appDetails;
+    private readonly apiSecurity;
+    static client(apiUrl: ApiUrl, appDetails: AppDetails, apiSecurity: ApiSecurity): Backups;
+    private constructor();
+    getAllDevices(): Promise<Device[]>;
+    getAllBackups(mac: string): Promise<DeviceBackup[]>;
+    deleteBackup(backupId: number): Promise<void>;
+    deleteDevice(deviceId: number): Promise<void>;
+    /**
+     * Returns the needed headers for the module requests
+     * @private
+     */
+    private headers;
+}

package/dist/drive/backups/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Backups = void 0;
+var client_1 = require("../../shared/http/client");
+var headers_1 = require("../../shared/headers");
+var Backups = /** @class */ (function () {
+    function Backups(apiUrl, appDetails, apiSecurity) {
+        this.client = client_1.HttpClient.create(apiUrl, apiSecurity.unauthorizedCallback);
+        this.appDetails = appDetails;
+        this.apiSecurity = apiSecurity;
+    }
+    Backups.client = function (apiUrl, appDetails, apiSecurity) {
+        return new Backups(apiUrl, appDetails, apiSecurity);
+    };
+    Backups.prototype.getAllDevices = function () {
+        return this.client
+            .get('/backup/device', this.headers());
+    };
+    Backups.prototype.getAllBackups = function (mac) {
+        return this.client
+            .get("/backup/" + mac, this.headers());
+    };
+    Backups.prototype.deleteBackup = function (backupId) {
+        return this.client
+            .delete("/backup/" + backupId, this.headers());
+    };
+    Backups.prototype.deleteDevice = function (deviceId) {
+        return this.client
+            .delete("/backup/device/" + deviceId, this.headers());
+    };
+    /**
+     * Returns the needed headers for the module requests
+     * @private
+     */
+    Backups.prototype.headers = function () {
+        return (0, headers_1.headersWithToken)(this.appDetails.clientName, this.appDetails.clientVersion, this.apiSecurity.token);
+    };
+    return Backups;
+}());
+exports.Backups = Backups;

package/dist/drive/backups/types.d.ts

@@ -0,0 +1,27 @@
+export interface Device {
+    id: number;
+    name: string;
+    mac: string;
+    userId: number;
+    createdAt: string;
+    updatedAt: string;
+    size: number;
+    platform: string | null;
+}
+export interface DeviceBackup {
+    id: number;
+    path: string;
+    name: string;
+    fileId?: string;
+    deviceId: number;
+    userId: number;
+    interval: number;
+    size?: number;
+    bucket: string;
+    createdAt: string;
+    updatedAt: string;
+    encrypt_version: string;
+    hash?: string;
+    enabled: boolean;
+    lastBackupAt?: string;
+}

package/dist/drive/backups/types.js

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

package/dist/drive/index.d.ts

@@ -0,0 +1,7 @@
+export * from './storage';
+export * from './share';
+export * from './users';
+export * from './referrals';
+export * from './payments';
+export * from './backups';
+export * from './trash';

package/dist/drive/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./storage"), exports);
+__exportStar(require("./share"), exports);
+__exportStar(require("./users"), exports);
+__exportStar(require("./referrals"), exports);
+__exportStar(require("./payments"), exports);
+__exportStar(require("./backups"), exports);
+__exportStar(require("./trash"), exports);

package/dist/drive/payments/index.d.ts

@@ -0,0 +1,40 @@
+import { ApiSecurity, ApiUrl, AppDetails } from '../../shared';
+import { CreateCheckoutSessionPayload, CreatePaymentSessionPayload, DisplayPrice, Invoice, PaymentMethod, ProductData, UserSubscription } from './types';
+export declare class Payments {
+    private readonly client;
+    private readonly appDetails;
+    private readonly apiSecurity;
+    static client(apiUrl: ApiUrl, appDetails: AppDetails, apiSecurity: ApiSecurity): Payments;
+    private constructor();
+    /**
+     * Fetches the existing products and its details
+     */
+    getProducts(): Promise<ProductData[]>;
+    /**
+     * Creates and returns a new session identifier for the client to go to payment platform
+     * @param payload
+     */
+    createSession(payload: CreatePaymentSessionPayload): Promise<{
+        id: string;
+    }>;
+    getSetupIntent(): Promise<{
+        clientSecret: string;
+    }>;
+    getDefaultPaymentMethod(): Promise<PaymentMethod>;
+    getInvoices({ startingAfter, limit }: {
+        startingAfter?: string;
+        limit?: number;
+    }): Promise<Invoice[]>;
+    getUserSubscription(): Promise<UserSubscription>;
+    getPrices(): Promise<DisplayPrice[]>;
+    updateSubscriptionPrice(priceId: string): Promise<UserSubscription>;
+    cancelSubscription(): Promise<void>;
+    createCheckoutSession(payload: CreateCheckoutSessionPayload): Promise<{
+        sessionId: string;
+    }>;
+    /**
+     * Returns the needed headers for the module requests
+     * @private
+     */
+    private headers;
+}

package/dist/drive/payments/index.js

@@ -0,0 +1,91 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Payments = void 0;
+var headers_1 = require("../../shared/headers");
+var client_1 = require("../../shared/http/client");
+var Payments = /** @class */ (function () {
+    function Payments(apiUrl, appDetails, apiSecurity) {
+        this.client = client_1.HttpClient.create(apiUrl, apiSecurity.unauthorizedCallback);
+        this.appDetails = appDetails;
+        this.apiSecurity = apiSecurity;
+    }
+    Payments.client = function (apiUrl, appDetails, apiSecurity) {
+        return new Payments(apiUrl, appDetails, apiSecurity);
+    };
+    /**
+     * Fetches the existing products and its details
+     */
+    Payments.prototype.getProducts = function () {
+        return this.client.get('/v3/stripe/products', this.headers());
+    };
+    /**
+     * Creates and returns a new session identifier for the client to go to payment platform
+     * @param payload
+     */
+    Payments.prototype.createSession = function (payload) {
+        return this.client.post('/v2/stripe/session', {
+            test: payload.test,
+            lifetime_tier: payload.lifetime_tier,
+            mode: payload.mode,
+            priceId: payload.priceId,
+            successUrl: payload.successUrl,
+            canceledUrl: payload.canceledUrl,
+        }, this.headers());
+    };
+    Payments.prototype.getSetupIntent = function () {
+        return this.client.get('/setup-intent', this.headers());
+    };
+    Payments.prototype.getDefaultPaymentMethod = function () {
+        return this.client.get('/default-payment-method', this.headers());
+    };
+    Payments.prototype.getInvoices = function (_a) {
+        var startingAfter = _a.startingAfter, limit = _a.limit;
+        var query = new URLSearchParams();
+        if (startingAfter !== undefined)
+            query.set('starting_after', startingAfter);
+        if (limit !== undefined)
+            query.set('limit', limit.toString());
+        return this.client.get("/invoices?" + query.toString(), this.headers());
+    };
+    Payments.prototype.getUserSubscription = function () {
+        return this.client.get('/subscriptions', this.headers()).catch(function (err) {
+            var error = err;
+            if (error.status === 404)
+                return { type: 'free' };
+            else
+                throw err;
+        });
+    };
+    Payments.prototype.getPrices = function () {
+        return this.client.get('/prices', this.headers());
+    };
+    Payments.prototype.updateSubscriptionPrice = function (priceId) {
+        return this.client.put('/subscriptions', { price_id: priceId }, this.headers());
+    };
+    Payments.prototype.cancelSubscription = function () {
+        return this.client.delete('/subscriptions', this.headers());
+    };
+    Payments.prototype.createCheckoutSession = function (payload) {
+        return this.client.post('/checkout-session', __assign({}, payload), this.headers());
+    };
+    /**
+     * Returns the needed headers for the module requests
+     * @private
+     */
+    Payments.prototype.headers = function () {
+        return (0, headers_1.headersWithToken)(this.appDetails.clientName, this.appDetails.clientVersion, this.apiSecurity.token);
+    };
+    return Payments;
+}());
+exports.Payments = Payments;