@akylas/nativescript-cli 8.7.2

package/lib/services/android-resources-migration-service.js

@@ -0,0 +1,104 @@
+"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.AndroidResourcesMigrationService = void 0;
+const path = require("path");
+const constants = require("../constants");
+const os_1 = require("os");
+const yok_1 = require("../common/yok");
+class AndroidResourcesMigrationService {
+    constructor($fs, $errors, $logger, $devicePlatformsConstants) {
+        this.$fs = $fs;
+        this.$errors = $errors;
+        this.$logger = $logger;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+    }
+    canMigrate(platformString) {
+        return (platformString.toLowerCase() ===
+            this.$devicePlatformsConstants.Android.toLowerCase());
+    }
+    hasMigrated(appResourcesDir) {
+        return this.$fs.exists(path.join(appResourcesDir, AndroidResourcesMigrationService.ANDROID_DIR, constants.SRC_DIR, constants.MAIN_DIR));
+    }
+    migrate(appResourcesDir, backupLocation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const originalAppResources = path.join(appResourcesDir, AndroidResourcesMigrationService.ANDROID_DIR);
+            const appResourcesDestination = path.join(appResourcesDir, AndroidResourcesMigrationService.ANDROID_DIR_TEMP);
+            const appResourcesBackup = path.join(backupLocation || appResourcesDir, AndroidResourcesMigrationService.ANDROID_DIR_OLD);
+            try {
+                yield this.tryMigrate(originalAppResources, appResourcesDestination, appResourcesBackup);
+                this.$logger.info(`Successfully updated your project's application resources '/Android' directory structure.${os_1.EOL}The previous version of your Android application resources has been renamed to '/${AndroidResourcesMigrationService.ANDROID_DIR_OLD}'`);
+            }
+            catch (error) {
+                try {
+                    this.recover(originalAppResources, appResourcesDestination, appResourcesBackup);
+                    this.$logger.info("Failed to update resources. They should be in their initial state.");
+                }
+                catch (err) {
+                    this.$logger.trace(err);
+                    this.$logger.info(`Failed to update resources.${os_1.EOL} Backup of original content is inside "${appResourcesBackup}".${os_1.EOL}If "${originalAppResources} is missing copy from backup folder."`);
+                }
+                finally {
+                    this.$errors.fail(error.message);
+                }
+            }
+        });
+    }
+    tryMigrate(originalAppResources, appResourcesDestination, appResourcesBackup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const appMainSourceSet = path.join(appResourcesDestination, constants.SRC_DIR, constants.MAIN_DIR);
+            const appResourcesMainSourceSetResourcesDestination = path.join(appMainSourceSet, constants.RESOURCES_DIR);
+            this.$fs.ensureDirectoryExists(appResourcesDestination);
+            this.$fs.ensureDirectoryExists(appMainSourceSet);
+            this.$fs.ensureDirectoryExists(appResourcesMainSourceSetResourcesDestination);
+            this.$fs.ensureDirectoryExists(path.join(appMainSourceSet, "java"));
+            this.$fs.ensureDirectoryExists(path.join(appMainSourceSet, constants.ASSETS_DIR));
+            const isDirectory = (source) => this.$fs.getLsStats(source).isDirectory();
+            const getAllFiles = (source) => this.$fs.readDirectory(source).map((name) => path.join(source, name));
+            const getDirectories = (files) => files.filter(isDirectory);
+            const getFiles = (files) => files.filter((file) => !isDirectory(file));
+            this.$fs.copyFile(path.join(originalAppResources, constants.APP_GRADLE_FILE_NAME), path.join(appResourcesDestination, constants.APP_GRADLE_FILE_NAME));
+            const appResourcesFiles = getAllFiles(originalAppResources);
+            const resourceDirectories = getDirectories(appResourcesFiles);
+            const resourceFiles = getFiles(appResourcesFiles);
+            resourceDirectories.forEach((dir) => {
+                if (path.basename(dir) !== "libs") {
+                    this.$fs.copyFile(dir, appResourcesMainSourceSetResourcesDestination);
+                }
+                else {
+                    this.$fs.copyFile(dir, path.join(appResourcesDestination));
+                }
+            });
+            resourceFiles.forEach((file) => {
+                const fileName = path.basename(file);
+                if (fileName !== constants.MANIFEST_FILE_NAME) {
+                    this.$fs.copyFile(file, path.join(appResourcesDestination, fileName));
+                }
+            });
+            this.$fs.copyFile(path.join(originalAppResources, constants.MANIFEST_FILE_NAME), path.join(appMainSourceSet, constants.MANIFEST_FILE_NAME));
+            this.$fs.rename(originalAppResources, appResourcesBackup);
+            this.$fs.rename(appResourcesDestination, originalAppResources);
+        });
+    }
+    recover(originalAppResources, appResourcesDestination, appResourcesBackup) {
+        if (!this.$fs.exists(originalAppResources)) {
+            this.$fs.rename(appResourcesBackup, originalAppResources);
+        }
+        if (this.$fs.exists(appResourcesDestination)) {
+            this.$fs.deleteDirectory(appResourcesDestination);
+        }
+    }
+}
+AndroidResourcesMigrationService.ANDROID_DIR = "Android";
+AndroidResourcesMigrationService.ANDROID_DIR_TEMP = "Android-Updated";
+AndroidResourcesMigrationService.ANDROID_DIR_OLD = "Android-Pre-v4";
+exports.AndroidResourcesMigrationService = AndroidResourcesMigrationService;
+yok_1.injector.register("androidResourcesMigrationService", AndroidResourcesMigrationService);

