pabal-store-api-mcp 1.1.0

package/dist/src/packages/configs/secrets-config/config.js

@@ -0,0 +1,187 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { ERROR_CODES } from "../../../packages/common/errors/error-codes.js";
+import { HTTP_STATUS } from "../../../packages/common/errors/status-codes.js";
+import { ConfigError } from "./errors.js";
+import { DATA_DIR_ENV_KEY } from "./constants.js";
+import { appStoreSchema, playStoreSchema } from "./schemas.js";
+// Config paths
+const CONFIG_DIR = join(homedir(), ".config", "pabal-store-api-mcp");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+// Security: recommended permissions
+const RECOMMENDED_DIR_MODE = 0o700; // drwx------
+const RECOMMENDED_FILE_MODE = 0o600; // -rw-------
+/**
+ * Check file/directory permissions and warn if too permissive
+ */
+function checkPermissions(path, isDirectory) {
+    try {
+        const stats = statSync(path);
+        const mode = stats.mode & 0o777;
+        const recommended = isDirectory
+            ? RECOMMENDED_DIR_MODE
+            : RECOMMENDED_FILE_MODE;
+        // Check if "group" or "others" have any permissions
+        const groupOthersPerms = mode & 0o077;
+        if (groupOthersPerms !== 0) {
+            const typeLabel = isDirectory ? "directory" : "file";
+            const recommendedStr = recommended.toString(8);
+            console.error(`[Security] ⚠️  Warning: ${typeLabel} "${path}" has permissive permissions (${mode.toString(8)})`);
+            console.error(`[Security]    Run: chmod ${recommendedStr} "${path}"`);
+        }
+    }
+    catch {
+        // Ignore permission check errors
+    }
+}
+/**
+ * Check all config files for secure permissions
+ */
+function checkConfigSecurity(configDir) {
+    // Check directory permissions
+    checkPermissions(configDir, true);
+    // Check all files in config directory
+    const sensitiveFiles = [
+        "config.json",
+        "app-store-key.p8",
+        "google-play-service-account.json",
+        "registered-apps.json",
+    ];
+    for (const file of sensitiveFiles) {
+        const filePath = join(configDir, file);
+        if (existsSync(filePath)) {
+            checkPermissions(filePath, false);
+        }
+    }
+}
+/**
+ * Get config directory path: ~/.config/pabal-mcp/
+ */
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+/**
+ * Get config file path: ~/.config/pabal-mcp/config.json
+ */
+export function getConfigPath() {
+    return CONFIG_PATH;
+}
+export function readConfigFile() {
+    const configPath = getConfigPath();
+    if (!existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const configContent = readFileSync(configPath, "utf-8");
+        return JSON.parse(configContent);
+    }
+    catch (error) {
+        console.error(`[Config]   ⚠️  Failed to read config file: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+export function getDataDir() {
+    const configDir = getConfigDir();
+    console.error(`[Config] 🔍 Checking data directory config...`);
+    // 1. Check config file first
+    const config = readConfigFile();
+    if (config?.dataDir && typeof config.dataDir === "string") {
+        const normalized = config.dataDir.trim();
+        if (normalized) {
+            const resultDir = isAbsolute(normalized)
+                ? normalized
+                : resolve(configDir, normalized);
+            console.error(`[Config]   ✅ Using config file dataDir: ${resultDir}`);
+            return resultDir;
+        }
+    }
+    // 2. Check environment variable
+    const override = process.env[DATA_DIR_ENV_KEY];
+    if (override && override.trim()) {
+        const normalized = override.trim();
+        const resultDir = isAbsolute(normalized)
+            ? normalized
+            : resolve(configDir, normalized);
+        console.error(`[Config]   ✅ Using environment variable: ${resultDir}`);
+        return resultDir;
+    }
+    // 3. Default to config directory
+    console.error(`[Config]   ✅ Using default (config dir): ${configDir}`);
+    return configDir;
+}
+export function loadConfig() {
+    const configDir = getConfigDir();
+    // Security check: warn if permissions are too permissive
+    checkConfigSecurity(configDir);
+    const config = readConfigFile();
+    if (!config) {
+        const configPath = getConfigPath();
+        throw new ConfigError(`Config file not found: ${configPath}\n` +
+            `Please create ~/.config/pabal-store-api-mcp/config.json`, { status: HTTP_STATUS.NOT_FOUND, code: ERROR_CODES.CONFIG_NOT_FOUND });
+    }
+    try {
+        const result = {};
+        if (config.appStore) {
+            const { issuerId, keyId, privateKeyPath } = config.appStore;
+            if (issuerId && keyId && privateKeyPath) {
+                const keyPath = isAbsolute(privateKeyPath)
+                    ? privateKeyPath
+                    : resolve(configDir, privateKeyPath);
+                const privateKey = readFileSafe(keyPath);
+                if (privateKey) {
+                    result.appStore = appStoreSchema.parse({
+                        keyId,
+                        issuerId,
+                        privateKey: normalizePrivateKey(privateKey),
+                    });
+                }
+            }
+        }
+        if (config.googlePlay?.serviceAccountKeyPath) {
+            const serviceAccountPath = config.googlePlay.serviceAccountKeyPath;
+            const jsonPath = isAbsolute(serviceAccountPath)
+                ? serviceAccountPath
+                : resolve(configDir, serviceAccountPath);
+            const json = readFileSafe(jsonPath);
+            if (json) {
+                result.playStore = playStoreSchema.parse({
+                    serviceAccountJson: json,
+                });
+            }
+        }
+        if (!result.appStore && !result.playStore) {
+            throw new ConfigError("Config file does not contain App Store or Play Store authentication information.", {
+                status: HTTP_STATUS.UNAUTHORIZED,
+                code: ERROR_CODES.CONFIG_AUTH_NOT_FOUND,
+            });
+        }
+        return result;
+    }
+    catch (error) {
+        if (error instanceof ConfigError) {
+            throw error;
+        }
+        throw new ConfigError(`Error reading config file: ${error instanceof Error ? error.message : String(error)}`, {
+            status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+            code: ERROR_CODES.CONFIG_READ_FAILED,
+            cause: error,
+        });
+    }
+}
+function readFileSafe(path) {
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}
+// Restore line breaks in PEM key
+function normalizePrivateKey(raw) {
+    if (raw.includes("-----BEGIN")) {
+        return raw;
+    }
+    const restored = raw.replace(/\\n/g, "\n");
+    return restored;
+}

package/dist/src/packages/configs/secrets-config/constants.d.ts

@@ -0,0 +1 @@
+export declare const DATA_DIR_ENV_KEY = "PABAL_MCP_DATA_DIR";

package/dist/src/packages/configs/secrets-config/constants.js

@@ -0,0 +1 @@
+export const DATA_DIR_ENV_KEY = "PABAL_MCP_DATA_DIR";

package/dist/src/packages/configs/secrets-config/errors.d.ts

@@ -0,0 +1,9 @@
+import { AppError } from "../../../packages/common/errors/app-error.js";
+export declare class ConfigError extends AppError {
+    constructor(message: string, options?: {
+        code?: string;
+        status?: number;
+        details?: unknown;
+        cause?: unknown;
+    });
+}

package/dist/src/packages/configs/secrets-config/errors.js

@@ -0,0 +1,15 @@
+import { AppError } from "../../../packages/common/errors/app-error.js";
+import { ERROR_CODES } from "../../../packages/common/errors/error-codes.js";
+import { HTTP_STATUS } from "../../../packages/common/errors/status-codes.js";
+export class ConfigError extends AppError {
+    constructor(message, options) {
+        super({
+            status: options?.status ?? HTTP_STATUS.INTERNAL_SERVER_ERROR,
+            code: options?.code ?? ERROR_CODES.CONFIG_ERROR,
+            message,
+            details: options?.details,
+            cause: options?.cause,
+        });
+        this.name = "ConfigError";
+    }
+}

package/dist/src/packages/configs/secrets-config/registered-apps.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Registered app management
+ * Manage app list through ~/.config/pabal-mcp/registered-apps.json file
+ */
+export interface RegisteredAppStoreInfo {
+    bundleId: string;
+    appId?: string;
+    name?: string;
+    supportedLocales?: string[];
+}
+export interface RegisteredGooglePlayInfo {
+    packageName: string;
+    name?: string;
+    supportedLocales?: string[];
+}
+export interface RegisteredApp {
+    /** App identifier (user-defined, must be unique) */
+    slug: string;
+    /** Display name */
+    name: string;
+    /** App Store information */
+    appStore?: RegisteredAppStoreInfo;
+    /** Google Play information */
+    googlePlay?: RegisteredGooglePlayInfo;
+}
+export interface RegisteredAppsConfig {
+    apps: RegisteredApp[];
+}
+/**
+ * Load registered app list
+ */
+export declare function loadRegisteredApps(): RegisteredAppsConfig;
+/**
+ * Save registered app list
+ */
+export declare function saveRegisteredApps(config: RegisteredAppsConfig): void;
+/**
+ * Register app
+ */
+export declare function registerApp(app: RegisteredApp): RegisteredApp;
+/**
+ * Find app (search by slug, bundleId, packageName)
+ */
+export declare function findApp(identifier: string): RegisteredApp | undefined;
+/**
+ * Update supported locales for an app
+ */
+export declare function updateAppSupportedLocales({ identifier, store, locales, }: {
+    identifier: string;
+    store: "appStore" | "googlePlay";
+    locales: string[];
+}): boolean;

package/dist/src/packages/configs/secrets-config/registered-apps.js

@@ -0,0 +1,108 @@
+/**
+ * Registered app management
+ * Manage app list through ~/.config/pabal-mcp/registered-apps.json file
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { AppError } from "../../../packages/common/errors/app-error.js";
+import { ERROR_CODES } from "../../../packages/common/errors/error-codes.js";
+import { getConfigDir } from "../../../packages/configs/secrets-config/config.js";
+// ============================================================================
+// File Paths
+// ============================================================================
+function getRegisteredAppsPath() {
+    return join(getConfigDir(), "registered-apps.json");
+}
+// ============================================================================
+// CRUD Functions
+// ============================================================================
+/**
+ * Load registered app list
+ */
+export function loadRegisteredApps() {
+    const filePath = getRegisteredAppsPath();
+    console.error(`[RegisteredApps] 🔍 Loading registered apps...`);
+    console.error(`[RegisteredApps]   File path: ${filePath}`);
+    console.error(`[RegisteredApps]   File exists: ${existsSync(filePath)}`);
+    if (!existsSync(filePath)) {
+        console.error(`[RegisteredApps]   ⚠️  File not found, returning empty list`);
+        return { apps: [] };
+    }
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const config = JSON.parse(content);
+        console.error(`[RegisteredApps]   ✅ Loaded ${config.apps.length} apps: ${config.apps.map((a) => a.slug).join(", ")}`);
+        return config;
+    }
+    catch (error) {
+        throw AppError.validation(ERROR_CODES.REGISTERED_APPS_READ_FAILED, `Failed to load registered apps: ${error instanceof Error ? error.message : String(error)}`, { filePath });
+    }
+}
+/**
+ * Save registered app list
+ */
+export function saveRegisteredApps(config) {
+    const filePath = getRegisteredAppsPath();
+    try {
+        writeFileSync(filePath, JSON.stringify(config, null, 2));
+    }
+    catch (error) {
+        throw AppError.io(ERROR_CODES.REGISTERED_APPS_WRITE_FAILED, `Failed to save registered apps: ${error instanceof Error ? error.message : String(error)}`, { filePath });
+    }
+}
+/**
+ * Register app
+ */
+export function registerApp(app) {
+    const config = loadRegisteredApps();
+    // Check for duplicates
+    const existing = config.apps.find((a) => a.slug === app.slug);
+    if (existing) {
+        throw AppError.conflict(ERROR_CODES.REGISTERED_APP_DUPLICATE, `App with slug "${app.slug}" already exists`);
+    }
+    config.apps.push(app);
+    saveRegisteredApps(config);
+    return app;
+}
+/**
+ * Find app (search by slug, bundleId, packageName)
+ */
+export function findApp(identifier) {
+    const config = loadRegisteredApps();
+    return config.apps.find((app) => app.slug === identifier ||
+        app.appStore?.bundleId === identifier ||
+        app.googlePlay?.packageName === identifier);
+}
+/**
+ * Update supported locales for an app
+ */
+export function updateAppSupportedLocales({ identifier, store, locales, }) {
+    const config = loadRegisteredApps();
+    const appIndex = config.apps.findIndex((app) => app.slug === identifier ||
+        app.appStore?.bundleId === identifier ||
+        app.googlePlay?.packageName === identifier);
+    if (appIndex === -1) {
+        throw AppError.notFound(ERROR_CODES.REGISTERED_APP_NOT_FOUND, `App "${identifier}" not found in registered apps`);
+    }
+    const app = config.apps[appIndex];
+    // Merge and deduplicate locales
+    const existingLocales = store === "appStore"
+        ? app.appStore?.supportedLocales || []
+        : app.googlePlay?.supportedLocales || [];
+    const mergedLocales = Array.from(new Set([...existingLocales, ...locales])).sort();
+    // Update the app
+    if (store === "appStore") {
+        if (!app.appStore) {
+            throw AppError.validation(ERROR_CODES.REGISTERED_APP_STORE_INFO_MISSING, `App "${identifier}" is missing App Store info`);
+        }
+        app.appStore.supportedLocales = mergedLocales;
+    }
+    else {
+        if (!app.googlePlay) {
+            throw AppError.validation(ERROR_CODES.REGISTERED_APP_STORE_INFO_MISSING, `App "${identifier}" is missing Google Play info`);
+        }
+        app.googlePlay.supportedLocales = mergedLocales;
+    }
+    saveRegisteredApps(config);
+    return true;
+}

package/dist/src/packages/configs/secrets-config/schemas.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const appStoreSchema: z.ZodObject<{
+    keyId: z.ZodString;
+    issuerId: z.ZodString;
+    privateKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    keyId: string;
+    issuerId: string;
+    privateKey: string;
+}, {
+    keyId: string;
+    issuerId: string;
+    privateKey: string;
+}>;
+export declare const playStoreSchema: z.ZodObject<{
+    serviceAccountJson: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    serviceAccountJson: string;
+}, {
+    serviceAccountJson: string;
+}>;

package/dist/src/packages/configs/secrets-config/schemas.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const appStoreSchema = z.object({
+    keyId: z.string().min(1),
+    issuerId: z.string().min(1),
+    privateKey: z.string().min(1), // PEM format string
+});
+export const playStoreSchema = z.object({
+    serviceAccountJson: z.string().min(1), // JSON string
+});

package/dist/src/packages/configs/secrets-config/types.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { appStoreSchema, playStoreSchema } from "./schemas.js";
+export type AppStoreConfig = z.infer<typeof appStoreSchema>;
+export type PlayStoreConfig = z.infer<typeof playStoreSchema>;
+export type EnvConfig = {
+    appStore?: AppStoreConfig;
+    playStore?: PlayStoreConfig;
+};

package/dist/src/packages/configs/secrets-config/types.js

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

package/dist/src/packages/stores/app-store/api-converters.d.ts

@@ -0,0 +1,26 @@
+/**
+ * App Store Connect API Data Converters
+ *
+ * Data transformation logic between API responses and internal types
+ */
+import type { AppStoreAsoData, AppStoreMultilingualAsoData, AppStoreReleaseNote, AppStoreScreenshots } from "../../../packages/configs/aso-config/types.js";
+import type { ApiResponse, AppInfoLocalization, AppStoreApp, AppStoreLocalization, AppStoreScreenshot, AppStoreScreenshotSet, AppStoreVersion } from "./types.js";
+export declare function sortVersions(versions: AppStoreVersion[]): AppStoreVersion[];
+export declare function selectEnglishAppName(localizations: AppInfoLocalization[]): string | null;
+export declare function mapLocalizationsByLocale<T extends {
+    attributes?: {
+        locale?: string;
+    };
+}>(localizations: T[]): Record<string, T>;
+export declare function fetchScreenshotsForLocalization(localizationId: string | undefined, listScreenshotSets: (localizationId: string) => Promise<ApiResponse<AppStoreScreenshotSet[]>>, listScreenshots: (screenshotSetId: string) => Promise<ApiResponse<AppStoreScreenshot[]>>): Promise<AppStoreScreenshots>;
+export declare function convertToAsoData(params: {
+    app: AppStoreApp;
+    appInfoLocalization?: AppInfoLocalization | null;
+    localization?: AppStoreLocalization | null;
+    screenshots: AppStoreScreenshots;
+    locale: string;
+    bundleId: string;
+}): AppStoreAsoData;
+export declare function convertToMultilingualAsoData(locales: Record<string, AppStoreAsoData>, defaultLocale?: string): AppStoreMultilingualAsoData;
+export declare function convertToReleaseNote(version: AppStoreVersion, localizations: AppStoreLocalization[]): AppStoreReleaseNote | null;
+export declare function sortReleaseNotes(releaseNotes: AppStoreReleaseNote[]): AppStoreReleaseNote[];

package/dist/src/packages/stores/app-store/api-converters.js

@@ -0,0 +1,131 @@
+/**
+ * App Store Connect API Data Converters
+ *
+ * Data transformation logic between API responses and internal types
+ */
+import { DEFAULT_LOCALE } from "../../../packages/configs/aso-config/constants.js";
+import { SCREENSHOT_TYPE_MAP } from "./constants.js";
+export function sortVersions(versions) {
+    return versions.sort((a, b) => {
+        const vA = (a.attributes?.versionString ?? "0").split(".").map(Number);
+        const vB = (b.attributes?.versionString ?? "0").split(".").map(Number);
+        for (let i = 0; i < Math.max(vA.length, vB.length); i++) {
+            const diff = (vB[i] || 0) - (vA[i] || 0);
+            if (diff !== 0)
+                return diff;
+        }
+        return 0;
+    });
+}
+export function selectEnglishAppName(localizations) {
+    const enUS = localizations.find((l) => l.attributes?.locale === "en-US");
+    if (enUS?.attributes?.name)
+        return enUS.attributes.name;
+    const enGB = localizations.find((l) => l.attributes?.locale === "en-GB");
+    if (enGB?.attributes?.name)
+        return enGB.attributes.name;
+    const enAny = localizations.find((l) => l.attributes?.locale?.startsWith("en"));
+    if (enAny?.attributes?.name)
+        return enAny.attributes.name;
+    return null;
+}
+export function mapLocalizationsByLocale(localizations) {
+    return localizations.reduce((acc, loc) => {
+        const locale = loc.attributes?.locale;
+        if (locale)
+            acc[locale] = loc;
+        return acc;
+    }, {});
+}
+export async function fetchScreenshotsForLocalization(localizationId, listScreenshotSets, listScreenshots) {
+    const screenshots = {};
+    if (!localizationId)
+        return screenshots;
+    const setsResponse = await listScreenshotSets(localizationId);
+    for (const set of setsResponse.data || []) {
+        const screenshotsResponse = await listScreenshots(set.id);
+        const urls = (screenshotsResponse.data || [])
+            .map((s) => s.attributes?.imageAsset?.templateUrl)
+            .filter(Boolean);
+        if (urls.length > 0) {
+            const displayType = set.attributes?.screenshotDisplayType;
+            if (displayType) {
+                const mappedType = SCREENSHOT_TYPE_MAP[displayType];
+                if (mappedType)
+                    screenshots[mappedType] = urls;
+            }
+        }
+    }
+    return screenshots;
+}
+export function convertToAsoData(params) {
+    const { app, appInfoLocalization, localization, screenshots, locale, bundleId, } = params;
+    return {
+        name: appInfoLocalization?.attributes?.name ||
+            app.attributes?.name ||
+            "Unknown",
+        subtitle: appInfoLocalization?.attributes?.subtitle,
+        description: localization?.attributes?.description || "",
+        keywords: localization?.attributes?.keywords,
+        promotionalText: localization?.attributes?.promotionalText,
+        screenshots,
+        bundleId,
+        locale,
+        supportUrl: localization?.attributes?.supportUrl,
+        marketingUrl: localization?.attributes?.marketingUrl,
+        whatsNew: localization?.attributes?.whatsNew,
+    };
+}
+export function convertToMultilingualAsoData(locales, defaultLocale) {
+    let finalDefaultLocale = defaultLocale;
+    if (!finalDefaultLocale && Object.keys(locales).length > 0) {
+        if (locales[DEFAULT_LOCALE]) {
+            finalDefaultLocale = DEFAULT_LOCALE;
+        }
+        else {
+            finalDefaultLocale = Object.keys(locales)[0];
+        }
+    }
+    return {
+        locales,
+        defaultLocale: finalDefaultLocale || DEFAULT_LOCALE,
+    };
+}
+export function convertToReleaseNote(version, localizations) {
+    const releaseNotesMap = {};
+    for (const localization of localizations) {
+        const locale = localization.attributes?.locale;
+        const whatsNew = localization.attributes?.whatsNew;
+        if (locale && whatsNew) {
+            releaseNotesMap[locale] = whatsNew;
+        }
+    }
+    if (Object.keys(releaseNotesMap).length === 0) {
+        return null;
+    }
+    const versionString = version.attributes?.versionString;
+    const platform = version.attributes?.platform;
+    if (!versionString || !platform) {
+        return null;
+    }
+    return {
+        versionString,
+        releaseNotes: releaseNotesMap,
+        platform,
+    };
+}
+export function sortReleaseNotes(releaseNotes) {
+    const versionMap = new Map(releaseNotes.map((note) => [note.versionString, note]));
+    const sortedVersions = sortVersions(releaseNotes.map((note) => ({
+        type: "appStoreVersions",
+        id: note.versionString,
+        attributes: {
+            versionString: note.versionString,
+            platform: note.platform,
+        },
+        links: { self: note.versionString },
+    })));
+    return sortedVersions
+        .map((version) => versionMap.get(version.attributes?.versionString ?? ""))
+        .filter((note) => !!note && !!note.versionString);
+}

package/dist/src/packages/stores/app-store/api-endpoints.d.ts

@@ -0,0 +1,33 @@
+/**
+ * App Store Connect API Endpoints
+ *
+ * Centralized API endpoint management for App Store Connect
+ */
+import type { ApiResponse, AppInfo, AppInfoLocalization, AppInfoLocalizationUpdateAttributes, AppStoreApp, AppStoreLocalization, AppStoreScreenshot, AppStoreScreenshotSet, AppStoreVersion, AppStoreVersionLocalizationUpdateAttributes } from "./types.js";
+export declare class AppStoreApiEndpoints {
+    private generateToken;
+    private issuerId;
+    private keyId;
+    constructor(generateToken: () => Promise<string>, issuerId: string, keyId: string);
+    normalizeNextLink(nextLink?: string | null): string | null;
+    private request;
+    listApps(nextUrl?: string): Promise<ApiResponse<AppStoreApp[]>>;
+    findAppByBundleId(bundleId: string): Promise<ApiResponse<AppStoreApp[]>>;
+    getApp(appId: string): Promise<ApiResponse<AppStoreApp>>;
+    listAppInfos(appId: string): Promise<ApiResponse<AppInfo[]>>;
+    listAppInfoLocalizations(appInfoId: string, locale?: string): Promise<ApiResponse<AppInfoLocalization[]>>;
+    updateAppInfoLocalization(localizationId: string, attributes: AppInfoLocalizationUpdateAttributes): Promise<void>;
+    createAppInfoLocalization(appInfoId: string, locale: string, attributes: AppInfoLocalizationUpdateAttributes): Promise<ApiResponse<AppInfoLocalization>>;
+    listAppStoreVersions(appId: string, options?: {
+        platform?: string;
+        state?: string;
+        limit?: number;
+    }): Promise<ApiResponse<AppStoreVersion[]>>;
+    createAppStoreVersion(appId: string, versionString: string, platform?: string): Promise<ApiResponse<AppStoreVersion>>;
+    listAppStoreVersionLocalizations(versionId: string, locale?: string): Promise<ApiResponse<AppStoreLocalization[]>>;
+    getAppStoreVersionLocalization(localizationId: string): Promise<ApiResponse<AppStoreLocalization>>;
+    updateAppStoreVersionLocalization(localizationId: string, attributes: AppStoreVersionLocalizationUpdateAttributes): Promise<void>;
+    createAppStoreVersionLocalization(versionId: string, locale: string, attributes: AppStoreVersionLocalizationUpdateAttributes): Promise<ApiResponse<AppStoreLocalization>>;
+    listScreenshotSets(localizationId: string): Promise<ApiResponse<AppStoreScreenshotSet[]>>;
+    listScreenshots(screenshotSetId: string): Promise<ApiResponse<AppStoreScreenshot[]>>;
+}