@storystick/cli 0.0.0-stage → 0.2.0-rc.0

package/dist/commands/content.js

@@ -0,0 +1,107 @@
+import { CONTENT_IMPORT_CONFLICT, DELIVERY_UNAVAILABLE } from '@storystick/types/errors/codes';
+import { resolve } from 'node:path';
+import { readContentImport, prepareContentImportAssets, importRunIdentity, prepareContentImport, applyContentImport, verifyContentImport, contentImportTransport } from '../content-import.js';
+import { requireProjectConnection } from '../project-connection.js';
+import { resolveCliRuntimeConfig } from '../runtime-config.js';
+import { StorystickError } from '../cli-error.js';
+import { configureOutput, emitJsonResult, exitJsonFailure, exitWithError, getOutputMode, logMessage, logOutput, withInterrupt } from '../output.js';
+import { readAssetImport, prepareAssetImport, applyAssetImport, assetImportTransport, uploadBudgetTransport, readUploadBudget } from '../asset-import.js';
+export async function runContent(action, target, options) {
+    configureOutput({ json: options.json === true });
+    const { signal, dispose } = withInterrupt();
+    const command = `content ${action}`;
+    try {
+        const root = resolve(options.root ?? '.'), project = options.project ?? requireProjectConnection(root).shortId;
+        if (!/^[0-9a-hjkmnp-tv-z]{8}$/.test(project))
+            throw new Error('Expected a Storystick project short ID.');
+        const runtime = resolveCliRuntimeConfig({ rootDir: root });
+        const transport = contentImportTransport(project, { signal, rootDir: root });
+        let result;
+        if (options.renew && (action !== 'import-asset' || !options.apply))
+            throw new Error('--renew <upload-session-id> requires content import-asset --apply.');
+        if (action === 'upload-budget' || action === 'upload-budget-cancel') {
+            if (options.resume || options.newRun)
+                throw new Error('Document import flags do not apply to upload budgets.');
+            const budget = uploadBudgetTransport(project, { signal, rootDir: root });
+            if (action === 'upload-budget-cancel' || !target) {
+                if (options.apply || options.dryRun || options.plan || (action === 'upload-budget-cancel' && !target))
+                    throw new Error('Use content upload-budget for status, or content upload-budget-cancel <budget-id>.');
+                result = await budget(action === 'upload-budget-cancel' ? { operation: 'cancel', requestId: target } : { operation: 'status' });
+            }
+            else {
+                if (Boolean(options.dryRun) === Boolean(options.apply) || (options.apply && !options.plan))
+                    throw new Error('Use content upload-budget <budget.json> with --dry-run or --apply --plan <digest>.');
+                const requested = await readUploadBudget(resolve(root, target));
+                result = await budget({ operation: options.apply ? 'grant' : 'plan', ...requested, ...(options.apply ? { planDigest: options.plan } : {}) });
+            }
+        }
+        else if (action === 'import-asset') {
+            if (!target || Boolean(options.dryRun) === Boolean(options.apply) || options.resume || options.newRun)
+                throw new Error('Use content import-asset <manifest.json> with --dry-run or --apply --plan <digest>.');
+            if (options.apply && !options.plan)
+                throw new Error('Apply requires --plan <digest> from a previous dry run.');
+            const source = await readAssetImport(resolve(root, target));
+            const assets = assetImportTransport(project, { signal, rootDir: root });
+            result = options.apply ? await applyAssetImport(assets, source.file, source.input, options.plan, { signal, renewSessionId: options.renew }) : await prepareAssetImport(assets, source.input);
+        }
+        else if (action === 'import') {
+            if (!target || Boolean(options.dryRun) === Boolean(options.apply))
+                throw new Error('Use content import <manifest.json> with exactly one of --dry-run or --apply --plan <digest>.');
+            if (options.apply && !options.plan)
+                throw new Error('Apply requires --plan <digest> from a previous dry run.');
+            if (options.newRun && (!options.dryRun || options.resume))
+                throw new Error('--new-run requires --dry-run and cannot be combined with --resume.');
+            const local = await readContentImport(resolve(root, target));
+            const assets = assetImportTransport(project, { signal, rootDir: root });
+            const source = await prepareContentImportAssets(assets, local);
+            const runId = await importRunIdentity({ root, project, gateway: runtime.gatewayUrl, manifest: source.manifest, resume: options.resume, newRun: options.newRun });
+            logMessage(`Import ${runId}`);
+            const prepared = await prepareContentImport(transport, { runId, ...source });
+            if (options.apply) {
+                if (prepared.planDigest !== options.plan)
+                    throw new Error('The supplied digest does not match the sealed server plan.');
+                if (!['planned', 'applying', 'complete'].includes(prepared.state))
+                    throw new Error(`Import cannot apply while ${prepared.state}.`);
+                for (const asset of source.assets) {
+                    const current = await transport({ operation: 'status', runId });
+                    if (!['planned', 'applying', 'complete'].includes(current.state))
+                        throw new Error(`Import cannot apply while ${current.state}.`);
+                    await applyAssetImport(assets, asset.file, asset.input, asset.plan.planDigest, { signal });
+                }
+                result = await applyContentImport(transport, runId, options.plan);
+            }
+            else
+                result = { ...prepared,
+                    assetBytes: source.assets.reduce((sum, asset) => sum + asset.input.declaredSizeBytes, 0),
+                    assets: source.assets.map(({ input, plan }) => ({ key: input.key, bytes: input.declaredSizeBytes, ...plan })),
+                };
+        }
+        else {
+            if (!target || !['import-status', 'import-cancel', 'verify'].includes(action))
+                throw new Error('Use content import-status, content import-cancel or content verify <run-id>.');
+            if (options.apply || options.dryRun || options.plan || options.resume || options.newRun)
+                throw new Error('Import execution flags are only valid for content import.');
+            result = action === 'verify' ? await verifyContentImport(transport, target)
+                : await transport({ operation: action === 'import-status' ? 'status' : 'cancel', runId: target });
+            if (action === 'verify') {
+                const proof = result;
+                if (!proof.verified)
+                    throw new StorystickError('Import readback does not match its receipts.', { ...CONTENT_IMPORT_CONFLICT, status: 409, payload: proof });
+                if (!proof.projected)
+                    throw new StorystickError('Content is committed; Content Plane projection is pending.', { ...DELIVERY_UNAVAILABLE, status: 503, payload: proof });
+            }
+        }
+        if (options.json)
+            emitJsonResult({ command, ok: true, data: result });
+        else
+            logOutput(JSON.stringify(result, null, 2));
+    }
+    catch (err) {
+        if (getOutputMode() === 'json')
+            exitJsonFailure({ command, err });
+        exitWithError(err);
+    }
+    finally {
+        dispose();
+    }
+}