package/lib/services/apple-portal/apple-portal-application-service.js

@@ -0,0 +1,82 @@
+"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.ApplePortalApplicationService = void 0;
+const yok_1 = require("../../common/yok");
+const _ = require("lodash");
+class ApplePortalApplicationService {
+    constructor($applePortalSessionService, $errors, $httpClient) {
+        this.$applePortalSessionService = $applePortalSessionService;
+        this.$errors = $errors;
+        this.$httpClient = $httpClient;
+    }
+    getApplications(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = [];
+            for (const account of user.associatedAccounts) {
+                const contentProviderId = account.contentProvider.contentProviderId;
+                const applications = yield this.getApplicationsByProvider(contentProviderId);
+                result = result.concat(applications.summaries);
+            }
+            return result;
+        });
+    }
+    getApplicationsByProvider(contentProviderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const webSessionCookie = yield this.$applePortalSessionService.createWebSession(contentProviderId);
+            const summaries = [];
+            yield this.getApplicationsByUrl(webSessionCookie, "https://appstoreconnect.apple.com/iris/v1/apps?include=appStoreVersions,prices", summaries);
+            return { summaries: summaries };
+        });
+    }
+    getApplicationsByUrl(webSessionCookie, url, summaries) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.$httpClient.httpRequest({
+                url,
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                    Cookie: webSessionCookie,
+                },
+            });
+            const result = JSON.parse(response.body);
+            const data = result.data;
+            for (const app of data) {
+                let summary;
+                summary = {
+                    bundleId: app.attributes.bundleId,
+                    adamId: app.id,
+                    name: app.attributes.name,
+                    versionSets: [],
+                };
+                summaries.push(summary);
+            }
+            if (result.links.next) {
+                yield this.getApplicationsByUrl(webSessionCookie, result.links.next, summaries);
+            }
+        });
+    }
+    getApplicationByBundleId(user, bundleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const applications = yield this.getApplications(user);
+            if (!applications || !applications.length) {
+                this.$errors.fail(`Cannot find any registered applications for Apple ID ${user.userName} in iTunes Connect.`);
+            }
+            const application = _.find(applications, (app) => app.bundleId === bundleId);
+            if (!application) {
+                this.$errors.fail(`Cannot find registered applications that match the specified identifier ${bundleId} in iTunes Connect.`);
+            }
+            return application;
+        });
+    }
+}
+exports.ApplePortalApplicationService = ApplePortalApplicationService;
+yok_1.injector.register("applePortalApplicationService", ApplePortalApplicationService);

