@internxt/sdk 1.9.12 → 1.9.14

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

@@ -1,5 +1,6 @@
 import { ApiSecurity, ApiUrl, AppDetails } from '../../shared';
-import { AvailableProducts, CreateCheckoutSessionPayload, CreatedSubscriptionData, CreatePaymentSessionPayload, CustomerBillingInfo, DisplayPrice, FreeTrialAvailable, Invoice, InvoicePayload, PaymentMethod, ProductData, RedeemCodePayload, UpdateSubscriptionPaymentMethod, UserSubscription, UserType } from './types';
+import { Tier } from './types/tiers';
+import { AvailableProducts, CreateCheckoutSessionPayload, CreatedSubscriptionData, CreatePaymentSessionPayload, CustomerBillingInfo, DisplayPrice, FreeTrialAvailable, Invoice, InvoicePayload, PaymentMethod, ProductData, RedeemCodePayload, UpdateSubscriptionPaymentMethod, UserSubscription, UserType } from './types/types';
 export declare class Payments {
     private readonly client;
     private readonly appDetails;
@@ -63,6 +64,23 @@ export declare class Payments {
      * @returns an object containing available products
      */
     checkUserAvailableProducts(): Promise<AvailableProducts>;
+    /**
+     * Gets product information based on the user's subscription tier.
+     *
+     * @param {UserType} [userType] - The type of user for which to query product information.
+     *                               If not specified, UserType.Individual will be used by default.
+     * @returns {Promise<Tier>} A promise that resolves with the product information
+     *                         available for the specified tier.
+     *
+     * @example
+     * // Get products for an individual user tier (default)
+     * const individualProducts = await getUserTier();
+     *
+     * @example
+     * // Get products for a business user tier
+     * const businessProducts = await getUserTier(UserType.Business);
+     */
+    getUserTier(userType?: UserType): Promise<Tier>;
     /**
      * Returns the needed headers for the module requests
      * @private

package/dist/drive/payments/index.js

@@ -50,7 +50,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Payments = void 0;
 var headers_1 = require("../../shared/headers");
 var client_1 = require("../../shared/http/client");
-var types_1 = require("./types");
+var types_1 = require("./types/types");
 var Payments = /** @class */ (function () {
     function Payments(apiUrl, appDetails, apiSecurity) {
         this.client = client_1.HttpClient.create(apiUrl, apiSecurity.unauthorizedCallback);
@@ -204,6 +204,28 @@ var Payments = /** @class */ (function () {
     Payments.prototype.checkUserAvailableProducts = function () {
         return this.client.get('/products', this.headers());
     };
+    /**
+     * Gets product information based on the user's subscription tier.
+     *
+     * @param {UserType} [userType] - The type of user for which to query product information.
+     *                               If not specified, UserType.Individual will be used by default.
+     * @returns {Promise<Tier>} A promise that resolves with the product information
+     *                         available for the specified tier.
+     *
+     * @example
+     * // Get products for an individual user tier (default)
+     * const individualProducts = await getUserTier();
+     *
+     * @example
+     * // Get products for a business user tier
+     * const businessProducts = await getUserTier(UserType.Business);
+     */
+    Payments.prototype.getUserTier = function (userType) {
+        var query = new URLSearchParams();
+        if (userType !== undefined)
+            query.set('tierType', userType);
+        return this.client.get("/products/tier?".concat(query.toString()), this.headers());
+    };
     /**
      * Returns the needed headers for the module requests
      * @private

package/dist/drive/payments/object-storage.d.ts

@@ -1,5 +1,5 @@
 import { ApiUrl, AppDetails } from '../../shared';
-import { CreatedSubscriptionData } from './types';
+import { CreatedSubscriptionData } from './types/types';
 interface ObjectStoragePlan {
     id: string;
     bytes: number;

package/dist/drive/payments/types/tiers.d.ts

@@ -0,0 +1,51 @@
+interface AntivirusFeatures {
+    enabled: boolean;
+}
+interface BackupsFeatures {
+    enabled: boolean;
+}
+export interface DriveFeatures {
+    enabled: boolean;
+    maxSpaceBytes: number;
+    workspaces: {
+        enabled: boolean;
+        minimumSeats: number;
+        maximumSeats: number;
+        maxSpaceBytesPerSeat: number;
+    };
+}
+interface MeetFeatures {
+    enabled: boolean;
+    paxPerCall: number;
+}
+interface MailFeatures {
+    enabled: boolean;
+    addressesPerUser: number;
+}
+export interface VpnFeatures {
+    enabled: boolean;
+    featureId: string;
+}
+export declare enum Service {
+    Drive = "drive",
+    Backups = "backups",
+    Antivirus = "antivirus",
+    Meet = "meet",
+    Mail = "mail",
+    Vpn = "vpn"
+}
+export interface Tier {
+    id: string;
+    label: string;
+    productId: string;
+    billingType: 'subscription' | 'lifetime';
+    featuresPerService: {
+        [Service.Drive]: DriveFeatures;
+        [Service.Backups]: BackupsFeatures;
+        [Service.Antivirus]: AntivirusFeatures;
+        [Service.Meet]: MeetFeatures;
+        [Service.Mail]: MailFeatures;
+        [Service.Vpn]: VpnFeatures;
+    };
+}
+export {};

package/dist/drive/payments/types/tiers.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+var Service;
+(function (Service) {
+    Service["Drive"] = "drive";
+    Service["Backups"] = "backups";
+    Service["Antivirus"] = "antivirus";
+    Service["Meet"] = "meet";
+    Service["Mail"] = "mail";
+    Service["Vpn"] = "vpn";
+})(Service = exports.Service || (exports.Service = {}));

package/dist/drive/payments/{types.d.ts → types/types.d.ts}

@@ -1,4 +1,4 @@
-import { AppSumoDetails } from './../../shared/types/appsumo';
+import { AppSumoDetails } from '../../../shared/types/appsumo';
 export interface ProductData {
     id: string;
     name: string;

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * as Network from './network';
 export * as photos from './photos';
 export * as Shared from './shared';
 export * as Workspaces from './workspaces';
+export * from './meet';

package/dist/index.js

@@ -33,3 +33,4 @@ exports.Network = __importStar(require("./network"));
 exports.photos = __importStar(require("./photos"));
 exports.Shared = __importStar(require("./shared"));
 exports.Workspaces = __importStar(require("./workspaces"));
+__exportStar(require("./meet"), exports);

package/dist/meet/index.d.ts

@@ -0,0 +1,15 @@
+import { ApiSecurity, ApiUrl, AppDetails } from '../shared';
+import { CreateCallResponse, JoinCallPayload, JoinCallResponse, UsersInCallResponse } from './types';
+export declare class Meet {
+    private readonly client;
+    private readonly appDetails;
+    private readonly apiSecurity?;
+    private constructor();
+    static client(apiUrl: ApiUrl, appDetails: AppDetails, apiSecurity?: ApiSecurity): Meet;
+    createCall(): Promise<CreateCallResponse>;
+    joinCall(callId: string, payload: JoinCallPayload): Promise<JoinCallResponse>;
+    leaveCall(callId: string): Promise<void>;
+    getCurrentUsersInCall(callId: string): Promise<UsersInCallResponse[]>;
+    private headersWithToken;
+    private basicHeaders;
+}

package/dist/meet/index.js

@@ -0,0 +1,111 @@
+"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 __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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Meet = void 0;
+var headers_1 = require("../shared/headers");
+var client_1 = require("../shared/http/client");
+var Meet = /** @class */ (function () {
+    function Meet(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;
+    }
+    Meet.client = function (apiUrl, appDetails, apiSecurity) {
+        return new Meet(apiUrl, appDetails, apiSecurity);
+    };
+    Meet.prototype.createCall = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.post('call', {}, this.headersWithToken())];
+            });
+        });
+    };
+    Meet.prototype.joinCall = function (callId, payload) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_b) {
+                headers = ((_a = this.apiSecurity) === null || _a === void 0 ? void 0 : _a.token) ? this.headersWithToken() : this.basicHeaders();
+                return [2 /*return*/, this.client.post("call/".concat(callId, "/users/join"), __assign({}, payload), headers)];
+            });
+        });
+    };
+    Meet.prototype.leaveCall = function (callId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_b) {
+                headers = ((_a = this.apiSecurity) === null || _a === void 0 ? void 0 : _a.token) ? this.headersWithToken() : this.basicHeaders();
+                return [2 /*return*/, this.client.post("call/".concat(callId, "/users/leave"), {}, headers)];
+            });
+        });
+    };
+    Meet.prototype.getCurrentUsersInCall = function (callId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_b) {
+                headers = ((_a = this.apiSecurity) === null || _a === void 0 ? void 0 : _a.token) ? this.headersWithToken() : this.basicHeaders();
+                return [2 /*return*/, this.client.get("call/".concat(callId, "/users"), headers)];
+            });
+        });
+    };
+    Meet.prototype.headersWithToken = function () {
+        var _a;
+        if (!((_a = this.apiSecurity) === null || _a === void 0 ? void 0 : _a.token)) {
+            throw new Error('Token is required for Meet operations');
+        }
+        return (0, headers_1.headersWithToken)(this.appDetails.clientName, this.appDetails.clientVersion, this.apiSecurity.token);
+    };
+    Meet.prototype.basicHeaders = function () {
+        return (0, headers_1.basicHeaders)(this.appDetails.clientName, this.appDetails.clientVersion);
+    };
+    return Meet;
+}());
+exports.Meet = Meet;