package/dist/commands/delivery.d.ts

@@ -0,0 +1,22 @@
+export type DeliveryOptions = {
+    root?: string;
+    project?: string;
+    fromVercel?: boolean;
+    team?: string;
+    destination?: string;
+    siteUrl?: string;
+    rootDirectory?: string;
+    buildCommand?: string;
+    dryRun?: boolean;
+    json?: boolean;
+};
+export declare function deliveryProposal(root: string, options: DeliveryOptions): {
+    teamId: any;
+    destinationId: any;
+    publicUrl: string;
+    projectSettings: {
+        rootDirectory: string | null;
+        buildCommand: string | null;
+    };
+};
+export declare function runDelivery(operation: string, options: DeliveryOptions): Promise<void>;

package/dist/commands/delivery.js

@@ -0,0 +1,99 @@
+import { resolve } from "node:path";
+import { callHubApi } from "../hub-client.js";
+import { resolveCliRuntimeConfig } from "../runtime-config.js";
+import { resolveProjectConnection } from "../project-connection.js";
+import { inspectSetup } from "../setup.js";
+import { StorystickError } from "../cli-error.js";
+import { configureOutput, emitJsonResult, exitJsonFailure, exitWithError, getOutputMode, logMessage, withInterrupt, } from "../output.js";
+export function deliveryProposal(root, options) {
+    if (options.fromVercel && (options.team || options.destination))
+        throw Error("Choose --from-vercel or explicit --team and --destination.");
+    const linked = options.fromVercel ? inspectSetup(root).hosting : null;
+    const teamId = linked?.teamId ?? options.team, destinationId = linked?.projectId ?? options.destination;
+    if (!teamId ||
+        !/^team_[a-zA-Z0-9]+$/.test(teamId) ||
+        !destinationId ||
+        !/^prj_[a-zA-Z0-9]+$/.test(destinationId))
+        throw Error("Specify --team and --destination, or link this folder with Vercel and use --from-vercel.");
+    let url;
+    try {
+        url = new URL(options.siteUrl ?? "");
+    }
+    catch {
+        throw new StorystickError("--site-url must be the HTTPS origin already attached to the Vercel project.", {
+            code: "DELIVERY_CONFIGURATION_INVALID",
+            category: "validation",
+            retryable: false,
+        });
+    }
+    if (url.protocol !== "https:" ||
+        url.username ||
+        url.password ||
+        url.pathname !== "/" ||
+        url.search ||
+        url.hash)
+        throw new StorystickError("--site-url must be the HTTPS origin already attached to the Vercel project.", {
+            code: "DELIVERY_CONFIGURATION_INVALID",
+            category: "validation",
+            retryable: false,
+        });
+    return {
+        teamId,
+        destinationId,
+        publicUrl: url.origin,
+        projectSettings: {
+            rootDirectory: options.rootDirectory ?? null,
+            buildCommand: options.buildCommand ?? null,
+        },
+    };
+}
+export async function runDelivery(operation, options) {
+    configureOutput({ json: options.json === true });
+    const { signal, dispose } = withInterrupt();
+    try {
+        if (!["status", "configure", "verify"].includes(operation))
+            throw Error("Use delivery status, configure or verify.");
+        if (options.dryRun && operation !== "configure")
+            throw Error("--dry-run applies to delivery configure only.");
+        if (process.env.STORYSTICK_RELEASE_SESSION)
+            throw Error("Hosting configuration requires an account CLI session outside the sandbox.");
+        const rootDir = resolve(options.root ?? ".");
+        const configuration = operation === "configure"
+            ? deliveryProposal(rootDir, options)
+            : undefined;
+        const projectShortId = options.project ?? resolveProjectConnection(rootDir)?.shortId;
+        if (!projectShortId)
+            throw new StorystickError("Connect a project or specify --project <shortId>.", {
+                code: "PROJECT_NOT_CONNECTED",
+                category: "validation",
+                retryable: false,
+            });
+        const result = options.dryRun
+            ? { projectShortId, configuration, saved: false }
+            : await callHubApi("/api/cli/project-setup", {
+                rootDir,
+                gatewayUrl: resolveCliRuntimeConfig({ rootDir }).gatewayUrl,
+                method: "POST",
+                body: {
+                    projectShortId,
+                    operation: `delivery-${operation}`,
+                    ...(configuration ? { configuration } : {}),
+                },
+                signal,
+                interactiveAuth: false,
+                timeoutMs: 90_000,
+            });
+        if (getOutputMode() === "json")
+            emitJsonResult({ command: "delivery", ok: true, data: result });
+        else
+            logMessage(JSON.stringify(result, null, 2));
+    }
+    catch (err) {
+        if (getOutputMode() === "json")
+            exitJsonFailure({ command: "delivery", err });
+        exitWithError(err);
+    }
+    finally {
+        dispose();
+    }
+}