package/lib/services/apple-portal/apple-portal-cookie-service.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplePortalCookieService = void 0;
+const _ = require("lodash");
+const yok_1 = require("../../common/yok");
+class ApplePortalCookieService {
+    constructor() {
+        this.userSessionCookies = {};
+        this.validUserSessionCookieNames = [
+            "myacinfo",
+            "dqsid",
+            "itctx",
+            "itcdq",
+            "acn01",
+            "DES",
+        ];
+        this.validWebSessionCookieNames = ["wosid", "woinst", "itctx"];
+    }
+    getWebSessionCookie(cookiesData) {
+        const webSessionCookies = _.cloneDeep(this.userSessionCookies);
+        const parsedCookies = this.parseCookiesData(cookiesData, this.validWebSessionCookieNames);
+        _.each(parsedCookies, (parsedCookie) => (webSessionCookies[parsedCookie.key] = parsedCookie.cookie));
+        return _.values(webSessionCookies).join("; ");
+    }
+    getUserSessionCookie() {
+        return _.values(this.userSessionCookies).join("; ");
+    }
+    updateUserSessionCookie(cookiesData) {
+        const parsedCookies = this.parseCookiesData(cookiesData, this.validUserSessionCookieNames);
+        _.each(parsedCookies, (parsedCookie) => (this.userSessionCookies[parsedCookie.key] = parsedCookie.cookie));
+    }
+    parseCookiesData(cookiesData, validCookieNames) {
+        const result = {};
+        for (const c of cookiesData) {
+            const parts = c.split(";");
+            for (const cookie of parts) {
+                const trimmedCookie = cookie.trim();
+                const [cookieKey, cookieValue] = trimmedCookie.split("=");
+                if (_.includes(validCookieNames, cookieKey) ||
+                    _.some(validCookieNames, (validCookieName) => cookieKey.startsWith(validCookieName))) {
+                    result[cookieKey] = {
+                        key: cookieKey,
+                        value: cookieValue,
+                        cookie: trimmedCookie,
+                    };
+                }
+            }
+        }
+        return result;
+    }
+}
+exports.ApplePortalCookieService = ApplePortalCookieService;
+yok_1.injector.register("applePortalCookieService", ApplePortalCookieService);

package/lib/services/apple-portal/apple-portal-session-service.js

