@playdrop/playdrop-cli 0.3.1-build.1

package/node_modules/@playdrop/api-client/dist/client.js

@@ -0,0 +1,1908 @@
+import { ApiError, UnsupportedClientError } from '@playdrop/types/api';
+const DEFAULT_REQUEST_TIMEOUT_MS = 15000;
+export function createApiClient(config = {}) {
+    const fetchImpl = config.fetchImpl ?? globalThis.fetch?.bind(globalThis);
+    if (!fetchImpl) {
+        throw new Error('api_client_missing_fetch');
+    }
+    const requestTimeoutMs = (() => {
+        if (config.requestTimeoutMs === undefined) {
+            return DEFAULT_REQUEST_TIMEOUT_MS;
+        }
+        const parsed = Number(config.requestTimeoutMs);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            throw new Error('invalid_api_request_timeout_ms');
+        }
+        return Math.floor(parsed);
+    })();
+    async function resolveToken() {
+        if (config.tokenProvider) {
+            const token = await config.tokenProvider();
+            return token ?? null;
+        }
+        if (typeof window !== 'undefined') {
+            try {
+                return window.localStorage.getItem('playdrop.accessToken');
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    function resolveBaseUrl() {
+        if (config.baseUrl) {
+            return config.baseUrl;
+        }
+        if (typeof process !== 'undefined' && process.env.NEXT_PUBLIC_API_BASE) {
+            return process.env.NEXT_PUBLIC_API_BASE;
+        }
+        if (typeof window !== 'undefined') {
+            const { protocol, hostname } = window.location;
+            if (hostname.includes('www.') && hostname.includes('.')) {
+                return `${protocol}//api.${hostname.replace('www.', '')}`;
+            }
+            if (hostname === 'play.local' || hostname === 'www.localhost') {
+                const apiDomain = hostname.includes('localhost') ? 'api.localhost' : 'api.local';
+                return `${protocol}//${apiDomain}`;
+            }
+            return `${protocol}//${hostname}:4000`;
+        }
+        return 'http://localhost:4000';
+    }
+    function resolveUrl(base, path) {
+        if (/^https?:/i.test(path)) {
+            return path;
+        }
+        const normalizedBase = base.endsWith('/') ? base : `${base}/`;
+        const trimmedPath = path.startsWith('/') ? path.slice(1) : path;
+        return new URL(trimmedPath, normalizedBase).toString();
+    }
+    function buildIapQuery(params) {
+        if (!params) {
+            return '';
+        }
+        const search = new URLSearchParams();
+        if (params.kind) {
+            search.set('kind', params.kind);
+        }
+        if (params.status) {
+            const statuses = Array.isArray(params.status) ? params.status : [params.status];
+            if (statuses.length > 0) {
+                search.set('status', statuses.join(','));
+            }
+        }
+        if (params.from) {
+            const fromValue = params.from instanceof Date ? params.from.toISOString() : params.from;
+            search.set('from', fromValue);
+        }
+        if (params.to) {
+            const toValue = params.to instanceof Date ? params.to.toISOString() : params.to;
+            search.set('to', toValue);
+        }
+        if (typeof params.appId === 'number') {
+            search.set('appId', String(params.appId));
+        }
+        if (typeof params.limit === 'number') {
+            search.set('limit', String(params.limit));
+        }
+        if (typeof params.offset === 'number') {
+            search.set('offset', String(params.offset));
+        }
+        const query = search.toString();
+        return query;
+    }
+    function normalizeAssetRevisionInput(revision) {
+        if (typeof revision === 'number') {
+            if (!Number.isInteger(revision) || revision <= 0) {
+                throw new Error('invalid_asset_revision');
+            }
+            return String(revision);
+        }
+        const trimmed = revision.trim().toLowerCase();
+        if (!trimmed) {
+            throw new Error('invalid_asset_revision');
+        }
+        const numeric = trimmed.startsWith('r') ? trimmed.slice(1) : trimmed;
+        const parsed = Number.parseInt(numeric, 10);
+        if (!Number.isInteger(parsed) || parsed <= 0) {
+            throw new Error('invalid_asset_revision');
+        }
+        return String(parsed);
+    }
+    function normalizeSemverInput(version) {
+        const trimmed = typeof version === 'string' ? version.trim() : '';
+        if (!trimmed) {
+            throw new Error('invalid_version_format');
+        }
+        const semverRegex = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+        if (!semverRegex.test(trimmed)) {
+            throw new Error('invalid_version_format');
+        }
+        return trimmed;
+    }
+    function parseContentDispositionFilename(headerValue) {
+        if (!headerValue) {
+            return null;
+        }
+        const utf8Match = /filename\*=UTF-8''([^;]+)/i.exec(headerValue);
+        if (utf8Match && utf8Match[1]) {
+            try {
+                return decodeURIComponent(utf8Match[1]);
+            }
+            catch {
+                return utf8Match[1];
+            }
+        }
+        const plainMatch = /filename="?([^";]+)"?/i.exec(headerValue);
+        return plainMatch?.[1] ?? null;
+    }
+    async function parseResponseBody(response) {
+        if (response.status === 204 || response.status === 205 || response.status === 304) {
+            return undefined;
+        }
+        const contentType = response.headers.get('content-type') || '';
+        if (contentType.includes('application/json')) {
+            try {
+                return (await response.clone().json());
+            }
+            catch {
+                // fall through to text if parsing fails
+            }
+        }
+        try {
+            const text = await response.clone().text();
+            return text;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function parseUnsupportedError(status, payload) {
+        if (status !== 426 && status !== 400) {
+            return null;
+        }
+        const data = (payload && typeof payload === 'object') ? payload : null;
+        const code = typeof data?.error === 'string' ? data.error : undefined;
+        const unsupportedCodes = new Set([
+            'unsupported_client',
+            'unsupported_client_version',
+            'unsupported_client_build',
+            'unsupported_platform_version',
+            'missing_client_metadata',
+        ]);
+        const isGuardResponse = status === 426 || (status === 400 && code !== undefined && unsupportedCodes.has(code));
+        if (!isGuardResponse) {
+            return null;
+        }
+        const message = typeof data?.message === 'string' ? data.message : 'Unsupported client version';
+        return new UnsupportedClientError(code ?? 'unsupported_client', message, data ?? null);
+    }
+    async function request(req) {
+        const base = resolveBaseUrl();
+        const targetUrl = resolveUrl(base, req.path);
+        const headers = new Headers();
+        // Add client headers if provided
+        if (config.clientHeaders) {
+            const clientHeaders = config.clientHeaders();
+            for (const [key, value] of Object.entries(clientHeaders)) {
+                headers.set(key, value);
+            }
+        }
+        headers.set('accept', 'application/json');
+        if (req.body !== undefined && req.body !== null && req.method !== 'GET') {
+            headers.set('content-type', 'application/json');
+        }
+        if (req.headers) {
+            for (const [key, value] of Object.entries(req.headers)) {
+                headers.set(key, value);
+            }
+        }
+        const token = await resolveToken();
+        if (token) {
+            headers.set('authorization', `Bearer ${token}`);
+        }
+        const init = {
+            method: req.method,
+            headers,
+        };
+        if (req.body !== undefined && req.body !== null && req.method !== 'GET') {
+            init.body = typeof req.body === 'string' ? req.body : JSON.stringify(req.body);
+        }
+        let timeoutHandle = null;
+        let controller = null;
+        if (typeof AbortController !== 'undefined') {
+            controller = new AbortController();
+            init.signal = controller.signal;
+            timeoutHandle = setTimeout(() => {
+                controller?.abort();
+            }, requestTimeoutMs);
+        }
+        try {
+            const response = await fetchImpl(targetUrl, init);
+            const parsed = await parseResponseBody(response);
+            return {
+                status: response.status,
+                body: parsed,
+                headers: response.headers,
+            };
+        }
+        catch (error) {
+            if (controller?.signal.aborted) {
+                throw new Error(`api_request_timeout:${req.method}:${req.path}`);
+            }
+            throw error;
+        }
+        finally {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+        }
+    }
+    function handleApiError(response, context) {
+        const unsupported = parseUnsupportedError(response.status, response.body);
+        if (unsupported) {
+            throw unsupported;
+        }
+        const payload = response.body && typeof response.body === 'object' ? response.body : {};
+        const code = typeof payload.error === 'string' ? payload.error : context;
+        // Build a meaningful error message from the response
+        let message;
+        if (typeof payload.message === 'string') {
+            message = payload.message;
+        }
+        else if (typeof payload.error === 'string') {
+            // Use the error code as the base message
+            message = payload.error;
+            // Append errorPath if available (e.g., "ecs_invalid: systems.serverSim[0] uses reserved...")
+            if (typeof payload.errorPath === 'string') {
+                message = `${payload.error}: ${payload.errorPath}`;
+            }
+            // Append missing exports if available (for server_exports_missing)
+            if (Array.isArray(payload.missing) && payload.missing.length > 0) {
+                message = `${payload.error}: missing exports [${payload.missing.join(', ')}]`;
+            }
+        }
+        else {
+            message = `${context} failed`;
+        }
+        throw new ApiError(message, response.status, code);
+    }
+    // Implementation of all API methods
+    return {
+        request,
+        async login(loginRequest) {
+            const response = await request({
+                method: 'POST',
+                path: '/auth/login',
+                body: loginRequest,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'login');
+            }
+            return response.body;
+        },
+        async register(registerRequest) {
+            const response = await request({
+                method: 'POST',
+                path: '/auth/register',
+                body: registerRequest,
+            });
+            if (response.status !== 201) {
+                handleApiError(response, 'register');
+            }
+            return response.body;
+        },
+        async me() {
+            const response = await request({
+                method: 'GET',
+                path: '/me',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'me');
+            }
+            return response.body;
+        },
+        async updateProfile(updateRequest) {
+            const response = await request({
+                method: 'PATCH',
+                path: '/me',
+                body: updateRequest,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'update_profile');
+            }
+            return response.body;
+        },
+        async changePassword(changeRequest) {
+            const response = await request({
+                method: 'POST',
+                path: '/me/password',
+                body: changeRequest,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'change_password');
+            }
+            return response.body;
+        },
+        async upgradeToCreator() {
+            const response = await request({
+                method: 'POST',
+                path: '/me/upgrade-to-creator',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'upgrade_to_creator');
+            }
+            return response.body;
+        },
+        async unlinkX() {
+            const response = await request({
+                method: 'POST',
+                path: '/auth/x/unlink',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'unlink_x');
+            }
+            return response.body;
+        },
+        async unlinkGoogle() {
+            const response = await request({
+                method: 'POST',
+                path: '/auth/google/unlink',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'unlink_google');
+            }
+            return response.body;
+        },
+        async fetchGooglePendingSignup(token) {
+            const response = await request({
+                method: 'GET',
+                path: `/auth/google/pending/${encodeURIComponent(token)}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_google_pending_signup');
+            }
+            return response.body;
+        },
+        async checkUsernameAvailable(username) {
+            const response = await request({
+                method: 'GET',
+                path: `/auth/username-available/${encodeURIComponent(username)}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'check_username_available');
+            }
+            return response.body;
+        },
+        async completeGoogleSignup(signupRequest) {
+            const response = await request({
+                method: 'POST',
+                path: '/auth/google/complete-signup',
+                body: signupRequest,
+            });
+            if (response.status !== 201) {
+                handleApiError(response, 'complete_google_signup');
+            }
+            return response.body;
+        },
+        async fetchUserById(userId) {
+            if (!Number.isFinite(userId) || userId <= 0) {
+                throw new Error('invalid_user_id');
+            }
+            const response = await request({
+                method: 'GET',
+                path: `/users/${encodeURIComponent(String(userId))}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_user_by_id');
+            }
+            return response.body;
+        },
+        async fetchUserByUsername(username) {
+            const trimmed = typeof username === 'string' ? username.trim() : '';
+            if (!trimmed) {
+                throw new Error('invalid_username');
+            }
+            const response = await request({
+                method: 'GET',
+                path: `/users/by-username/${encodeURIComponent(trimmed)}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_user_by_username');
+            }
+            return response.body;
+        },
+        async fetchOwnedProfileAssets() {
+            const response = await request({
+                method: 'GET',
+                path: '/me/profile-assets',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_owned_profile_assets');
+            }
+            return response.body;
+        },
+        async fetchApps() {
+            const response = await request({
+                method: 'GET',
+                path: '/apps',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_apps');
+            }
+            return response.body;
+        },
+        async fetchAppsByType(type, options = {}) {
+            const params = new URLSearchParams();
+            if (typeof options.limit === 'number' && Number.isFinite(options.limit)) {
+                params.set('limit', String(options.limit));
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'GET',
+                path: `/apps/types/${encodeURIComponent(type)}` + (query ? `?${query}` : ''),
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_apps_by_type');
+            }
+            return response.body;
+        },
+        async fetchAppsByCreator(creatorUsername, options = {}) {
+            const normalizedCreator = creatorUsername.trim();
+            const params = new URLSearchParams();
+            if (typeof options.limit === 'number' && Number.isFinite(options.limit)) {
+                params.set('limit', String(options.limit));
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'GET',
+                path: `/apps/creators/${encodeURIComponent(normalizedCreator)}` + (query ? `?${query}` : ''),
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_apps_by_creator');
+            }
+            return response.body;
+        },
+        async fetchAppBySlug(creatorUsername, appName) {
+            const response = await request({
+                method: 'GET',
+                path: `/apps/${encodeURIComponent(creatorUsername)}/${encodeURIComponent(appName)}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_app');
+            }
+            return response.body;
+        },
+        async requestAppAccessToken(appId) {
+            const response = await request({
+                method: 'POST',
+                path: `/apps/${encodeURIComponent(String(appId))}/token`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'request_app_access_token');
+            }
+            return response.body;
+        },
+        async sendAppLog(appId, entry) {
+            const response = await request({
+                method: 'POST',
+                path: `/apps/${encodeURIComponent(String(appId))}/logs`,
+                body: entry,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'send_app_log');
+            }
+            return response.body;
+        },
+        async fetchCreatorApps() {
+            const response = await request({
+                method: 'GET',
+                path: '/creator/apps',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_creator_apps');
+            }
+            return response.body;
+        },
+        async createApp(createRequest) {
+            const response = await request({
+                method: 'POST',
+                path: '/creator/apps',
+                body: createRequest,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'create_app');
+            }
+            return response.body;
+        },
+        async updateApp(name, updateRequest, options = {}) {
+            const params = new URLSearchParams();
+            if (typeof options.creatorUsername === 'string' && options.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', options.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'PATCH',
+                path: `/creator/apps/${encodeURIComponent(name)}${query ? `?${query}` : ''}`,
+                body: updateRequest,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'update_app');
+            }
+            return response.body;
+        },
+        async uploadAppVersion(appName, options) {
+            const base = resolveBaseUrl();
+            const form = new FormData();
+            // Required field
+            form.append('version', options.version);
+            // Optional text fields
+            if (options.releaseNotes !== undefined) {
+                form.append('releaseNotes', options.releaseNotes);
+            }
+            if (options.visibility !== undefined) {
+                form.append('visibility', options.visibility);
+            }
+            if (options.surfaceTargets && options.surfaceTargets.length > 0) {
+                form.append('surfaceTargets', JSON.stringify(options.surfaceTargets));
+            }
+            if (options.entryPoint !== undefined) {
+                form.append('entryPoint', options.entryPoint);
+            }
+            if (options.setAsCurrent !== undefined) {
+                form.append('setAsCurrent', String(options.setAsCurrent));
+            }
+            if (options.externalUrl !== undefined) {
+                form.append('externalUrl', options.externalUrl);
+            }
+            // App metadata fields (for creating app if it doesn't exist)
+            if (options.displayName !== undefined) {
+                form.append('displayName', options.displayName);
+            }
+            if (options.description !== undefined) {
+                form.append('description', options.description);
+            }
+            if (options.type !== undefined) {
+                form.append('type', options.type);
+            }
+            if (options.emoji !== undefined) {
+                form.append('emoji', options.emoji);
+            }
+            if (options.color !== undefined) {
+                form.append('color', options.color);
+            }
+            // Admin-only field
+            if (options.creatorUsername !== undefined) {
+                form.append('creatorUsername', options.creatorUsername);
+            }
+            // Bundle files (HOSTED mode)
+            if (options.bundle) {
+                form.append('bundle', options.bundle);
+            }
+            if (options.source) {
+                form.append('source', options.source);
+            }
+            if (options.ecs) {
+                form.append('ecs', options.ecs);
+            }
+            if (options.server) {
+                form.append('server', options.server);
+            }
+            // Listing assets - images must be PNG, videos must be MP4
+            if (options.icon) {
+                form.append('icon', options.icon);
+            }
+            if (options.heroPortrait) {
+                form.append('heroPortrait', options.heroPortrait);
+            }
+            if (options.heroLandscape) {
+                form.append('heroLandscape', options.heroLandscape);
+            }
+            if (options.screenshotsPortrait) {
+                for (const screenshot of options.screenshotsPortrait) {
+                    form.append('screenshotsPortrait', screenshot);
+                }
+            }
+            if (options.screenshotsLandscape) {
+                for (const screenshot of options.screenshotsLandscape) {
+                    form.append('screenshotsLandscape', screenshot);
+                }
+            }
+            if (options.videosPortrait) {
+                for (const video of options.videosPortrait) {
+                    form.append('videosPortrait', video);
+                }
+            }
+            if (options.videosLandscape) {
+                for (const video of options.videosLandscape) {
+                    form.append('videosLandscape', video);
+                }
+            }
+            const path = `/creator/apps/${encodeURIComponent(appName)}/versions`;
+            const headers = new Headers();
+            if (config.clientHeaders) {
+                const clientHeaders = config.clientHeaders();
+                for (const [key, value] of Object.entries(clientHeaders)) {
+                    headers.set(key, value);
+                }
+            }
+            const token = await resolveToken();
+            if (token) {
+                headers.set('authorization', `Bearer ${token}`);
+            }
+            const response = await fetchImpl(resolveUrl(base, path), {
+                method: 'POST',
+                headers,
+                body: form,
+            });
+            const parsed = await parseResponseBody(response);
+            const apiResponse = { status: response.status, body: parsed, headers: response.headers };
+            if (response.status !== 201) {
+                handleApiError(apiResponse, 'upload_app_version');
+            }
+            return parsed;
+        },
+        async listAppVersions(creatorUsername, appName) {
+            const path = `/apps/${encodeURIComponent(creatorUsername)}/${encodeURIComponent(appName)}/versions`;
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'list_app_versions');
+            }
+            return response.body;
+        },
+        async getAppVersion(creatorUsername, appName, version) {
+            const path = `/apps/${encodeURIComponent(creatorUsername)}/${encodeURIComponent(appName)}/versions/${encodeURIComponent(version)}`;
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'get_app_version');
+            }
+            return response.body;
+        },
+        async updateAppVersion(appName, version, updates, options = {}) {
+            const params = new URLSearchParams();
+            if (typeof options.creatorUsername === 'string' && options.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', options.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const path = `/creator/apps/${encodeURIComponent(appName)}/versions/${encodeURIComponent(version)}${query ? `?${query}` : ''}`;
+            const response = await request({
+                method: 'PATCH',
+                path,
+                body: updates,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'update_app_version');
+            }
+            return response.body;
+        },
+        async deleteAppVersion(appName, version, options = {}) {
+            const params = new URLSearchParams();
+            if (typeof options.creatorUsername === 'string' && options.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', options.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const path = `/creator/apps/${encodeURIComponent(appName)}/versions/${encodeURIComponent(version)}${query ? `?${query}` : ''}`;
+            const response = await request({
+                method: 'DELETE',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'delete_app_version');
+            }
+            return response.body;
+        },
+        async createAssetVersion(name, options, mutationTarget = {}) {
+            const assetName = typeof name === 'string' ? name.trim() : '';
+            if (!assetName) {
+                throw new Error('invalid_asset_name');
+            }
+            if (!Array.isArray(options.files) || options.files.length === 0) {
+                throw new Error('missing_asset_files');
+            }
+            const form = new FormData();
+            form.set('category', options.category);
+            form.set('subcategory', options.subcategory);
+            form.set('format', options.format);
+            if (options.visibility) {
+                form.set('visibility', options.visibility);
+            }
+            if (options.sourceKind) {
+                form.set('sourceKind', options.sourceKind);
+            }
+            if (typeof options.sourceAppVersionId === 'number') {
+                form.set('sourceAppVersionId', String(options.sourceAppVersionId));
+            }
+            if (typeof options.sourceGenerationId === 'string' && options.sourceGenerationId.trim().length > 0) {
+                form.set('sourceGenerationId', options.sourceGenerationId.trim());
+            }
+            if (typeof options.shopListed === 'boolean') {
+                form.set('shopListed', options.shopListed ? 'true' : 'false');
+            }
+            if (typeof options.shopPriceCoins === 'number') {
+                form.set('shopPriceCoins', String(options.shopPriceCoins));
+            }
+            if (typeof options.displayName === 'string' && options.displayName.trim().length > 0) {
+                form.set('displayName', options.displayName.trim());
+            }
+            if (typeof options.description === 'string') {
+                form.set('description', options.description);
+            }
+            for (let index = 0; index < options.files.length; index++) {
+                const item = options.files[index];
+                const fieldName = typeof item.fieldName === 'string' && item.fieldName.trim().length > 0
+                    ? item.fieldName.trim()
+                    : 'file';
+                if (typeof item.filename === 'string' && item.filename.trim().length > 0) {
+                    form.append(fieldName, item.file, item.filename.trim());
+                }
+                else {
+                    form.append(fieldName, item.file);
+                }
+            }
+            const base = resolveBaseUrl();
+            const headers = new Headers();
+            if (config.clientHeaders) {
+                const clientHeaders = config.clientHeaders();
+                for (const [key, value] of Object.entries(clientHeaders)) {
+                    headers.set(key, value);
+                }
+            }
+            const token = await resolveToken();
+            if (token) {
+                headers.set('authorization', `Bearer ${token}`);
+            }
+            const params = new URLSearchParams();
+            if (typeof mutationTarget.creatorUsername === 'string' && mutationTarget.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', mutationTarget.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const path = `/creator/assets/${encodeURIComponent(assetName)}/versions${query ? `?${query}` : ''}`;
+            const response = await fetchImpl(resolveUrl(base, path), {
+                method: 'POST',
+                headers,
+                body: form,
+            });
+            const parsed = await parseResponseBody(response);
+            const apiResponse = { status: response.status, body: parsed, headers: response.headers };
+            if (response.status !== 201 && response.status !== 200) {
+                handleApiError(apiResponse, 'create_asset_version');
+            }
+            return parsed;
+        },
+        async listAssetCategories() {
+            const response = await request({
+                method: 'GET',
+                path: '/asset-categories',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'list_asset_categories');
+            }
+            return response.body;
+        },
+        async listAssets(options = {}) {
+            const params = new URLSearchParams();
+            if (typeof options.limit === 'number') {
+                params.set('limit', String(options.limit));
+            }
+            if (typeof options.offset === 'number') {
+                params.set('offset', String(options.offset));
+            }
+            if (typeof options.category === 'string' && options.category.trim().length > 0) {
+                params.set('category', options.category.trim());
+            }
+            if (typeof options.subcategory === 'string' && options.subcategory.trim().length > 0) {
+                params.set('subcategory', options.subcategory.trim());
+            }
+            const query = params.toString();
+            const path = `/assets${query ? `?${query}` : ''}`;
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'list_assets');
+            }
+            return response.body;
+        },
+        async listAssetsForCreator(creatorUsername, options = {}) {
+            const params = new URLSearchParams();
+            if (typeof options.limit === 'number') {
+                params.set('limit', String(options.limit));
+            }
+            if (typeof options.offset === 'number') {
+                params.set('offset', String(options.offset));
+            }
+            if (typeof options.category === 'string' && options.category.trim().length > 0) {
+                params.set('category', options.category.trim());
+            }
+            if (typeof options.subcategory === 'string' && options.subcategory.trim().length > 0) {
+                params.set('subcategory', options.subcategory.trim());
+            }
+            const query = params.toString();
+            const path = `/creators/${encodeURIComponent(creatorUsername)}/assets${query ? `?${query}` : ''}`;
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'list_assets_for_creator');
+            }
+            return response.body;
+        },
+        async fetchAssetBySlug(creatorUsername, assetName) {
+            const path = `/assets/${encodeURIComponent(creatorUsername)}/${encodeURIComponent(assetName)}`;
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_asset_by_slug');
+            }
+            return response.body;
+        },
+        async listAssetVersions(creatorUsername, assetName, options = {}) {
+            const params = new URLSearchParams();
+            if (typeof options.limit === 'number') {
+                params.set('limit', String(options.limit));
+            }
+            if (typeof options.offset === 'number') {
+                params.set('offset', String(options.offset));
+            }
+            const query = params.toString();
+            const path = `/assets/${encodeURIComponent(creatorUsername)}/${encodeURIComponent(assetName)}/versions${query ? `?${query}` : ''}`;
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'list_asset_versions');
+            }
+            return response.body;
+        },
+        async updateAsset(name, requestBody, mutationTarget = {}) {
+            const assetName = typeof name === 'string' ? name.trim() : '';
+            if (!assetName) {
+                throw new Error('invalid_asset_name');
+            }
+            const params = new URLSearchParams();
+            if (typeof mutationTarget.creatorUsername === 'string' && mutationTarget.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', mutationTarget.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'PATCH',
+                path: `/creator/assets/${encodeURIComponent(assetName)}${query ? `?${query}` : ''}`,
+                body: requestBody,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'update_asset');
+            }
+            return response.body;
+        },
+        async updateAssetVersion(name, revision, requestBody, mutationTarget = {}) {
+            const assetName = typeof name === 'string' ? name.trim() : '';
+            if (!assetName) {
+                throw new Error('invalid_asset_name');
+            }
+            const normalizedRevision = normalizeAssetRevisionInput(revision);
+            const params = new URLSearchParams();
+            if (typeof mutationTarget.creatorUsername === 'string' && mutationTarget.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', mutationTarget.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'PATCH',
+                path: `/creator/assets/${encodeURIComponent(assetName)}/versions/${encodeURIComponent(normalizedRevision)}${query ? `?${query}` : ''}`,
+                body: requestBody,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'update_asset_version');
+            }
+            return response.body;
+        },
+        async deleteAssetVersion(name, revision, mutationTarget = {}) {
+            const assetName = typeof name === 'string' ? name.trim() : '';
+            if (!assetName) {
+                throw new Error('invalid_asset_name');
+            }
+            const normalizedRevision = normalizeAssetRevisionInput(revision);
+            const params = new URLSearchParams();
+            if (typeof mutationTarget.creatorUsername === 'string' && mutationTarget.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', mutationTarget.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'DELETE',
+                path: `/creator/assets/${encodeURIComponent(assetName)}/versions/${encodeURIComponent(normalizedRevision)}${query ? `?${query}` : ''}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'delete_asset_version');
+            }
+            return response.body;
+        },
+        async deleteAsset(name, mutationTarget = {}) {
+            const assetName = typeof name === 'string' ? name.trim() : '';
+            if (!assetName) {
+                throw new Error('invalid_asset_name');
+            }
+            const params = new URLSearchParams();
+            if (typeof mutationTarget.creatorUsername === 'string' && mutationTarget.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', mutationTarget.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'DELETE',
+                path: `/creator/assets/${encodeURIComponent(assetName)}${query ? `?${query}` : ''}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'delete_asset');
+            }
+            return response.body;
+        },
+        async downloadAssetFile(creatorUsername, assetName, revision, options = {}) {
+            const creator = typeof creatorUsername === 'string' ? creatorUsername.trim() : '';
+            const name = typeof assetName === 'string' ? assetName.trim() : '';
+            if (!creator || !name) {
+                throw new Error('invalid_asset_key');
+            }
+            const normalizedRevision = normalizeAssetRevisionInput(revision);
+            const params = new URLSearchParams();
+            if (typeof options.role === 'string' && options.role.trim().length > 0) {
+                params.set('role', options.role.trim());
+            }
+            const query = params.toString();
+            const path = `/assets/${encodeURIComponent(creator)}/${encodeURIComponent(name)}/versions/${encodeURIComponent(normalizedRevision)}/file${query ? `?${query}` : ''}`;
+            const base = resolveBaseUrl();
+            const headers = new Headers();
+            if (config.clientHeaders) {
+                const clientHeaders = config.clientHeaders();
+                for (const [key, value] of Object.entries(clientHeaders)) {
+                    headers.set(key, value);
+                }
+            }
+            const token = await resolveToken();
+            if (token) {
+                headers.set('authorization', `Bearer ${token}`);
+            }
+            const response = await fetchImpl(resolveUrl(base, path), {
+                method: 'GET',
+                headers,
+            });
+            if (!response.ok) {
+                const parsed = await parseResponseBody(response);
+                handleApiError({ status: response.status, body: parsed, headers: response.headers }, 'download_asset_file');
+            }
+            return response.blob();
+        },
+        async downloadAssetSource(creatorUsername, assetName, revision) {
+            const creator = typeof creatorUsername === 'string' ? creatorUsername.trim() : '';
+            const name = typeof assetName === 'string' ? assetName.trim() : '';
+            if (!creator || !name) {
+                throw new Error('invalid_asset_key');
+            }
+            const normalizedRevision = normalizeAssetRevisionInput(revision);
+            const path = `/assets/${encodeURIComponent(creator)}/${encodeURIComponent(name)}/versions/${encodeURIComponent(normalizedRevision)}/source`;
+            const base = resolveBaseUrl();
+            const headers = new Headers();
+            if (config.clientHeaders) {
+                const clientHeaders = config.clientHeaders();
+                for (const [key, value] of Object.entries(clientHeaders)) {
+                    headers.set(key, value);
+                }
+            }
+            const token = await resolveToken();
+            if (token) {
+                headers.set('authorization', `Bearer ${token}`);
+            }
+            const response = await fetchImpl(resolveUrl(base, path), {
+                method: 'GET',
+                headers,
+            });
+            if (!response.ok) {
+                const parsed = await parseResponseBody(response);
+                handleApiError({ status: response.status, body: parsed, headers: response.headers }, 'download_asset_source');
+            }
+            const blob = await response.blob();
+            const filename = parseContentDispositionFilename(response.headers.get('content-disposition'))
+                ?? `${name}-r${normalizedRevision}-source.zip`;
+            const headerSize = response.headers.get('content-length');
+            const parsedSize = headerSize ? Number.parseInt(headerSize, 10) : Number.NaN;
+            const checksumHeader = response.headers.get('x-asset-source-checksum');
+            return {
+                blob,
+                metadata: {
+                    filename,
+                    sizeBytes: Number.isFinite(parsedSize) && parsedSize >= 0 ? parsedSize : blob.size,
+                    checksum: checksumHeader ?? null,
+                },
+            };
+        },
+        async createAssetPackVersion(name, body, mutationTarget = {}) {
+            const packName = typeof name === 'string' ? name.trim() : '';
+            if (!packName) {
+                throw new Error('invalid_pack_name');
+            }
+            const params = new URLSearchParams();
+            if (typeof mutationTarget.creatorUsername === 'string' && mutationTarget.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', mutationTarget.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'POST',
+                path: `/creator/asset-packs/${encodeURIComponent(packName)}/versions${query ? `?${query}` : ''}`,
+                body,
+            });
+            if (response.status !== 201 && response.status !== 200) {
+                handleApiError(response, 'create_asset_pack_version');
+            }
+            return response.body;
+        },
+        async uploadAssetPackVersion(name, options, mutationTarget = {}) {
+            const packName = typeof name === 'string' ? name.trim() : '';
+            if (!packName) {
+                throw new Error('invalid_pack_name');
+            }
+            if (!options || !options.request) {
+                throw new Error('invalid_pack_upload_request');
+            }
+            const requestBody = options.request;
+            const form = new FormData();
+            form.append('version', requestBody.version);
+            if (requestBody.visibility !== undefined) {
+                form.append('visibility', requestBody.visibility);
+            }
+            if (requestBody.releaseNotes !== undefined) {
+                form.append('releaseNotes', requestBody.releaseNotes);
+            }
+            if (requestBody.displayName !== undefined) {
+                form.append('displayName', requestBody.displayName);
+            }
+            if (requestBody.description !== undefined) {
+                form.append('description', requestBody.description);
+            }
+            if (requestBody.previewAppVersionId !== undefined) {
+                form.append('previewAppVersionId', String(requestBody.previewAppVersionId));
+            }
+            form.append('assets', JSON.stringify(requestBody.assets ?? []));
+            const relations = requestBody.relations;
+            if (Array.isArray(relations) && relations.length > 0) {
+                form.append('relations', JSON.stringify(relations));
+            }
+            if (options.icon) {
+                form.append('icon', options.icon);
+            }
+            if (options.heroPortrait) {
+                form.append('heroPortrait', options.heroPortrait);
+            }
+            if (options.heroLandscape) {
+                form.append('heroLandscape', options.heroLandscape);
+            }
+            if (options.screenshotsPortrait) {
+                for (const screenshot of options.screenshotsPortrait) {
+                    form.append('screenshotsPortrait', screenshot);
+                }
+            }
+            if (options.screenshotsLandscape) {
+                for (const screenshot of options.screenshotsLandscape) {
+                    form.append('screenshotsLandscape', screenshot);
+                }
+            }
+            if (options.videosPortrait) {
+                for (const video of options.videosPortrait) {
+                    form.append('videosPortrait', video);
+                }
+            }
+            if (options.videosLandscape) {
+                for (const video of options.videosLandscape) {
+                    form.append('videosLandscape', video);
+                }
+            }
+            const params = new URLSearchParams();
+            if (typeof mutationTarget.creatorUsername === 'string' && mutationTarget.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', mutationTarget.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const path = `/creator/asset-packs/${encodeURIComponent(packName)}/versions${query ? `?${query}` : ''}`;
+            const base = resolveBaseUrl();
+            const headers = new Headers();
+            if (config.clientHeaders) {
+                const clientHeaders = config.clientHeaders();
+                for (const [key, value] of Object.entries(clientHeaders)) {
+                    headers.set(key, value);
+                }
+            }
+            const token = await resolveToken();
+            if (token) {
+                headers.set('authorization', `Bearer ${token}`);
+            }
+            const response = await fetchImpl(resolveUrl(base, path), {
+                method: 'POST',
+                headers,
+                body: form,
+            });
+            const parsed = await parseResponseBody(response);
+            const apiResponse = { status: response.status, body: parsed, headers: response.headers };
+            if (response.status !== 201 && response.status !== 200) {
+                handleApiError(apiResponse, 'upload_asset_pack_version');
+            }
+            return parsed;
+        },
+        async listAssetPacks(options = {}) {
+            const params = new URLSearchParams();
+            if (typeof options.limit === 'number') {
+                params.set('limit', String(options.limit));
+            }
+            if (typeof options.offset === 'number') {
+                params.set('offset', String(options.offset));
+            }
+            if (typeof options.containsCategory === 'string' && options.containsCategory.trim().length > 0) {
+                params.set('containsCategory', options.containsCategory.trim());
+            }
+            if (typeof options.containsSubcategory === 'string' && options.containsSubcategory.trim().length > 0) {
+                params.set('containsSubcategory', options.containsSubcategory.trim());
+            }
+            const query = params.toString();
+            const path = `/asset-packs${query ? `?${query}` : ''}`;
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'list_asset_packs');
+            }
+            return response.body;
+        },
+        async listAssetPacksForCreator(creatorUsername, options = {}) {
+            const params = new URLSearchParams();
+            if (typeof options.limit === 'number') {
+                params.set('limit', String(options.limit));
+            }
+            if (typeof options.offset === 'number') {
+                params.set('offset', String(options.offset));
+            }
+            if (typeof options.containsCategory === 'string' && options.containsCategory.trim().length > 0) {
+                params.set('containsCategory', options.containsCategory.trim());
+            }
+            if (typeof options.containsSubcategory === 'string' && options.containsSubcategory.trim().length > 0) {
+                params.set('containsSubcategory', options.containsSubcategory.trim());
+            }
+            const query = params.toString();
+            const path = `/creators/${encodeURIComponent(creatorUsername)}/asset-packs${query ? `?${query}` : ''}`;
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'list_asset_packs_for_creator');
+            }
+            return response.body;
+        },
+        async fetchAssetPackBySlug(creatorUsername, packName) {
+            const path = `/asset-packs/${encodeURIComponent(creatorUsername)}/${encodeURIComponent(packName)}`;
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_asset_pack_by_slug');
+            }
+            return response.body;
+        },
+        async downloadAssetPackSource(creatorUsername, packName, version) {
+            const creator = typeof creatorUsername === 'string' ? creatorUsername.trim() : '';
+            const name = typeof packName === 'string' ? packName.trim() : '';
+            if (!creator || !name) {
+                throw new Error('invalid_pack_key');
+            }
+            const normalizedVersion = normalizeSemverInput(version);
+            const path = `/asset-packs/${encodeURIComponent(creator)}/${encodeURIComponent(name)}/versions/${encodeURIComponent(normalizedVersion)}/source`;
+            const base = resolveBaseUrl();
+            const headers = new Headers();
+            if (config.clientHeaders) {
+                const clientHeaders = config.clientHeaders();
+                for (const [key, value] of Object.entries(clientHeaders)) {
+                    headers.set(key, value);
+                }
+            }
+            const token = await resolveToken();
+            if (token) {
+                headers.set('authorization', `Bearer ${token}`);
+            }
+            const response = await fetchImpl(resolveUrl(base, path), {
+                method: 'GET',
+                headers,
+            });
+            if (!response.ok) {
+                const parsed = await parseResponseBody(response);
+                handleApiError({ status: response.status, body: parsed, headers: response.headers }, 'download_asset_pack_source');
+            }
+            const blob = await response.blob();
+            const filename = parseContentDispositionFilename(response.headers.get('content-disposition'))
+                ?? `${name}-${normalizedVersion}-source.zip`;
+            const headerSize = response.headers.get('content-length');
+            const parsedSize = headerSize ? Number.parseInt(headerSize, 10) : Number.NaN;
+            const checksumHeader = response.headers.get('x-pack-source-checksum');
+            return {
+                blob,
+                metadata: {
+                    filename,
+                    sizeBytes: Number.isFinite(parsedSize) && parsedSize >= 0 ? parsedSize : blob.size,
+                    checksum: checksumHeader ?? null,
+                },
+            };
+        },
+        async listAssetPackVersions(creatorUsername, packName, options = {}) {
+            const params = new URLSearchParams();
+            if (typeof options.limit === 'number') {
+                params.set('limit', String(options.limit));
+            }
+            if (typeof options.offset === 'number') {
+                params.set('offset', String(options.offset));
+            }
+            const query = params.toString();
+            const path = `/asset-packs/${encodeURIComponent(creatorUsername)}/${encodeURIComponent(packName)}/versions${query ? `?${query}` : ''}`;
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'list_asset_pack_versions');
+            }
+            return response.body;
+        },
+        async updateAssetPack(name, requestBody, mutationTarget = {}) {
+            const packName = typeof name === 'string' ? name.trim() : '';
+            if (!packName) {
+                throw new Error('invalid_pack_name');
+            }
+            const params = new URLSearchParams();
+            if (typeof mutationTarget.creatorUsername === 'string' && mutationTarget.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', mutationTarget.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'PATCH',
+                path: `/creator/asset-packs/${encodeURIComponent(packName)}${query ? `?${query}` : ''}`,
+                body: requestBody,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'update_asset_pack');
+            }
+            return response.body;
+        },
+        async updateAssetPackVersion(name, version, requestBody, mutationTarget = {}) {
+            const packName = typeof name === 'string' ? name.trim() : '';
+            const versionValue = typeof version === 'string' ? version.trim() : '';
+            if (!packName) {
+                throw new Error('invalid_pack_name');
+            }
+            if (!versionValue) {
+                throw new Error('invalid_pack_version');
+            }
+            const params = new URLSearchParams();
+            if (typeof mutationTarget.creatorUsername === 'string' && mutationTarget.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', mutationTarget.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'PATCH',
+                path: `/creator/asset-packs/${encodeURIComponent(packName)}/versions/${encodeURIComponent(versionValue)}${query ? `?${query}` : ''}`,
+                body: requestBody,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'update_asset_pack_version');
+            }
+            return response.body;
+        },
+        async deleteAssetPackVersion(name, version, mutationTarget = {}) {
+            const packName = typeof name === 'string' ? name.trim() : '';
+            const versionValue = typeof version === 'string' ? version.trim() : '';
+            if (!packName) {
+                throw new Error('invalid_pack_name');
+            }
+            if (!versionValue) {
+                throw new Error('invalid_pack_version');
+            }
+            const params = new URLSearchParams();
+            if (typeof mutationTarget.creatorUsername === 'string' && mutationTarget.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', mutationTarget.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'DELETE',
+                path: `/creator/asset-packs/${encodeURIComponent(packName)}/versions/${encodeURIComponent(versionValue)}${query ? `?${query}` : ''}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'delete_asset_pack_version');
+            }
+            return response.body;
+        },
+        async deleteAssetPack(name, mutationTarget = {}) {
+            const packName = typeof name === 'string' ? name.trim() : '';
+            if (!packName) {
+                throw new Error('invalid_pack_name');
+            }
+            const params = new URLSearchParams();
+            if (typeof mutationTarget.creatorUsername === 'string' && mutationTarget.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', mutationTarget.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'DELETE',
+                path: `/creator/asset-packs/${encodeURIComponent(packName)}${query ? `?${query}` : ''}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'delete_asset_pack');
+            }
+            return response.body;
+        },
+        async batchUpsertGraphRelations(body) {
+            const response = await request({
+                method: 'POST',
+                path: '/creator/graph/relations:batchUpsert',
+                body,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'batch_upsert_graph_relations');
+            }
+            return response.body;
+        },
+        async deleteApp(name, options = {}) {
+            const params = new URLSearchParams();
+            if (typeof options.creatorUsername === 'string' && options.creatorUsername.trim().length > 0) {
+                params.set('creatorUsername', options.creatorUsername.trim());
+            }
+            const query = params.toString();
+            const response = await request({
+                method: 'DELETE',
+                path: `/creator/apps/${encodeURIComponent(name)}${query ? `?${query}` : ''}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'delete_app');
+            }
+            return response.body;
+        },
+        async submitFeedback(feedbackRequest) {
+            const response = await request({
+                method: 'POST',
+                path: '/feedback',
+                body: feedbackRequest,
+            });
+            if (response.status !== 201 && response.status !== 200) {
+                handleApiError(response, 'submit_feedback');
+            }
+            return response.body;
+        },
+        async listFeedback(options = {}) {
+            const params = new URLSearchParams();
+            if (options.limit !== undefined) {
+                params.set('limit', String(options.limit));
+            }
+            if (options.offset !== undefined) {
+                params.set('offset', String(options.offset));
+            }
+            if (typeof options.source === 'string' && options.source.trim().length > 0) {
+                params.set('source', options.source.trim());
+            }
+            if (options.userId !== undefined) {
+                params.set('userId', String(options.userId));
+            }
+            const query = params.toString();
+            const path = `/feedback${query ? `?${query}` : ''}`;
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'list_feedback');
+            }
+            return response.body;
+        },
+        async deleteFeedback(id) {
+            const response = await request({
+                method: 'DELETE',
+                path: `/feedback/${encodeURIComponent(String(id))}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'delete_feedback');
+            }
+            return response.body;
+        },
+        async setSelectedProfileAsset(profileAssetRequest) {
+            const response = await request({
+                method: 'POST',
+                path: '/me/profile-asset',
+                body: profileAssetRequest,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'set_profile_asset');
+            }
+            return response.body;
+        },
+        async fetchHome() {
+            const response = await request({
+                method: 'GET',
+                path: '/home',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_home');
+            }
+            return response.body;
+        },
+        async fetchUsers() {
+            const response = await request({
+                method: 'GET',
+                path: '/admin/users',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_users');
+            }
+            return response.body;
+        },
+        async createUser(userRequest) {
+            const response = await request({
+                method: 'POST',
+                path: '/admin/users',
+                body: userRequest,
+            });
+            if (response.status !== 201 && response.status !== 200) {
+                handleApiError(response, 'create_user');
+            }
+            return response.body;
+        },
+        async batchCreateUsersFromCsv(formData) {
+            const base = resolveBaseUrl();
+            const headers = new Headers();
+            if (config.clientHeaders) {
+                const clientHeaders = config.clientHeaders();
+                for (const [key, value] of Object.entries(clientHeaders)) {
+                    headers.set(key, value);
+                }
+            }
+            const token = await resolveToken();
+            if (token) {
+                headers.set('authorization', `Bearer ${token}`);
+            }
+            const path = '/admin/users/batch-create';
+            const response = await fetchImpl(resolveUrl(base, path), {
+                method: 'POST',
+                headers,
+                body: formData,
+            });
+            const parsed = await parseResponseBody(response);
+            const apiResponse = { status: response.status, body: parsed, headers: response.headers };
+            if (response.status !== 200 && response.status !== 201) {
+                handleApiError(apiResponse, 'batch_create_users');
+            }
+            return parsed;
+        },
+        async fetchAdminUser(userId) {
+            const response = await request({
+                method: 'GET',
+                path: `/admin/users/${encodeURIComponent(String(userId))}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_admin_user');
+            }
+            return response.body;
+        },
+        async updateAdminUser(userId, updateRequest) {
+            const response = await request({
+                method: 'PATCH',
+                path: `/admin/users/${encodeURIComponent(String(userId))}`,
+                body: updateRequest,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'update_admin_user');
+            }
+            return response.body;
+        },
+        async deleteAdminUser(userId) {
+            const response = await request({
+                method: 'DELETE',
+                path: `/admin/users/${encodeURIComponent(String(userId))}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'delete_admin_user');
+            }
+            return response.body;
+        },
+        async fetchAdminApps() {
+            const response = await request({
+                method: 'GET',
+                path: '/admin/apps',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_admin_apps');
+            }
+            return response.body;
+        },
+        async fetchAdminGames() {
+            const response = await this.fetchAdminApps();
+            return { ...response, games: response.apps };
+        },
+        async updateAdminApp(id, updateRequest) {
+            const response = await request({
+                method: 'PATCH',
+                path: `/admin/apps/${encodeURIComponent(String(id))}`,
+                body: updateRequest,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'update_admin_app');
+            }
+            return response.body;
+        },
+        async deleteAdminApp(id) {
+            const response = await request({
+                method: 'DELETE',
+                path: `/admin/apps/${encodeURIComponent(String(id))}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'delete_admin_app');
+            }
+            return response.body;
+        },
+        async fetchAdminCoinPacks() {
+            const response = await request({
+                method: 'GET',
+                path: '/admin/coin-packs',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_admin_coin_packs');
+            }
+            return response.body;
+        },
+        async createAdminCoinPack(body) {
+            const response = await request({
+                method: 'POST',
+                path: '/admin/coin-packs',
+                body,
+            });
+            if (response.status !== 201) {
+                handleApiError(response, 'create_admin_coin_pack');
+            }
+            return response.body;
+        },
+        async updateAdminCoinPack(sku, body) {
+            const response = await request({
+                method: 'PATCH',
+                path: `/admin/coin-packs/${encodeURIComponent(sku)}`,
+                body,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'update_admin_coin_pack');
+            }
+            return response.body;
+        },
+        async deleteAdminCoinPack(sku) {
+            const response = await request({
+                method: 'DELETE',
+                path: `/admin/coin-packs/${encodeURIComponent(sku)}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'delete_admin_coin_pack');
+            }
+            return response.body;
+        },
+        async fetchAdminPayments(options) {
+            const params = new URLSearchParams();
+            if (options?.provider) {
+                params.set('provider', options.provider);
+            }
+            if (options?.status) {
+                const statuses = Array.isArray(options.status) ? options.status : [options.status];
+                params.set('status', statuses.join(','));
+            }
+            if (typeof options?.userId === 'number') {
+                params.set('userId', String(options.userId));
+            }
+            if (options?.coinPackSku) {
+                params.set('coinPackSku', options.coinPackSku);
+            }
+            if (options?.from) {
+                const fromValue = options.from instanceof Date ? options.from.toISOString() : options.from;
+                params.set('from', fromValue);
+            }
+            if (options?.to) {
+                const toValue = options.to instanceof Date ? options.to.toISOString() : options.to;
+                params.set('to', toValue);
+            }
+            if (typeof options?.limit === 'number') {
+                params.set('limit', String(options.limit));
+            }
+            if (typeof options?.offset === 'number') {
+                params.set('offset', String(options.offset));
+            }
+            const query = params.toString();
+            const path = query ? `/admin/payments?${query}` : '/admin/payments';
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_admin_payments');
+            }
+            return response.body;
+        },
+        async fetchAdminPayment(paymentId) {
+            const response = await request({
+                method: 'GET',
+                path: `/admin/payments/${encodeURIComponent(String(paymentId))}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_admin_payment');
+            }
+            return response.body;
+        },
+        async refundAdminPayment(paymentId, body) {
+            const response = await request({
+                method: 'POST',
+                path: `/admin/payments/${encodeURIComponent(String(paymentId))}/refund`,
+                body,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'refund_admin_payment');
+            }
+            return response.body;
+        },
+        async reconcileAdminPayment(paymentId) {
+            const response = await request({
+                method: 'POST',
+                path: `/admin/payments/${encodeURIComponent(String(paymentId))}/reconcile`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'reconcile_admin_payment');
+            }
+            return response.body;
+        },
+        async fetchAdminCoinTransactions(options) {
+            const params = new URLSearchParams();
+            if (options?.limit !== undefined) {
+                params.set('limit', String(options.limit));
+            }
+            if (options?.offset !== undefined) {
+                params.set('offset', String(options.offset));
+            }
+            const query = params.toString();
+            const path = query ? `/admin/coin-transactions?${query}` : '/admin/coin-transactions';
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_admin_coin_transactions');
+            }
+            return response.body;
+        },
+        async fetchAdminAiGenerations(options) {
+            const params = new URLSearchParams();
+            if (options?.limit !== undefined) {
+                params.set('limit', String(options.limit));
+            }
+            if (options?.offset !== undefined) {
+                params.set('offset', String(options.offset));
+            }
+            const query = params.toString();
+            const path = query ? `/admin/ai-generations?${query}` : '/admin/ai-generations';
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_admin_ai_generations');
+            }
+            return response.body;
+        },
+        async fetchAdminAiGeneration(id) {
+            const response = await request({
+                method: 'GET',
+                path: `/admin/ai-generations/${id}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_admin_ai_generation');
+            }
+            return response.body;
+        },
+        async migrateAdminAppStorage(requestBody) {
+            const response = await request({
+                method: 'POST',
+                path: '/admin/migrations/app-storage-v0-9-0',
+                body: requestBody,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'admin_storage_migration');
+            }
+            return response.body;
+        },
+        async fetchCreatorBootstrap() {
+            const response = await request({
+                method: 'GET',
+                path: '/creator/bootstrap',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_creator_bootstrap');
+            }
+            return response.body;
+        },
+        async fetchRemixScaffold(creatorUsername, appName) {
+            const response = await request({
+                method: 'GET',
+                path: `/creator/apps/${encodeURIComponent(creatorUsername)}/${encodeURIComponent(appName)}/remix`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_remix_scaffold');
+            }
+            return response.body;
+        },
+        async fetchTemplateScaffold(namespace, slug) {
+            const response = await request({
+                method: 'GET',
+                path: `/creator/templates/${encodeURIComponent(namespace)}/${encodeURIComponent(slug)}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_template_scaffold');
+            }
+            return response.body;
+        },
+        async fetchCoinShop() {
+            const response = await request({
+                method: 'GET',
+                path: '/shop',
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_shop');
+            }
+            return response.body;
+        },
+        async createCoinPackCheckoutSession(sku) {
+            const normalizedSku = sku.trim();
+            if (!normalizedSku) {
+                throw new Error('invalid_coin_pack_sku');
+            }
+            const response = await request({
+                method: 'POST',
+                path: `/shop/coin-packs/${encodeURIComponent(normalizedSku)}/checkout-session`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'create_coin_pack_checkout_session');
+            }
+            return response.body;
+        },
+        async fetchCoinPackCheckoutStatus(sessionId) {
+            const normalizedSessionId = sessionId.trim();
+            if (!normalizedSessionId) {
+                throw new Error('invalid_checkout_session_id');
+            }
+            const response = await request({
+                method: 'GET',
+                path: `/shop/coin-packs/checkout-session/${encodeURIComponent(normalizedSessionId)}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_coin_pack_checkout_status');
+            }
+            return response.body;
+        },
+        async purchaseAsset(body) {
+            const response = await request({
+                method: 'POST',
+                path: '/purchase',
+                body,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'purchase_asset');
+            }
+            return response.body;
+        },
+        async purchaseIap(body) {
+            const response = await request({
+                method: 'POST',
+                path: '/iap/purchase',
+                body,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'purchase_iap');
+            }
+            return response.body;
+        },
+        async fetchIapReceipts(params) {
+            const query = buildIapQuery(params);
+            const path = query ? `/iap/receipts?${query}` : '/iap/receipts';
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_iap_receipts');
+            }
+            return response.body;
+        },
+        async cancelIapReceipt(receiptId) {
+            const response = await request({
+                method: 'POST',
+                path: `/iap/receipts/${encodeURIComponent(String(receiptId))}/cancel`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'cancel_iap_receipt');
+            }
+            return response.body;
+        },
+        async fetchAppIapReceipts(params) {
+            const query = buildIapQuery(params);
+            const path = query ? `/app/iap/receipts?${query}` : '/app/iap/receipts';
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_app_iap_receipts');
+            }
+            return response.body;
+        },
+        async consumeAppIapReceipt(receiptId) {
+            const response = await request({
+                method: 'POST',
+                path: `/app/iap/receipts/${encodeURIComponent(String(receiptId))}/consume`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'consume_app_iap_receipt');
+            }
+            return response.body;
+        },
+        async grantAppIapReceipt(receiptId) {
+            const response = await request({
+                method: 'POST',
+                path: `/app/iap/receipts/${encodeURIComponent(String(receiptId))}/grant`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'grant_app_iap_receipt');
+            }
+            return response.body;
+        },
+        async cancelAppIapReceipt(receiptId) {
+            const response = await request({
+                method: 'POST',
+                path: `/app/iap/receipts/${encodeURIComponent(String(receiptId))}/cancel`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'cancel_app_iap_receipt');
+            }
+            return response.body;
+        },
+        async fetchCoinTransactions(options) {
+            const params = new URLSearchParams();
+            if (options?.limit !== undefined) {
+                params.set('limit', String(options.limit));
+            }
+            if (options?.offset !== undefined) {
+                params.set('offset', String(options.offset));
+            }
+            const query = params.toString();
+            const path = query ? `/transactions?${query}` : '/transactions';
+            const response = await request({
+                method: 'GET',
+                path,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_coin_transactions');
+            }
+            return response.body;
+        },
+        async fetchAiGeneration(id) {
+            const response = await request({
+                method: 'GET',
+                path: `/ai-generations/${encodeURIComponent(id)}`,
+            });
+            if (response.status !== 200) {
+                handleApiError(response, 'fetch_ai_generation');
+            }
+            return response.body;
+        },
+    };
+}