package/dist/meet/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/meet/index.test.js

@@ -0,0 +1,265 @@
+"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 __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 });
+var sinon_1 = __importDefault(require("sinon"));
+var headers_1 = require("../shared/headers");
+var client_1 = require("../shared/http/client");
+var index_1 = require("./index");
+var httpClient = client_1.HttpClient.create('');
+describe('Meet service tests', function () {
+    beforeEach(function () {
+        sinon_1.default.stub(client_1.HttpClient, 'create').returns(httpClient);
+    });
+    afterEach(function () {
+        sinon_1.default.restore();
+    });
+    describe('createCall method', function () {
+        it('should successfully create a call with token', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var expectedResponse, _a, client, headers, postCall, response;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        expectedResponse = {
+                            token: 'call-token',
+                            room: 'room-id',
+                            paxPerCall: 10,
+                        };
+                        _a = clientAndHeadersWithToken(), client = _a.client, headers = _a.headers;
+                        postCall = sinon_1.default.stub(httpClient, 'post').resolves(expectedResponse);
+                        return [4 /*yield*/, client.createCall()];
+                    case 1:
+                        response = _b.sent();
+                        // Assert
+                        expect(postCall.firstCall.args).toEqual(['call', {}, headers]);
+                        expect(response).toEqual(expectedResponse);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should throw an error when token is missing', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var client;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        client = clientAndHeadersWithoutToken().client;
+                        // Act & Assert
+                        return [4 /*yield*/, expect(client.createCall()).rejects.toThrow('Token is required for Meet operations')];
+                    case 1:
+                        // Act & Assert
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('joinCall method', function () {
+        var callId = 'call-123';
+        var payload = {
+            name: 'John',
+            lastname: 'Doe',
+            anonymous: false,
+        };
+        var joinCallResponse = {
+            token: 'join-token',
+            room: 'room-id',
+            userId: 'user-123',
+        };
+        it('should join a call successfully with token', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a, client, headers, postCall, response;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = clientAndHeadersWithToken(), client = _a.client, headers = _a.headers;
+                        postCall = sinon_1.default.stub(httpClient, 'post').resolves(joinCallResponse);
+                        return [4 /*yield*/, client.joinCall(callId, payload)];
+                    case 1:
+                        response = _b.sent();
+                        // Assert
+                        expect(postCall.firstCall.args).toEqual(["call/".concat(callId, "/users/join"), payload, headers]);
+                        expect(response).toEqual(joinCallResponse);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should join a call successfully without token', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a, client, headers, postCall, response;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = clientAndHeadersWithoutToken(), client = _a.client, headers = _a.headers;
+                        postCall = sinon_1.default.stub(httpClient, 'post').resolves(joinCallResponse);
+                        return [4 /*yield*/, client.joinCall(callId, payload)];
+                    case 1:
+                        response = _b.sent();
+                        // Assert
+                        expect(postCall.firstCall.args[0]).toEqual("call/".concat(callId, "/users/join"));
+                        expect(postCall.firstCall.args[1]).toEqual(payload);
+                        expect(postCall.firstCall.args[2]).toEqual(headers);
+                        expect(response).toEqual(joinCallResponse);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('getCurrentUsersInCall method', function () {
+        var callId = 'call-123';
+        var usersInCallResponse = [
+            {
+                userId: 'user-123',
+                name: 'John',
+                lastname: 'Doe',
+                anonymous: false,
+                avatar: 'avatar-url-1',
+            },
+            {
+                userId: 'user-456',
+                name: 'Jane',
+                lastname: 'Smith',
+                anonymous: true,
+                avatar: 'avatar-url-2',
+            },
+        ];
+        it('should get current users in call successfully with token', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a, client, headers, getCall, response;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = clientAndHeadersWithToken(), client = _a.client, headers = _a.headers;
+                        getCall = sinon_1.default.stub(httpClient, 'get').resolves(usersInCallResponse);
+                        return [4 /*yield*/, client.getCurrentUsersInCall(callId)];
+                    case 1:
+                        response = _b.sent();
+                        // Assert
+                        expect(getCall.firstCall.args).toEqual(["call/".concat(callId, "/users"), headers]);
+                        expect(response).toEqual(usersInCallResponse);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should get current users in call successfully without token', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a, client, headers, getCall, response;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = clientAndHeadersWithoutToken(), client = _a.client, headers = _a.headers;
+                        getCall = sinon_1.default.stub(httpClient, 'get').resolves(usersInCallResponse);
+                        return [4 /*yield*/, client.getCurrentUsersInCall(callId)];
+                    case 1:
+                        response = _b.sent();
+                        // Assert
+                        expect(getCall.firstCall.args[0]).toEqual("call/".concat(callId, "/users"));
+                        expect(getCall.firstCall.args[1]).toEqual(headers);
+                        expect(response).toEqual(usersInCallResponse);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('leaveCall method', function () {
+        var callId = 'call-123';
+        it('should leave a call successfully with token', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a, client, headers, postCall;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = clientAndHeadersWithToken(), client = _a.client, headers = _a.headers;
+                        postCall = sinon_1.default.stub(httpClient, 'post').resolves();
+                        // Act
+                        return [4 /*yield*/, client.leaveCall(callId)];
+                    case 1:
+                        // Act
+                        _b.sent();
+                        // Assert
+                        expect(postCall.firstCall.args).toEqual(["call/".concat(callId, "/users/leave"), {}, headers]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should leave a call successfully without token', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a, client, headers, postCall;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = clientAndHeadersWithoutToken(), client = _a.client, headers = _a.headers;
+                        postCall = sinon_1.default.stub(httpClient, 'post').resolves();
+                        // Act
+                        return [4 /*yield*/, client.leaveCall(callId)];
+                    case 1:
+                        // Act
+                        _b.sent();
+                        // Assert
+                        expect(postCall.firstCall.args[0]).toEqual("call/".concat(callId, "/users/leave"));
+                        expect(postCall.firstCall.args[1]).toEqual({});
+                        expect(postCall.firstCall.args[2]).toEqual(headers);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+function clientAndHeadersWithToken(apiUrl, clientName, clientVersion, token) {
+    if (apiUrl === void 0) { apiUrl = ''; }
+    if (clientName === void 0) { clientName = 'c-name'; }
+    if (clientVersion === void 0) { clientVersion = '0.1'; }
+    if (token === void 0) { token = 'my-token'; }
+    var appDetails = {
+        clientName: clientName,
+        clientVersion: clientVersion,
+    };
+    var apiSecurity = {
+        token: token,
+    };
+    var client = index_1.Meet.client(apiUrl, appDetails, apiSecurity);
+    var headers = (0, headers_1.headersWithToken)(clientName, clientVersion, token);
+    return { client: client, headers: headers };
+}
+function clientAndHeadersWithoutToken(apiUrl, clientName, clientVersion) {
+    if (apiUrl === void 0) { apiUrl = ''; }
+    if (clientName === void 0) { clientName = 'c-name'; }
+    if (clientVersion === void 0) { clientVersion = '0.1'; }
+    var appDetails = {
+        clientName: clientName,
+        clientVersion: clientVersion,
+    };
+    var client = index_1.Meet.client(apiUrl, appDetails);
+    var headers = (0, headers_1.basicHeaders)(clientName, clientVersion);
+    return { client: client, headers: headers };
+}

package/dist/meet/types.d.ts

@@ -0,0 +1,22 @@
+export interface CreateCallResponse {
+    token: string;
+    room: string;
+    paxPerCall: number;
+}
+export interface JoinCallPayload {
+    name: string;
+    lastname: string;
+    anonymous: boolean;
+}
+export interface JoinCallResponse {
+    token: string;
+    room: string;
+    userId: string;
+}
+export interface UsersInCallResponse {
+    userId: string;
+    name: string;
+    lastname: string;
+    anonymous: boolean;
+    avatar: string;
+}

package/dist/meet/types.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@internxt/sdk",
   "author": "Internxt <hello@internxt.com>",
-  "version": "1.9.12",
+  "version": "1.9.14",
   "description": "An sdk for interacting with Internxt's services",
   "repository": {
     "type": "git",