@@ -0,0 +1,277 @@
+"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.ApplePortalSessionService = void 0;
+const helpers_1 = require("../../common/helpers");
+const yok_1 = require("../../common/yok");
+const crypto = require("crypto");
+class ApplePortalSessionService {
+    constructor($applePortalCookieService, $errors, $httpClient, $logger, $prompter) {
+        this.$applePortalCookieService = $applePortalCookieService;
+        this.$errors = $errors;
+        this.$httpClient = $httpClient;
+        this.$logger = $logger;
+        this.$prompter = $prompter;
+        this.loginConfigEndpoint = "https://appstoreconnect.apple.com/olympus/v1/app/config?hostname=itunesconnect.apple.com";
+        this.defaultLoginConfig = {
+            authServiceUrl: "https://idmsa.apple.com/appleautcodh",
+            authServiceKey: "e0b80c3bf78523bfe80974d320935bfa30add02e1bff88ec2166c6bd5a706c42",
+        };
+    }
+    createUserSession(credentials, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loginResult = yield this.login(credentials, opts);
+            if (!opts || !opts.sessionBase64) {
+                if (loginResult.isTwoFactorAuthenticationEnabled) {
+                    const authServiceKey = (yield this.getLoginConfig()).authServiceKey;
+                    yield this.handleTwoFactorAuthentication(loginResult.scnt, loginResult.xAppleIdSessionId, authServiceKey, loginResult.hashcash);
+                }
+                const sessionResponse = yield this.$httpClient.httpRequest({
+                    url: "https://appstoreconnect.apple.com/olympus/v1/session",
+                    method: "GET",
+                    headers: {
+                        Cookie: this.$applePortalCookieService.getUserSessionCookie(),
+                    },
+                });
+                this.$applePortalCookieService.updateUserSessionCookie(sessionResponse.headers["set-cookie"]);
+            }
+            const userDetailsResponse = yield this.$httpClient.httpRequest({
+                url: "https://appstoreconnect.apple.com/WebObjects/iTunesConnect.woa/ra/user/detail",
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                    Cookie: this.$applePortalCookieService.getUserSessionCookie(),
+                },
+            });
+            this.$applePortalCookieService.updateUserSessionCookie(userDetailsResponse.headers["set-cookie"]);
+            const userdDetails = JSON.parse(userDetailsResponse.body).data;
+            const result = Object.assign(Object.assign(Object.assign({}, userdDetails), loginResult), { userSessionCookie: this.$applePortalCookieService.getUserSessionCookie() });
+            return result;
+        });
+    }
+    createWebSession(contentProviderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const webSessionResponse = yield this.$httpClient.httpRequest({
+                url: "https://appstoreconnect.apple.com/olympus/v1/session",
+                method: "POST",
+                body: {
+                    provider: {
+                        providerId: contentProviderId,
+                    },
+                },
+                headers: {
+                    Accept: "application/json, text/plain, */*",
+                    "Accept-Encoding": "gzip, deflate, br",
+                    "X-Csrf-Itc": "itc",
+                    "Content-Type": "application/json;charset=UTF-8",
+                    "X-Requested-With": "olympus-ui",
+                    Cookie: this.$applePortalCookieService.getUserSessionCookie(),
+                },
+            });
+            const webSessionCookie = this.$applePortalCookieService.getWebSessionCookie(webSessionResponse.headers["set-cookie"]);
+            return webSessionCookie;
+        });
+    }
+    login(credentials, opts) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {
+                scnt: null,
+                xAppleIdSessionId: null,
+                isTwoFactorAuthenticationEnabled: false,
+                areCredentialsValid: true,
+                hashcash: null,
+            };
+            if (opts && opts.sessionBase64) {
+                const decodedSession = Buffer.from(opts.sessionBase64, "base64").toString("utf8");
+                this.$applePortalCookieService.updateUserSessionCookie([decodedSession]);
+                result.isTwoFactorAuthenticationEnabled =
+                    decodedSession.indexOf("DES") > -1;
+            }
+            else {
+                try {
+                    yield this.loginCore(credentials);
+                }
+                catch (err) {
+                    const statusCode = err && err.response && err.response.status;
+                    const bits = (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.headers["x-apple-hc-bits"];
+                    const challenge = (_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.headers["x-apple-hc-challenge"];
+                    const hashcash = makeHashCash(bits, challenge);
+                    result.hashcash = hashcash;
+                    result.areCredentialsValid = statusCode !== 401 && statusCode !== 403;
+                    result.isTwoFactorAuthenticationEnabled = statusCode === 409;
+                    if (result.isTwoFactorAuthenticationEnabled &&
+                        opts &&
+                        opts.requireApplicationSpecificPassword &&
+                        !opts.applicationSpecificPassword) {
+                        this.$errors
+                            .fail(`Your account has two-factor authentication enabled but --appleApplicationSpecificPassword option is not provided.
+To generate an application-specific password, please go to https://appleid.apple.com/account/manage.
+This password will be used for the iTunes Transporter, which is used to upload your application.`);
+                    }
+                    if (result.isTwoFactorAuthenticationEnabled &&
+                        opts &&
+                        opts.requireInteractiveConsole &&
+                        !(0, helpers_1.isInteractive)()) {
+                        this.$errors
+                            .fail(`Your account has two-factor authentication enabled, but your console is not interactive.
+For more details how to set up your environment, please execute "ns publish ios --help".`);
+                    }
+                    const headers = (err && err.response && err.response.headers) || {};
+                    result.scnt = headers.scnt;
+                    result.xAppleIdSessionId = headers["x-apple-id-session-id"];
+                }
+            }
+            return result;
+        });
+    }
+    loginCore(credentials) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loginConfig = yield this.getLoginConfig();
+            const loginUrl = `${loginConfig.authServiceUrl}/auth/signin`;
+            const headers = {
+                "Content-Type": "application/json",
+                "X-Requested-With": "XMLHttpRequest",
+                "X-Apple-Widget-Key": loginConfig.authServiceKey,
+                Accept: "application/json, text/javascript",
+            };
+            const body = {
+                accountName: credentials.username,
+                password: credentials.password,
+                rememberMe: true,
+            };
+            const loginResponse = yield this.$httpClient.httpRequest({
+                url: loginUrl,
+                method: "POST",
+                body,
+                headers,
+            });
+            this.$applePortalCookieService.updateUserSessionCookie(loginResponse.headers["set-cookie"]);
+        });
+    }
+    getLoginConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let config = null;
+            try {
+                const response = yield this.$httpClient.httpRequest({
+                    url: this.loginConfigEndpoint,
+                    method: "GET",
+                });
+                config = JSON.parse(response.body);
+            }
+            catch (err) {
+                this.$logger.trace(`Error while executing request to ${this.loginConfigEndpoint}. More info: ${err}`);
+            }
+            return config || this.defaultLoginConfig;
+        });
+    }
+    handleTwoFactorAuthentication(scnt, xAppleIdSessionId, authServiceKey, hashcash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = {
+                scnt: scnt,
+                "X-Apple-Id-Session-Id": xAppleIdSessionId,
+                "X-Apple-Widget-Key": authServiceKey,
+                "X-Apple-HC": hashcash,
+                Accept: "application/json",
+            };
+            const authResponse = yield this.$httpClient.httpRequest({
+                url: "https://idmsa.apple.com/appleauth/auth",
+                method: "GET",
+                headers,
+            });
+            const data = JSON.parse(authResponse.body);
+            const isSMS = data.trustedPhoneNumbers &&
+                data.trustedPhoneNumbers.length === 1 &&
+                data.noTrustedDevices;
+            const multiSMS = data.trustedPhoneNumbers &&
+                data.trustedPhoneNumbers.length !== 1 &&
+                data.noTrustedDevices;
+            let token;
+            if (data.trustedPhoneNumbers &&
+                data.trustedPhoneNumbers.length &&
+                !multiSMS) {
+                const parsedAuthResponse = JSON.parse(authResponse.body);
+                token = yield this.$prompter.getString(`Please enter the ${parsedAuthResponse.securityCode.length} digit code`, { allowEmpty: false });
+                const body = {
+                    securityCode: {
+                        code: token.toString(),
+                    },
+                };
+                let url = `https://idmsa.apple.com/appleauth/auth/verify/trusteddevice/securitycode`;
+                if (isSMS) {
+                    body.mode = "sms";
+                    body.phoneNumber = {
+                        id: data.trustedPhoneNumbers[0].id,
+                    };
+                    url = `https://idmsa.apple.com/appleauth/auth/verify/phone/securitycode`;
+                }
+                yield this.$httpClient.httpRequest({
+                    url,
+                    method: "POST",
+                    body,
+                    headers: Object.assign(Object.assign({}, headers), { "Content-Type": "application/json" }),
+                });
+                const authTrustResponse = yield this.$httpClient.httpRequest({
+                    url: "https://idmsa.apple.com/appleauth/auth/2sv/trust",
+                    method: "GET",
+                    headers,
+                });
+                this.$applePortalCookieService.updateUserSessionCookie(authTrustResponse.headers["set-cookie"]);
+            }
+            else if (multiSMS) {
+                this.$errors.fail(`The NativeScript CLI does not support SMS authenticaton with multiple registered phone numbers.`);
+            }
+            else {
+                this.$errors.fail(`Although response from Apple indicated activated Two-step Verification or Two-factor Authentication, NativeScript CLI don't know how to handle this response: ${data}`);
+            }
+        });
+    }
+}
+exports.ApplePortalSessionService = ApplePortalSessionService;
+yok_1.injector.register("applePortalSessionService", ApplePortalSessionService);
+function makeHashCash(bits, challenge) {
+    const version = 1;
+    const dateString = getHashCanDateString();
+    let result;
+    for (let counter = 0;; counter++) {
+        const hc = [version, bits, dateString, challenge, `:${counter}`].join(":");
+        const shasumData = crypto.createHash("sha1");
+        shasumData.update(hc);
+        const digest = shasumData.digest();
+        if (checkBits(+bits, digest)) {
+            result = hc;
+            break;
+        }
+    }
+    return result;
+}
+function getHashCanDateString() {
+    const now = new Date();
+    return `${now.getFullYear()}${padTo2Digits(now.getMonth() + 1)}${padTo2Digits(now.getDate())}${padTo2Digits(now.getHours())}${padTo2Digits(now.getMinutes())}${padTo2Digits(now.getSeconds())}`;
+}
+function padTo2Digits(num) {
+    return num.toString().padStart(2, "0");
+}
+function checkBits(bits, digest) {
+    let result = true;
+    for (let i = 0; i < bits; ++i) {
+        result = checkBit(i, digest);
+        if (!result)
+            break;
+    }
+    return result;
+}
+function checkBit(position, buffer) {
+    const bitOffset = position & 7;
+    const byteIndex = position >> 3;
+    const bit = (buffer[byteIndex] >> bitOffset) & 1;
+    return bit === 0;
+}

