@yoonion/mimi-seed-mcp 0.19.0 → 0.19.2

package/dist/checks/billing.js

@@ -0,0 +1,307 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const BILLING_MODULE = /com\.android\.billingclient:billing(?:-ktx)?/;
+const LITERAL_DEPENDENCY = /com\.android\.billingclient:billing(?:-ktx)?:([0-9]+(?:\.[0-9A-Za-z_-]+){0,3})/g;
+const VARIABLE_DEPENDENCY = /com\.android\.billingclient:billing(?:-ktx)?:\$\{?([A-Za-z_][A-Za-z0-9_.-]*)\}?/g;
+const VERSION_ASSIGNMENT = /(?:^|\s)([A-Za-z_][A-Za-z0-9_.-]*)\s*(?:=|:)\s*["']([0-9]+(?:\.[0-9A-Za-z_-]+){0,3})["']/gm;
+const BILLING_SUPPORT_SCHEDULE = [
+    { major: 5, submissionDeadline: '2024-08-31', extensionDeadline: '2024-11-01' },
+    { major: 6, submissionDeadline: '2025-08-31', extensionDeadline: '2025-11-01' },
+    { major: 7, submissionDeadline: '2026-08-31', extensionDeadline: '2026-11-01' },
+    { major: 8, submissionDeadline: '2027-08-31', extensionDeadline: '2027-11-01' },
+    { major: 9, submissionDeadline: '2028-08-31', extensionDeadline: '2028-11-01' },
+];
+const SKIP_DIRS = new Set([
+    '.git',
+    '.gradle',
+    '.idea',
+    'build',
+    'dist',
+    'node_modules',
+    'Pods',
+    'DerivedData',
+]);
+async function walk(root, maxDepth = 7) {
+    const result = [];
+    async function visit(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (!SKIP_DIRS.has(entry.name))
+                    await visit(path.join(dir, entry.name), depth + 1);
+            }
+            else if (entry.isFile()
+                && (entry.name === 'build.gradle'
+                    || entry.name === 'build.gradle.kts'
+                    || entry.name === 'libs.versions.toml')) {
+                result.push(path.join(dir, entry.name));
+            }
+        }
+    }
+    await visit(root, 0);
+    return result;
+}
+function parseCatalog(text) {
+    const versions = new Map();
+    const libraries = new Map();
+    const bundles = new Map();
+    let section = '';
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.replace(/\s+#.*$/, '').trim();
+        if (!line)
+            continue;
+        const sectionMatch = line.match(/^\[([^\]]+)]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1];
+            continue;
+        }
+        if (section === 'versions') {
+            const match = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*["']([^"']+)["']/);
+            if (match)
+                versions.set(match[1], match[2]);
+            continue;
+        }
+        if (section === 'bundles') {
+            const match = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*\[([^\]]*)]/);
+            if (match) {
+                bundles.set(match[1], [...match[2].matchAll(/["']([^"']+)["']/g)].map((item) => item[1]));
+            }
+            continue;
+        }
+        if (section !== 'libraries')
+            continue;
+        const shorthand = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*["']([^"']+)["']/);
+        if (shorthand) {
+            const coordinates = shorthand[2].split(':');
+            libraries.set(shorthand[1], {
+                module: coordinates.length >= 2 ? `${coordinates[0]}:${coordinates[1]}` : undefined,
+                version: coordinates.length >= 3 ? coordinates.slice(2).join(':') : undefined,
+            });
+            continue;
+        }
+        const match = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*\{(.+)}\s*$/);
+        if (!match)
+            continue;
+        const body = match[2];
+        const explicitModule = body.match(/module\s*=\s*["']([^"']+)["']/)?.[1];
+        const group = body.match(/group\s*=\s*["']([^"']+)["']/)?.[1];
+        const name = body.match(/name\s*=\s*["']([^"']+)["']/)?.[1];
+        const module = explicitModule ?? (group && name ? `${group}:${name}` : undefined);
+        const version = body.match(/(?:^|,)\s*version\s*=\s*["']([^"']+)["']/)?.[1];
+        const versionRef = body.match(/version\.ref\s*=\s*["']([^"']+)["']/)?.[1];
+        libraries.set(match[1], { module, version, versionRef });
+    }
+    return { versions, libraries, bundles };
+}
+function collectVariables(text) {
+    const result = new Map();
+    for (const match of text.matchAll(VERSION_ASSIGNMENT))
+        result.set(match[1], match[2]);
+    return result;
+}
+function normalizeAlias(alias) {
+    return alias.replace(/^libs\./, '').replace(/\./g, '-');
+}
+function majorOf(version) {
+    const major = Number.parseInt(version.split('.')[0], 10);
+    return Number.isFinite(major) ? major : null;
+}
+function policyAt(now) {
+    const deadlineEnd = (date) => new Date(`${date}T23:59:59.999Z`);
+    const next = BILLING_SUPPORT_SCHEDULE.find((row) => now <= deadlineEnd(row.submissionDeadline));
+    const lastExpired = [...BILLING_SUPPORT_SCHEDULE]
+        .filter((row) => now > deadlineEnd(row.submissionDeadline))
+        .at(-1);
+    return {
+        minimumSupportedMajor: next?.major ?? null,
+        submissionDeadline: lastExpired?.submissionDeadline ?? BILLING_SUPPORT_SCHEDULE[0].submissionDeadline,
+        extensionDeadline: lastExpired?.extensionDeadline ?? BILLING_SUPPORT_SCHEDULE[0].extensionDeadline,
+        latestKnownMajor: BILLING_SUPPORT_SCHEDULE.at(-1).major,
+        scheduleCurrent: Boolean(next),
+        knownSchedule: BILLING_SUPPORT_SCHEDULE.map((row) => ({ ...row })),
+        sourceUrl: 'https://developer.android.com/google/play/billing/deprecation-faq',
+    };
+}
+function scheduleForMajor(major) {
+    return BILLING_SUPPORT_SCHEDULE.find((row) => row.major === major);
+}
+function catalogScope(file) {
+    const parent = path.dirname(file);
+    return path.basename(parent) === 'gradle' ? path.dirname(parent) : parent;
+}
+function isWithin(scope, file) {
+    const relative = path.relative(scope, file);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+export async function checkBillingCompliance(projectPath, now = new Date()) {
+    const root = path.resolve(projectPath);
+    let rootStat;
+    try {
+        rootStat = await fs.stat(root);
+    }
+    catch {
+        throw new Error(`Android project path does not exist or is not readable: ${root}`);
+    }
+    if (!rootStat.isDirectory())
+        throw new Error(`Android project path is not a directory: ${root}`);
+    const files = await walk(root);
+    const texts = new Map();
+    for (const file of files)
+        texts.set(file, await fs.readFile(file, 'utf8'));
+    const catalogs = files
+        .filter((file) => path.basename(file) === 'libs.versions.toml')
+        .map((file) => ({ file, scope: catalogScope(file), info: parseCatalog(texts.get(file) ?? '') }));
+    const variablesByFile = new Map();
+    for (const [file, text] of texts) {
+        if (path.basename(file) === 'libs.versions.toml')
+            continue;
+        variablesByFile.set(file, collectVariables(text));
+    }
+    const catalogFor = (file) => catalogs
+        .filter((entry) => isWithin(entry.scope, file))
+        .sort((left, right) => right.scope.length - left.scope.length)[0]?.info
+        ?? (catalogs.length === 1 ? catalogs[0].info : undefined);
+    const variableFor = (file, key) => [...variablesByFile.entries()]
+        .filter(([candidate]) => candidate === file || isWithin(path.dirname(candidate), file))
+        .sort(([left], [right]) => path.dirname(right).length - path.dirname(left).length)
+        .map(([, variables]) => variables.get(key))
+        .find((value) => value !== undefined);
+    const evidence = [];
+    for (const [file, text] of texts) {
+        const relative = path.relative(root, file).replace(/\\/g, '/');
+        if (path.basename(file) === 'libs.versions.toml') {
+            continue;
+        }
+        const catalog = catalogFor(file);
+        for (const match of text.matchAll(LITERAL_DEPENDENCY)) {
+            evidence.push({
+                file: relative,
+                module: match[0].slice(0, match[0].lastIndexOf(':')),
+                version: match[1],
+                source: 'literal',
+            });
+        }
+        for (const match of text.matchAll(VARIABLE_DEPENDENCY)) {
+            const version = variableFor(file, match[1]);
+            evidence.push({
+                file: relative,
+                module: match[0].slice(0, match[0].lastIndexOf(':')),
+                version,
+                expression: match[1],
+                source: version ? 'variable' : 'unresolved',
+            });
+        }
+        for (const bundleMatch of text.matchAll(/\blibs\.bundles\.([A-Za-z0-9_.-]+)/g)) {
+            const bundleAlias = normalizeAlias(bundleMatch[1]);
+            const libraryAliases = catalog?.bundles.get(bundleAlias) ?? catalog?.bundles.get(bundleMatch[1]) ?? [];
+            for (const libraryAlias of libraryAliases) {
+                const normalizedLibraryAlias = normalizeAlias(libraryAlias);
+                const lib = catalog?.libraries.get(normalizedLibraryAlias) ?? catalog?.libraries.get(libraryAlias);
+                if (!lib?.module || !BILLING_MODULE.test(lib.module))
+                    continue;
+                const version = lib.version ?? (lib.versionRef ? catalog?.versions.get(lib.versionRef) : undefined);
+                if (!evidence.some((row) => row.file === relative && row.expression === bundleMatch[0] && row.module === lib.module)) {
+                    evidence.push({
+                        file: relative,
+                        module: lib.module,
+                        version,
+                        expression: bundleMatch[0],
+                        source: version ? 'version_catalog' : 'unresolved',
+                    });
+                }
+            }
+        }
+        for (const aliasMatch of text.matchAll(/\blibs\.([A-Za-z0-9_.-]+)/g)) {
+            if (aliasMatch[1].startsWith('bundles.'))
+                continue;
+            const alias = normalizeAlias(aliasMatch[1]);
+            const lib = catalog?.libraries.get(alias) ?? catalog?.libraries.get(aliasMatch[1]);
+            if (!lib?.module || !BILLING_MODULE.test(lib.module))
+                continue;
+            const version = lib.version ?? (lib.versionRef ? catalog?.versions.get(lib.versionRef) : undefined);
+            if (!evidence.some((row) => row.file === relative && row.expression === aliasMatch[0])) {
+                evidence.push({
+                    file: relative,
+                    module: lib.module,
+                    version,
+                    expression: aliasMatch[0],
+                    source: version ? 'version_catalog' : 'unresolved',
+                });
+            }
+        }
+        if (BILLING_MODULE.test(text) && !evidence.some((row) => row.file === relative)) {
+            evidence.push({
+                file: relative,
+                module: 'com.android.billingclient:billing',
+                expression: 'Billing dependency found but version could not be resolved',
+                source: 'unresolved',
+            });
+        }
+    }
+    const detectedVersions = [...new Set(evidence.flatMap((row) => row.version ? [row.version] : []))].sort();
+    const policy = policyAt(now);
+    const majors = detectedVersions.map(majorOf).filter((major) => major !== null);
+    const unresolved = evidence.some((row) => !row.version);
+    let status;
+    let summary;
+    const actions = [];
+    if (evidence.length === 0) {
+        status = 'not_used';
+        summary = 'Google Play Billing dependency was not found in the scanned Gradle project.';
+    }
+    else if (!policy.scheduleCurrent || policy.minimumSupportedMajor === null) {
+        status = 'unresolved';
+        summary = `The official schedule embedded in this release ends at Billing Library ${policy.latestKnownMajor}; current policy must be refreshed from the source.`;
+        actions.push('Check the official Billing deprecation table and update Mimi Seed before relying on this result.');
+    }
+    else if (majors.some((major) => major < policy.minimumSupportedMajor)) {
+        status = 'blocker';
+        summary = `Billing Library ${detectedVersions.join(', ')} is below the submission minimum major ${policy.minimumSupportedMajor}.`;
+        actions.push(`Upgrade to a supported Billing Library before submitting a new app or update.`);
+        for (const major of [...new Set(majors.filter((value) => value < policy.minimumSupportedMajor))].sort()) {
+            const schedule = scheduleForMajor(major);
+            actions.push(schedule
+                ? `Billing Library ${major}: standard deadline ${schedule.submissionDeadline}; extension deadline ${schedule.extensionDeadline} only if Google granted it in Play Console.`
+                : `Billing Library ${major}: its deadline predates the embedded official table; no active extension should be assumed.`);
+        }
+    }
+    else if (unresolved || majors.length === 0) {
+        status = 'unresolved';
+        summary = 'A Billing dependency was found, but at least one version expression could not be resolved statically.';
+        actions.push('Resolve the reported Gradle variable or version catalog alias and run the check again.');
+    }
+    else if (majors.some((major) => major === policy.minimumSupportedMajor)) {
+        status = 'warning';
+        summary = `Billing Library ${detectedVersions.join(', ')} is currently supported but is the next major scheduled for deprecation.`;
+        const nextDeadline = scheduleForMajor(policy.minimumSupportedMajor);
+        if (nextDeadline)
+            actions.push(`Plan an upgrade before ${nextDeadline.submissionDeadline}.`);
+    }
+    else {
+        status = 'pass';
+        summary = `Billing Library ${detectedVersions.join(', ')} satisfies the current submission policy.`;
+    }
+    return {
+        projectPath: root,
+        checkedAt: now.toISOString(),
+        status,
+        detectedVersions,
+        evidence,
+        policy,
+        summary,
+        actions,
+        upgrade: {
+            installCommand: 'android skills add play-billing-library-version-upgrade',
+            prompt: 'Help me upgrade my Play Billing Library implementation.',
+            automaticExecution: false,
+        },
+    };
+}

package/dist/checks/risks.d.ts

@@ -8,5 +8,8 @@ export interface SubmissionRisk {
     fixUrl?: string;
 }
 export declare function checkPlayStoreRisks(auth: OAuth2Client, packageName: string, language?: string): Promise<SubmissionRisk[]>;
-export declare function checkAppStoreRisks(appId: string): Promise<SubmissionRisk[]>;
+export declare function checkAppStoreRisks(appId: string, expected?: {
+    socialMedia?: boolean;
+    socialMediaAgeRestricted?: boolean;
+}): Promise<SubmissionRisk[]>;
 export declare function formatRisks(risks: SubmissionRisk[], platform: string): string;

package/dist/checks/risks.js

@@ -1,5 +1,6 @@
 import { publisher, withEdit } from '../playstore/tools.js';
 import { apiGet } from '../appstore/tools.js';
+import { isNotFound } from '../appstore/http.js';
 const APPSTORE_EDITABLE_STATES = 'PREPARE_FOR_SUBMISSION,DEVELOPER_REJECTED,METADATA_REJECTED,REJECTED';
 export async function checkPlayStoreRisks(auth, packageName, language = 'ko-KR') {
     const risks = [];
@@ -72,7 +73,7 @@ async function safeGet(call, risks, code, title) {
     }
 }
 const APP_INFO_LIVE_STATE = 'READY_FOR_DISTRIBUTION';
-export async function checkAppStoreRisks(appId) {
+export async function checkAppStoreRisks(appId, expected = {}) {
     const risks = [];
     const versions = await safeGet(() => apiGet(`/apps/${appId}/appStoreVersions`, {
         'filter[appStoreState]': APPSTORE_EDITABLE_STATES,
@@ -140,10 +141,25 @@ export async function checkAppStoreRisks(appId) {
         const stateOf = (i) => i.attributes?.state ?? i.attributes?.appStoreState ?? '';
         const editable = infos.find((i) => stateOf(i) !== APP_INFO_LIVE_STATE) ?? infos[0];
         if (editable) {
-            const localizations = await safeGet(() => apiGet(`/appInfos/${editable.id}/appInfoLocalizations`, {
-                'fields[appInfoLocalizations]': 'locale,privacyPolicyUrl,privacyPolicyText',
-                'limit': '200',
-            }), risks, 'PRIVACY', '개인정보 로컬라이제이션');
+            const [localizations, ageRating] = await Promise.all([
+                safeGet(() => apiGet(`/appInfos/${editable.id}/appInfoLocalizations`, {
+                    'fields[appInfoLocalizations]': 'locale,privacyPolicyUrl,privacyPolicyText',
+                    'limit': '200',
+                }), risks, 'PRIVACY', '개인정보 로컬라이제이션'),
+                safeGet(async () => {
+                    try {
+                        return await apiGet(`/appInfos/${editable.id}/ageRatingDeclaration`, {
+                            'fields[ageRatingDeclarations]': 'userGeneratedContent,socialMedia,socialMediaAgeRestricted,ageAssurance',
+                        });
+                    }
+                    catch (error) {
+                        // A 404 means the declaration is genuinely absent, not that the check is unknown.
+                        if (isNotFound(error))
+                            return { data: null };
+                        throw error;
+                    }
+                }, risks, 'AGE_RATING_SOCIAL', '연령등급 소셜 미디어 응답'),
+            ]);
             if (localizations) {
                 const locs = (localizations.data ?? []);
                 const hasPrivacy = locs.some((l) => l.attributes?.privacyPolicyUrl || l.attributes?.privacyPolicyText);
@@ -151,6 +167,63 @@ export async function checkAppStoreRisks(appId) {
                     risks.push({ level: 'blocker', code: 'NO_PRIVACY', title: '개인정보처리방침 URL 없음', detail: 'App Store 가이드라인 5.1.1 — 필수 항목입니다. 모든 로컬라이제이션에서 privacyPolicyUrl 또는 privacyPolicyText 중 하나를 입력하세요.' });
                 }
             }
+            if (ageRating) {
+                const declaration = ageRating.data?.attributes ?? {};
+                if (declaration.socialMedia === undefined || declaration.socialMediaAgeRestricted === undefined) {
+                    risks.push({
+                        level: 'blocker',
+                        code: 'SOCIAL_MEDIA_ANSWERS_MISSING',
+                        title: '연령등급 소셜 미디어 질문 미응답',
+                        detail: '2026년 9월부터 신규 앱·업데이트 제출에 socialMedia와 socialMediaAgeRestricted 응답이 필요합니다.',
+                        fixUrl: 'https://developer.apple.com/news/?id=tlur8uvi',
+                    });
+                }
+                if (declaration.socialMediaAgeRestricted === true && declaration.socialMedia !== true) {
+                    risks.push({
+                        level: 'blocker',
+                        code: 'SOCIAL_MEDIA_AGE_RESTRICTION_MISMATCH',
+                        title: '13세 미만 제한 응답 불일치',
+                        detail: 'socialMediaAgeRestricted=true는 socialMedia=true인 앱에서만 의미가 있습니다.',
+                    });
+                }
+                if (declaration.socialMediaAgeRestricted === true && declaration.ageAssurance !== true) {
+                    risks.push({
+                        level: 'blocker',
+                        code: 'SOCIAL_MEDIA_AGE_ASSURANCE_MISSING',
+                        title: '13세 미만 소셜 기능 제한에 연령 확인이 없음',
+                        detail: 'Apple은 socialMediaAgeRestricted=true인 경우 최소한 Declared Age Range API로 연령 범위를 확인하도록 요구합니다. ageAssurance 응답과 실제 구현을 확인하세요.',
+                        fixUrl: 'https://developer.apple.com/help/app-store-connect/reference/app-information/age-ratings-values-and-definitions',
+                    });
+                }
+                if (expected.socialMedia !== undefined
+                    && declaration.socialMedia !== undefined
+                    && declaration.socialMedia !== expected.socialMedia) {
+                    risks.push({
+                        level: 'blocker',
+                        code: 'SOCIAL_MEDIA_CAPABILITY_MISMATCH',
+                        title: '앱 기능과 App Store 소셜 미디어 응답 불일치',
+                        detail: `프로젝트 기능 선언은 socialMedia=${expected.socialMedia}이지만 App Store Connect는 ${String(declaration.socialMedia)}입니다.`,
+                    });
+                }
+                if (expected.socialMediaAgeRestricted !== undefined
+                    && declaration.socialMediaAgeRestricted !== undefined
+                    && declaration.socialMediaAgeRestricted !== expected.socialMediaAgeRestricted) {
+                    risks.push({
+                        level: 'blocker',
+                        code: 'SOCIAL_MEDIA_AGE_GATE_MISMATCH',
+                        title: '13세 미만 기능 제한과 App Store 응답 불일치',
+                        detail: `프로젝트 기능 선언은 socialMediaAgeRestricted=${expected.socialMediaAgeRestricted}이지만 App Store Connect는 ${String(declaration.socialMediaAgeRestricted)}입니다.`,
+                    });
+                }
+                if (declaration.userGeneratedContent && declaration.socialMedia === false) {
+                    risks.push({
+                        level: 'warning',
+                        code: 'UGC_WITHOUT_SOCIAL_MEDIA',
+                        title: 'UGC는 있으나 소셜 미디어 기능은 없음으로 응답',
+                        detail: '피드·좋아요·댓글·공유·발견 기능이 있다면 socialMedia 응답을 true로 바꿔야 합니다.',
+                    });
+                }
+            }
         }
     }
     return risks;

package/dist/firebase/remote-config.d.ts

@@ -0,0 +1,163 @@
+import type { OAuth2Client } from 'google-auth-library';
+interface OptionalResult<T> {
+    available: boolean;
+    data?: T;
+    error?: string;
+}
+interface RemoteConfigTemplate {
+    parameters?: Record<string, unknown>;
+    parameterGroups?: Record<string, unknown>;
+    conditions?: unknown[];
+    version?: {
+        versionNumber?: string;
+        updateTime?: string;
+        updateUser?: {
+            email?: string;
+        };
+        updateOrigin?: string;
+        updateType?: string;
+    };
+}
+interface PagedItems<T> {
+    items: T[];
+    pages: number;
+    truncated: boolean;
+}
+export declare function countStates(items: Array<{
+    state?: string;
+}>): Record<string, number>;
+export declare function estimateRemoteConfigDailyCost(fetches: number): number;
+export declare function remoteConfigUsageLevel(fetches: number): 'ok' | 'warning' | 'critical';
+export declare function getRemoteConfigOverview(auth: OAuth2Client, input: {
+    projectId: string;
+    namespace?: string;
+    days?: number;
+}): Promise<{
+    projectId: string;
+    namespace: string;
+    pricingPolicy: {
+        effectiveDate: string;
+        noCostDailyFetches: number;
+        firstPaidTier: {
+            from: number;
+            to: number;
+            usdPerRequest: number;
+        };
+        secondPaidTier: {
+            from: number;
+            usdPerRequest: number;
+        };
+        transitionNotice: string;
+        sourceUrl: string;
+    };
+    billing: {
+        readonly available: false;
+        readonly error: string;
+    } | {
+        available: boolean;
+        plan: string;
+        billingEnabled: boolean;
+    };
+    usage: OptionalResult<{
+        date: string;
+        fetches: number;
+    }[]> | {
+        available: boolean;
+        metric: string;
+        days: {
+            date: string;
+            fetches: number;
+        }[];
+        latest: {
+            utilizationPercent: number;
+            level: "ok" | "warning" | "critical";
+            projectedStandardDailyCostUsd: number;
+            date: string;
+            fetches: number;
+        } | null;
+        peak: {
+            utilizationPercent: number;
+            level: "ok" | "warning" | "critical";
+            projectedStandardDailyCostUsd: number;
+            date: string;
+            fetches: number;
+        } | null;
+    };
+    template: OptionalResult<RemoteConfigTemplate> | {
+        available: boolean;
+        version: {
+            versionNumber?: string;
+            updateTime?: string;
+            updateUser?: {
+                email?: string;
+            };
+            updateOrigin?: string;
+            updateType?: string;
+        } | null;
+        parameterCount: number;
+        parameterGroupCount: number;
+        conditionCount: number;
+    };
+    experiments: OptionalResult<PagedItems<{
+        name?: string;
+        state?: string;
+        startTime?: string;
+        endTime?: string;
+        lastUpdateTime?: string;
+        definition?: unknown;
+    }>> | {
+        available: boolean;
+        total: number;
+        stateCounts: Record<string, number>;
+        active: {
+            name: string | undefined;
+            displayName: string | undefined;
+            state: string | undefined;
+            startTime: string | undefined;
+            endTime: string | undefined;
+            lastUpdateTime: string | undefined;
+        }[];
+        recent: {
+            name: string | undefined;
+            displayName: string | undefined;
+            state: string | undefined;
+            startTime: string | undefined;
+            endTime: string | undefined;
+            lastUpdateTime: string | undefined;
+        }[];
+        pages: number;
+        truncated: boolean;
+    };
+    rollouts: OptionalResult<PagedItems<{
+        name?: string;
+        state?: string;
+        startTime?: string;
+        endTime?: string;
+        lastUpdateTime?: string;
+        definition?: unknown;
+    }>> | {
+        available: boolean;
+        total: number;
+        stateCounts: Record<string, number>;
+        active: {
+            name: string | undefined;
+            displayName: string | undefined;
+            state: string | undefined;
+            startTime: string | undefined;
+            endTime: string | undefined;
+            lastUpdateTime: string | undefined;
+        }[];
+        recent: {
+            name: string | undefined;
+            displayName: string | undefined;
+            state: string | undefined;
+            startTime: string | undefined;
+            endTime: string | undefined;
+            lastUpdateTime: string | undefined;
+        }[];
+        pages: number;
+        truncated: boolean;
+    };
+    warnings: string[];
+}>;
+export {};