package/dist/commands/info.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `storystick info [<projectId>]` (SPEC-1 Item #4).
+ *
+ * Without an argument: detail of the active project (detected from the nearest
+ * complete, validated ProjectConnection). With an argument: detail of the
+ * given shortId.
+ *
+ * Flag `--json` emits the full payload for scripting.
+ */
+import type { ProjectAccessSummary } from '../project-access.js';
+export interface ProjectInfo extends ProjectAccessSummary {
+    /** 8-char Crockford shortId — the public project identifier. */
+    shortId: string;
+    /** Kebab-cased URL label derived from name (may be empty). */
+    urlLabel: string;
+    name: string;
+    /**
+     * Internal Convex `_id`. Kept in the payload for ops debug workflows
+     * (support-ticket correlation, Convex trace lookup) but never rendered
+     * in the CLI pretty-print — `--json` only. Distinct from the SDK's
+     * `ProjectConfig.projectId`, which is the public shortId.
+     */
+    internalId: string;
+    plan: 'free' | 'pro' | 'team';
+    createdAt: number;
+    apiKeyCount?: number;
+    secretKeyCount?: number;
+    publishableKeyCount?: number;
+    endpoint: string;
+}
+export interface InfoOptions {
+    json?: boolean;
+    root?: string;
+}
+export declare function runInfo(projectIdArg: string | undefined, options?: InfoOptions): Promise<void>;

package/dist/commands/info.js

@@ -0,0 +1,62 @@
+/**
+ * `storystick info [<projectId>]` (SPEC-1 Item #4).
+ *
+ * Without an argument: detail of the active project (detected from the nearest
+ * complete, validated ProjectConnection). With an argument: detail of the
+ * given shortId.
+ *
+ * Flag `--json` emits the full payload for scripting.
+ */
+import pc from 'picocolors';
+import { resolve } from 'node:path';
+import { callHubApi } from '../hub-client.js';
+import { requireProjectConnection } from '../project-connection.js';
+import { configureOutput, emitJsonResult, exitJsonFailure, exitWithError, getOutputMode, logOutput, promptDeviceAuth, withInterrupt, } from '../output.js';
+export async function runInfo(projectIdArg, options = {}) {
+    configureOutput({ json: options.json === true });
+    const { signal, dispose } = withInterrupt();
+    try {
+        let projectId = projectIdArg;
+        if (!projectId) {
+            projectId = requireProjectConnection(resolve(options.root ?? '.')).shortId;
+        }
+        const info = await callHubApi(`/api/cli/projects/for-user-by-shortId?shortId=${encodeURIComponent(projectId)}`, { onAuthPrompt: promptDeviceAuth, signal });
+        if (options.json) {
+            // ADR-072 §D15: BREAKING — payload now wrapped in the standard
+            // envelope (was a raw ProjectInfo object pre-ADR-072).
+            emitJsonResult({ command: 'info', ok: true, data: info });
+            return;
+        }
+        const created = new Date(info.createdAt).toISOString().slice(0, 10);
+        const rows = [
+            ['Project:', info.shortId],
+            ['Name:', info.name],
+            ['URL:', `/p/${info.urlLabel ? `${info.urlLabel}-${info.shortId}` : info.shortId}`],
+            ['Endpoint:', info.endpoint],
+            ['Plan:', info.plan],
+            ['Content role:', info.contentRole],
+            ['Access:', info.accessSource],
+            ['Team role:', info.teamRole ?? '—'],
+            ['Created:', created],
+        ];
+        if (info.apiKeyCount !== undefined &&
+            info.secretKeyCount !== undefined &&
+            info.publishableKeyCount !== undefined) {
+            const keyBreakdown = info.apiKeyCount === 0
+                ? '0'
+                : `${info.apiKeyCount} (${info.secretKeyCount} secret, ${info.publishableKeyCount} publishable)`;
+            rows.push(['API keys:', keyBreakdown]);
+        }
+        const body = rows.map(([label, value]) => pc.dim(label.padEnd(12)) + value).join('\n') + '\n';
+        logOutput(body);
+    }
+    catch (err) {
+        if (getOutputMode() === 'json') {
+            exitJsonFailure({ command: 'info', err });
+        }
+        exitWithError(err);
+    }
+    finally {
+        dispose();
+    }
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `storystick list` / `storystick ls` (SPEC-1 Item #4).
+ *
+ * Lists the authenticated user's projects. Marks the active project from the
+ * nearest complete, validated ProjectConnection via bold formatting.
+ *
+ * Flags:
+ *   --json  Emit JSON to stdout, no ANSI. Active-project detection still
+ *           applies; the marker surfaces as `active: true` in the payload.
+ *   --all   Include archived (soft-deleted) projects. Adds a `status`
+ *           column and surfaces `deletedAt`.
+ */
+import type { ProjectAccessSummary } from '../project-access.js';
+export interface ListedProject extends ProjectAccessSummary {
+    /** 8-char Crockford shortId — the public project identifier. */
+    shortId: string;
+    /** Kebab-cased URL label derived from name (may be empty). */
+    urlLabel: string;
+    name: string;
+    plan: 'free' | 'pro' | 'team';
+    deletedAt: number | null;
+    createdAt: number;
+}
+export interface ListOptions {
+    json?: boolean;
+    all?: boolean;
+}
+export declare function runList(options?: ListOptions): Promise<void>;

package/dist/commands/list.js

@@ -0,0 +1,116 @@
+/**
+ * `storystick list` / `storystick ls` (SPEC-1 Item #4).
+ *
+ * Lists the authenticated user's projects. Marks the active project from the
+ * nearest complete, validated ProjectConnection via bold formatting.
+ *
+ * Flags:
+ *   --json  Emit JSON to stdout, no ANSI. Active-project detection still
+ *           applies; the marker surfaces as `active: true` in the payload.
+ *   --all   Include archived (soft-deleted) projects. Adds a `status`
+ *           column and surfaces `deletedAt`.
+ */
+import pc from 'picocolors';
+import { callHubApi } from '../hub-client.js';
+import { resolveProjectConnection } from '../project-connection.js';
+import { configureOutput, emitJsonResult, exitJsonFailure, exitWithError, getOutputMode, logMessage, logOutput, promptDeviceAuth, withInterrupt, } from '../output.js';
+// ─── Entry point ──────────────────────────────────────────────
+export async function runList(options = {}) {
+    configureOutput({ json: options.json === true });
+    const { signal, dispose } = withInterrupt();
+    try {
+        const path = '/api/cli/projects/list-for-user' +
+            (options.all ? '?includeArchived=1' : '');
+        const projects = await callHubApi(path, {
+            onAuthPrompt: promptDeviceAuth,
+            signal,
+        });
+        const active = resolveProjectConnection()?.shortId ?? null;
+        if (options.json) {
+            // ADR-072 §D15: BREAKING — payload is wrapped in the standard
+            // envelope (was a flat array pre-ADR-072). Migration guide in
+            // docs-notes/migration-adr-072.md (Batch 8).
+            const payload = projects.map((p) => ({
+                shortId: p.shortId,
+                urlLabel: p.urlLabel,
+                name: p.name,
+                teamRole: p.teamRole,
+                contentRole: p.contentRole,
+                accessSource: p.accessSource,
+                capabilities: p.capabilities,
+                plan: p.plan,
+                status: deriveStatus(p.deletedAt),
+                archived: p.deletedAt !== null,
+                active: p.shortId === active,
+            }));
+            emitJsonResult({ command: 'list', ok: true, data: payload });
+            return;
+        }
+        if (projects.length === 0) {
+            logMessage('No projects found. Try ' +
+                pc.bold('storystick init <name>') +
+                ' to create one.');
+            return;
+        }
+        // Pretty-print — build column widths so roles and plans stay aligned.
+        const rows = projects.map((p) => ({
+            active: p.shortId === active,
+            shortId: p.shortId,
+            name: p.name,
+            teamRole: p.teamRole ?? '—',
+            contentRole: p.contentRole,
+            accessSource: p.accessSource,
+            plan: p.plan,
+            status: deriveStatus(p.deletedAt),
+        }));
+        const idW = Math.max(8, ...rows.map((r) => r.shortId.length));
+        const nameW = Math.max(4, ...rows.map((r) => r.name.length));
+        const contentRoleW = Math.max(7, ...rows.map((r) => r.contentRole.length));
+        const accessW = Math.max(6, ...rows.map((r) => r.accessSource.length));
+        const teamRoleW = Math.max(4, ...rows.map((r) => r.teamRole.length));
+        const planW = Math.max(4, ...rows.map((r) => r.plan.length));
+        const lines = [];
+        const header = [
+            pc.dim('ID'.padEnd(idW)),
+            pc.dim('NAME'.padEnd(nameW)),
+            pc.dim('CONTENT'.padEnd(contentRoleW)),
+            pc.dim('ACCESS'.padEnd(accessW)),
+            pc.dim('TEAM'.padEnd(teamRoleW)),
+            pc.dim('PLAN'.padEnd(planW)),
+        ];
+        if (options.all)
+            header.push(pc.dim('STATUS'));
+        lines.push(header.join('  '));
+        // Active project is distinguished by a bold shortId — the ● marker was
+        // dropped per ADR-061 style rule 2 ("two icons total").
+        for (const r of rows) {
+            const id = r.active ? pc.bold(r.shortId.padEnd(idW)) : r.shortId.padEnd(idW);
+            const line = [
+                id,
+                r.name.padEnd(nameW),
+                r.contentRole.padEnd(contentRoleW),
+                r.accessSource.padEnd(accessW),
+                r.teamRole.padEnd(teamRoleW),
+                r.plan.padEnd(planW),
+            ];
+            if (options.all) {
+                line.push(r.status === 'archived' ? pc.yellow(r.status) : r.status);
+            }
+            lines.push(line.join('  '));
+        }
+        logOutput(lines.join('\n') + '\n');
+    }
+    catch (err) {
+        if (getOutputMode() === 'json') {
+            exitJsonFailure({ command: 'list', err });
+        }
+        exitWithError(err);
+    }
+    finally {
+        dispose();
+    }
+}
+// ─── Helpers ──────────────────────────────────────────────────
+function deriveStatus(deletedAt) {
+    return deletedAt == null ? 'active' : 'archived';
+}

package/dist/commands/migrate.d.ts

@@ -0,0 +1,80 @@
+import type { SchemaChangeRecipeV1, SchemaChangeRunViewV1, SerializedSchema } from '@storystick/types';
+import { type SchemaChangeEvidenceBody } from '../operations-client.js';
+import type { ExternalMigrationArtifact } from '../migration-artifact.js';
+export interface MigrateOutputOptions {
+    root?: string;
+    gatewayUrl?: string;
+    json?: boolean;
+    verbose?: boolean;
+    quiet?: boolean;
+    fetchImpl?: typeof fetch;
+}
+export declare function newMigrationRequestId(): string;
+export declare function runMigrateBuild(migrationPath: string, options?: MigrateOutputOptions): Promise<ExternalMigrationArtifact>;
+export declare function assertExternalMigrationArtifact(run: SchemaChangeRunViewV1, artifact: ExternalMigrationArtifact): void;
+type GuidedProgram = {
+    artifact?: ExternalMigrationArtifact;
+    recipe?: SchemaChangeRecipeV1;
+    runId?: string;
+};
+/** Compose the existing durable analysis and preparation; no second server state machine. */
+export declare function runMigratePreview(target: SerializedSchema, program: GuidedProgram, options?: MigrateOutputOptions & {
+    requestId?: string;
+}): Promise<void>;
+export interface MigrationApplicationReadback {
+    projectId: string;
+    artifactId: string;
+    artifactDigest: string;
+    schemaVersion: string | null;
+    querySchemaFingerprint: string;
+}
+export declare function readMigrationApplication(args: {
+    appUrl: string;
+    projectId: string;
+    target: SerializedSchema;
+    signal?: AbortSignal;
+    fetchImpl?: typeof fetch;
+}): Promise<{
+    url: string;
+    readback: MigrationApplicationReadback;
+}>;
+export declare function runMigratePairBuild(runId: string, target: SerializedSchema, input: {
+    phase: 'prepared' | 'serving';
+    appUrl: string;
+    previewProof?: string;
+    requestId?: string;
+}, options?: MigrateOutputOptions): Promise<void>;
+export declare function runMigrateGuidedActivate(target: SerializedSchema, program: GuidedProgram & {
+    appUrl?: string;
+    servingUrl?: string;
+    previewProof?: string;
+    yes?: boolean;
+}, options?: MigrateOutputOptions & {
+    requestId?: string;
+}): Promise<void>;
+export declare function runMigrateAnalyze(targetSchema: SerializedSchema, recipe: SchemaChangeRecipeV1, options?: MigrateOutputOptions & {
+    requestId?: string;
+}): Promise<void>;
+export declare function runMigrateAnalyzeExternal(targetSchema: SerializedSchema, artifact: ExternalMigrationArtifact, options?: MigrateOutputOptions & {
+    requestId?: string;
+}): Promise<void>;
+export declare function runMigratePrepare(runId: string, analysisId: string, options?: MigrateOutputOptions & {
+    requestId?: string;
+    artifact?: ExternalMigrationArtifact;
+}): Promise<void>;
+export declare function runMigrateRunCommand(action: 'resume' | 'abort', runId: string, options?: MigrateOutputOptions & {
+    requestId?: string;
+}): Promise<void>;
+export declare function runMigrateAttest(body: Omit<SchemaChangeEvidenceBody, 'requestId'>, options?: MigrateOutputOptions & {
+    requestId?: string;
+}): Promise<void>;
+export declare function runMigrateActivate(runId: string, preparationId: string, evidenceId: string, options?: MigrateOutputOptions & {
+    requestId?: string;
+}): Promise<void>;
+export declare function runMigrateStatus(runId: string | undefined, options?: MigrateOutputOptions): Promise<void>;
+export declare function runMigrateIssues(runId: string, analysisId: string, options?: MigrateOutputOptions & {
+    cursor?: string;
+    limit?: number;
+}): Promise<void>;
+export declare function runMigrateReceipt(runId: string, options?: MigrateOutputOptions): Promise<void>;
+export {};