package/lib/services/apple-portal/definitions.d.ts

@@ -0,0 +1,87 @@
+import { ICredentials } from "../../common/declarations";
+
+interface IApplePortalSessionService {
+	createWebSession(contentProviderId: number): Promise<string>;
+	createUserSession(
+		credentials: ICredentials,
+		opts?: IAppleCreateUserSessionOptions
+	): Promise<IApplePortalUserDetail>;
+}
+
+interface IApplePortalCookieService {
+	getWebSessionCookie(cookiesData: string[]): string;
+	getUserSessionCookie(): string;
+	updateUserSessionCookie(cookie: string[]): void;
+}
+
+interface IApplePortalApplicationService {
+	getApplications(
+		user: IApplePortalUserDetail
+	): Promise<IApplePortalApplicationSummary[]>;
+	getApplicationsByProvider(
+		contentProviderId: number
+	): Promise<IApplePortalApplication>;
+	getApplicationByBundleId(
+		user: IApplePortalUserDetail,
+		bundleId: string
+	): Promise<IApplePortalApplicationSummary>;
+}
+
+interface IAppleCreateUserSessionOptions {
+	applicationSpecificPassword?: string;
+	sessionBase64: string;
+	requireInteractiveConsole?: boolean;
+	requireApplicationSpecificPassword?: boolean;
+}
+
+interface IAppleLoginResult {
+	scnt: string;
+	xAppleIdSessionId: string;
+	isTwoFactorAuthenticationEnabled: boolean;
+	areCredentialsValid: boolean;
+	hashcash: string;
+}
+
+interface IApplePortalUserDetail extends IAppleLoginResult {
+	associatedAccounts: IApplePortalAssociatedAccountData[];
+	sessionToken: {
+		dsId: string;
+		contentProviderId: number;
+		ipAddress: string;
+	};
+	contentProviderFeatures: string[];
+	contentProviderId: number;
+	firstname: string;
+	displayName: string;
+	userName: string;
+	userId: string;
+	contentProvider: string;
+	authServiceKey: string;
+	visibility: boolean;
+	DYCVisibility: boolean;
+	userSessionCookie: string;
+}
+
+interface IApplePortalAssociatedAccountData {
+	contentProvider: {
+		name: string;
+		contentProviderId: number;
+		contentProviderPublicId: string;
+		contentProviderTypes: string[];
+	};
+	roles: string[];
+	lastLogin: number;
+}
+
+interface IApplePortalApplication {
+	summaries: IApplePortalApplicationSummary[];
+}
+
+interface IApplePortalApplicationSummary {
+	name: string;
+	adamId: string;
+
+	bundleId: string;
+
+	versionSets: any[];
+}