@contentful/experience-design-system-cli 2.35.1-dev-build-4f1ad8cb.0 → 2.35.1-dev-build-10b29479.0

package/bin/cli.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-await import('../dist/index.js');
+await import("../dist/index.js");

package/dist/index.js

@@ -1389,6 +1389,11 @@ var init_app = __esm({
 import { readFileSync as readFileSync3 } from "node:fs";
 import { Command } from "commander";
 
+// packages/experience-design-system-cli/src/legacy/forwarded-import-args.ts
+function forwardedImportArgs(argv) {
+  return argv[0] === "import" ? argv.slice(1) : argv;
+}
+
 // packages/experience-design-system-cli/src/legacy/run-legacy.ts
 init_legacy_cli_path();
 import { spawn } from "node:child_process";
@@ -1442,7 +1447,11 @@ function registerForwardedCommands(program) {
 }
 function createProgram() {
   const program = new Command().name("experiences").description("Contentful Experiences design system import CLI").version(pkg.version, "--version", "Print version number");
-  program.command("import", { isDefault: true }).description("Launch the Experiences CLI").action(async () => {
+  program.command("import", { isDefault: true }).description("Launch the Experiences CLI").allowUnknownOption().allowExcessArguments().helpOption(false).argument("[args...]").action(async () => {
+    const forwarded = forwardedImportArgs(process.argv.slice(2));
+    if (forwarded.length > 0) {
+      process.exit(await runLegacy(["import", ...forwarded]));
+    }
     const { render } = await import("ink");
     const { runApp: runApp2 } = await Promise.resolve().then(() => (init_app(), app_exports));
     await runApp2(render);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.35.1-dev-build-4f1ad8cb.0",
+  "version": "2.35.1-dev-build-10b29479.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/dist/src/legacy/forwarded-import-args.d.ts

@@ -0,0 +1 @@
+export declare function forwardedImportArgs(argv: string[]): string[];

package/legacy/bin/cli.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 // Suppress the SQLite ExperimentalWarning before any modules load.
 // Must use dynamic import so this handler registers before sqlite is imported.
-process.removeAllListeners('warning');
-process.on('warning', (w) => {
-  if (w.name === 'ExperimentalWarning' && w.message.includes('SQLite')) return;
+process.removeAllListeners("warning");
+process.on("warning", (w) => {
+  if (w.name === "ExperimentalWarning" && w.message.includes("SQLite")) return;
   process.stderr.write(`${w.name}: ${w.message}\n`);
 });
 
 // Auto-rebuild when running from source (dev mode only).
 // Skipped when src/ doesn't exist (e.g. npm-installed users).
-import { existsSync, statSync, readdirSync } from 'node:fs';
-import { execFileSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve, join } from 'node:path';
+import { existsSync, statSync, readdirSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve, join } from "node:path";
 
 function newestMtime(dir, depth = 0) {
   if (depth > 10) return 0;
@@ -22,7 +22,7 @@ function newestMtime(dir, depth = 0) {
     const full = join(dir, entry.name);
     if (entry.isDirectory()) {
       max = Math.max(max, newestMtime(full, depth + 1));
-    } else if (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx')) {
+    } else if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
       max = Math.max(max, statSync(full).mtimeMs);
     }
   }
@@ -30,25 +30,29 @@ function newestMtime(dir, depth = 0) {
 }
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkgRoot = resolve(__dirname, '..');
-const srcDir = join(pkgRoot, 'src');
-const distEntry = join(pkgRoot, 'dist', 'src', 'index.js');
+const pkgRoot = resolve(__dirname, "..");
+const srcDir = join(pkgRoot, "src");
+const distEntry = join(pkgRoot, "dist", "src", "index.js");
 
-if (existsSync(srcDir) && existsSync(distEntry) && process.env.NODE_ENV !== 'test') {
+if (
+  existsSync(srcDir) &&
+  existsSync(distEntry) &&
+  process.env.NODE_ENV !== "test"
+) {
   const distMtime = statSync(distEntry).mtimeMs;
   if (newestMtime(srcDir) > distMtime) {
-    process.stderr.write('⚙ Source changed — rebuilding...\n');
-    const tsc = join(pkgRoot, 'node_modules', '.bin', 'tsc');
+    process.stderr.write("⚙ Source changed — rebuilding...\n");
+    const tsc = join(pkgRoot, "node_modules", ".bin", "tsc");
     try {
-      execFileSync(tsc, ['-p', join(pkgRoot, 'tsconfig.build.json')], {
-        stdio: ['ignore', 'ignore', 'inherit'],
+      execFileSync(tsc, ["-p", join(pkgRoot, "tsconfig.build.json")], {
+        stdio: ["ignore", "ignore", "inherit"],
         cwd: pkgRoot,
       });
-      process.stderr.write('✓ Build complete\n');
+      process.stderr.write("✓ Build complete\n");
     } catch {
-      process.stderr.write('✗ Build failed — running with existing dist\n');
+      process.stderr.write("✗ Build failed — running with existing dist\n");
     }
   }
 }
 
-await import('../dist/src/index.js');
+await import("../dist/src/index.js");

package/legacy/dist/src/analyze/composition/candidate-files.d.ts

@@ -0,0 +1,34 @@
+export declare const CANDIDATE_NAME_PATTERNS: RegExp[];
+export declare const CANDIDATE_CONTENT_MARKERS: string[];
+export declare const CANDIDATE_TOKEN_BUDGET = 6000;
+/**
+ * Token ceiling for the candidate set INLINED into a single agent prompt.
+ * Sized to stay under a 200k-context model once the agent's own system prompt
+ * + tool definitions (~105k observed) are added, so a large design system
+ * (hundreds of components → many matched files) can't overflow the request and
+ * fail resolution. Files beyond the budget are dropped (with a warning), not
+ * silently truncated. Distinct from `CANDIDATE_TOKEN_BUDGET`, which sizes the
+ * unused per-batch chunking.
+ */
+export declare const PROMPT_CANDIDATE_TOKEN_BUDGET = 80000;
+export type CandidateFile = {
+    path: string;
+    content: string;
+};
+export type SelectedCandidate = CandidateFile & {
+    reason: string;
+};
+export declare function selectCandidateFiles(files: CandidateFile[]): SelectedCandidate[];
+/**
+ * Cap a candidate set to what fits in a single agent prompt (see
+ * `PROMPT_CANDIDATE_TOKEN_BUDGET`). Files are kept smallest-first so the budget
+ * admits the most declarations; deterministic tie-break by path. Returns the
+ * kept files plus the paths dropped so the caller can warn (silent truncation
+ * would read as "resolved everything" when it didn't).
+ */
+export declare function capCandidatesToPromptBudget<T extends CandidateFile>(files: T[], budget?: number): {
+    kept: T[];
+    dropped: T[];
+};
+export declare function sliceDeclarationRegions(content: string, markers?: string[], window?: number): string[];
+export declare function batchCandidates(files: CandidateFile[], budget?: number): CandidateFile[][];

package/legacy/dist/src/analyze/composition/composition-cache-key.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Derive the `input_hash` for a composition-cache entry (stored in the pipeline
+ * DB's `composition_cache` table). Content-addresses the candidate file set
+ * (order-independent) plus the producing agent, so a re-run over unchanged
+ * files reuses the (token-costly) agent output.
+ *
+ * Content-hashing — not mtime — means a no-op `git checkout` that only bumps
+ * mtime is still a hit. Prompt/skill changes are handled by the `cli_version`
+ * column on the row (see `getCliCacheVersion`), so no separate resolver-version
+ * constant is needed here.
+ */
+export declare function buildCompositionInputHash(input: {
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+    agent: string;
+}): string;

package/legacy/dist/src/analyze/composition/interchange-schema.d.ts

@@ -5,7 +5,7 @@
  * parent→child relationship, carrying optional `slot` (T7), `confidence`,
  * and `provenance`. It is easier to merge and dedupe across sources (T2).
  */
-export type EdgeProvenance = 'typed-slot' | 'structural' | 'call-site' | 'manifest' | 'doc' | `adapter:${string}`;
+export type EdgeProvenance = 'typed-slot' | 'structural' | 'manifest' | 'doc' | `adapter:${string}` | 'agent';
 export type CompositionEdge = {
     parent: string;
     child: string;
@@ -13,11 +13,5 @@ export type CompositionEdge = {
     slot?: string;
     /** 1–5 scale, same as select/reject agent tools. */
     confidence?: number;
-    citation?: CompositionCitation;
     provenance: EdgeProvenance;
 };
-export type CompositionCitation = {
-    sourcePath: string;
-    startLine: number;
-    endLine: number;
-};

package/legacy/dist/src/analyze/composition/parse-map-edges.d.ts

@@ -0,0 +1,16 @@
+import type { CompositionEdge } from './interchange-schema.js';
+/**
+ * Lenient JSONL parser for the composition-mapping agent's tool-call output
+ * (spec T4). Mirrors `parseSelectToolCallLines` / `parseToolCallLines` in
+ * `@contentful/experience-design-system-generation`'s `agent-runner.ts`: one JSON object per line, each with a `tool`
+ * field from a fixed allowlist. A line that fails JSON.parse or validation is
+ * DROPPED into `warnings[]` (with a reason) and parsing CONTINUES — no retry,
+ * no throw. Non-`{` prose and blank lines are skipped silently.
+ */
+export type ParseMapEdgesResult = {
+    edges: CompositionEdge[];
+    warnings: string[];
+};
+export declare function parseMapEdges(raw: string, opts: {
+    componentNames: Set<string>;
+}): ParseMapEdgesResult;

package/legacy/dist/src/analyze/composition/prompt-loader.d.ts

@@ -0,0 +1,3 @@
+/** Resolve a bundled composition prompt from the package-root prompts directory. */
+export declare function resolvePromptPath(fileName: string): string;
+export declare function loadPrompt(fileName: string): string;

package/legacy/dist/src/analyze/composition/resolve-mapping-cli.d.ts

@@ -0,0 +1,10 @@
+export type CompositionCliOptions = {
+    /** `--composition-refresh` — force edge emission to run even over resolved residue. */
+    compositionRefresh?: boolean;
+    /** `--no-cache` — force the composition agent to rerun with the rest of the pipeline. */
+    noCache?: boolean;
+};
+export type ResolvedCompositionSources = {
+    forceAgent: boolean;
+};
+export declare function resolveCompositionSources(opts: CompositionCliOptions): ResolvedCompositionSources;

package/legacy/dist/src/analyze/composition/resolve-mapping.d.ts

@@ -1,36 +1,59 @@
 import type { RawComponentDefinition } from '../../types.js';
 import type { CompositionEdge } from './interchange-schema.js';
 import { type EdgeConflict } from './merge-edges.js';
-import type { SourceCallSiteEvidence, SourceCallSiteRejection } from './source-call-site-evidence.js';
 export type ResolveMappingResult = {
     components: RawComponentDefinition[];
     edges: CompositionEdge[];
     conflicts: EdgeConflict[];
     warnings: string[];
-    sourceCallSiteEvidence: SourceCallSiteEvidence[];
-    sourceCallSiteRejections: SourceCallSiteRejection[];
 };
 /**
  * Orchestrate composition-edge acquisition and enrichment.
  *
- * Sources by rank: typed-slot / "code slots" (1) > structural usage evidence
- * (2) > cited source call sites (3) > manifest (4) > doc (5) > adapter-resolved
- * / extraEdges (6). Manifest/doc edges are computed deterministically outside
+ * Sources by rank: typed-slot / "code slots" (2) > structural usage evidence
+ * (3) > manifest (4) > doc (5) > adapter-resolved / extraEdges (6) >
+ * edge-emitting agent (7). Manifest/doc edges are computed deterministically outside
  * this function (see manifest-doc-evidence.ts) and joined via `extraEdges`.
  * ALL sources — including the code slots already on the incoming components —
  * are fed into one ranked merge and unioned; non-conflicting edges from every
  * source survive, and on a conflict (same parent+child, different slot) the
- * higher-rank source wins and the loser is recorded. No agent contributes
- * edges: every edge is backed by code, a manifest or documentation.
+ * higher-rank source wins and the loser is recorded. The edge-emitting agent runs only when
+ * `forceAgent` is set OR there is residue a higher-rank source
+ * didn't cover (routing/cost optimization) — `forceAgent` bypasses that
+ * suppression but never changes rank.
+ *
+ * `runAgentFn` is injected (returns the agent's raw stdout) so this is
+ * testable without spawning a subprocess.
  */
 export declare function resolveMapping(input: {
     components: RawComponentDefinition[];
+    forceAgent?: boolean;
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+    runAgentFn: (opts: {
+        prompt: string;
+        files: Array<{
+            path: string;
+            content: string;
+        }>;
+    }) => Promise<string>;
+    buildPrompt?: (files: Array<{
+        path: string;
+        content: string;
+    }>, componentNames: string[]) => string;
+    /**
+     * Custom instruction preamble (from `--prompt composition=...`). Replaces the
+     * default guidance line ONLY; the machine-readable output contract + the
+     * component-name allowlist + candidate files are always appended so the
+     * JSONL parser keeps working regardless of the override.
+     */
+    promptOverride?: string;
     /**
      * Pre-resolved edges from an external source (e.g. manifest or documentation)
      * path). They join the ranked merge at their own provenance rank alongside
      * code slots and other automatic mapping sources.
      */
     extraEdges?: CompositionEdge[];
-    sourceCallSiteEvidence?: SourceCallSiteEvidence[];
-    sourceCallSiteRejections?: SourceCallSiteRejection[];
-}): ResolveMappingResult;
+}): Promise<ResolveMappingResult>;

package/legacy/dist/src/analyze/controller/run-analyze-extract.d.ts

@@ -0,0 +1,12 @@
+export interface AnalyzeExtractOptions {
+    project: string;
+    dir?: string;
+    resolveUnreachable?: string;
+    compositionRefresh?: boolean;
+    cache?: boolean;
+    noCache?: boolean;
+    prompt?: string[];
+    agent?: string;
+    bedrock?: boolean;
+}
+export declare function runAnalyzeExtract(opts: AnalyzeExtractOptions): Promise<void>;

package/legacy/dist/src/analyze/extract-command.d.ts

@@ -1,7 +1,4 @@
 import type { Command } from 'commander';
-export declare function resolveExtractNoCache(opts: {
-    cache?: boolean;
-    noCache?: boolean;
-}): boolean;
-export declare function collectSourceFiles(directory: string, onProgress?: (scannedCount: number) => void): Promise<string[]>;
+export { resolveExtractNoCache } from './helpers/resolve-no-cache.js';
+export { collectSourceFiles } from './services/collect-source-files.js';
 export declare function registerInternalExtractCommand(program: Command): void;

package/legacy/dist/src/analyze/helpers/resolve-composition-agent.d.ts

@@ -0,0 +1,9 @@
+import type { AgentName } from '@contentful/experience-design-system-generation';
+export declare function resolveCompositionAgentName(flagValue?: string): AgentName;
+export declare function readCandidateFiles(components: Array<{
+    sourcePath?: string;
+    source?: string;
+}>, extraFiles?: string[]): Promise<Array<{
+    path: string;
+    content: string;
+}>>;

package/legacy/dist/src/analyze/helpers/resolve-no-cache.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveExtractNoCache(opts: {
+    cache?: boolean;
+    noCache?: boolean;
+}): boolean;

package/legacy/dist/src/analyze/helpers/resolve-unreachable-mode.d.ts

@@ -0,0 +1 @@
+export declare function resolveUnreachableMode(value: string | undefined): 'auto' | 'always' | 'never';

package/legacy/dist/src/analyze/helpers/retry-db-write.d.ts

@@ -0,0 +1 @@
+export declare function retryDatabaseWrite<T>(operation: () => T, attempts?: number): Promise<T>;

package/legacy/dist/src/analyze/orchestrator/execute-analyze-extract.d.ts

@@ -0,0 +1,21 @@
+import type { AgentName } from '@contentful/experience-design-system-generation';
+export interface AnalyzeExtractOrchestratorRequest {
+    projectRoot: string;
+    sourceDirectory: string;
+    outDir: string;
+    noCache: boolean;
+    forceAgent: boolean;
+    agent: AgentName;
+    compositionPrompt?: string;
+    resolveUnreachable: 'auto' | 'always' | 'never';
+    onScanProgress?: (count: number) => void;
+    onCompositionProgress?: (phase: string) => void;
+    onSessionCreated?: (sessionId: string) => void | Promise<void>;
+}
+export interface AnalyzeExtractOrchestratorResult {
+    sessionId: string;
+    sourceFileCount: number;
+    componentCount: number;
+    warnings: string[];
+}
+export declare function executeAnalyzeExtractOrchestrator(request: AnalyzeExtractOrchestratorRequest): Promise<AnalyzeExtractOrchestratorResult>;

package/legacy/dist/src/analyze/services/collect-source-files.d.ts

@@ -0,0 +1 @@
+export declare function collectSourceFiles(directory: string, onProgress?: (scannedCount: number) => void): Promise<string[]>;

package/legacy/dist/src/analyze/services/extract-with-cache.d.ts

@@ -0,0 +1,17 @@
+import type { RawComponentDefinition } from '../../types.js';
+import type { openPipelineDb } from '../../session/db.js';
+export interface ExtractionWithCacheOptions {
+    db: ReturnType<typeof openPipelineDb>;
+    sourceFiles: string[];
+    noCache: boolean;
+    resolveUnreachable?: 'auto' | 'always' | 'never';
+    projectRoot?: string;
+    cacheVersion: string;
+    onProgress?: (filesProcessed: number) => void;
+}
+export interface ExtractionWithCacheResult {
+    components: RawComponentDefinition[];
+    warnings: string[];
+    cacheHits: number;
+}
+export declare function runExtractionWithCache(options: ExtractionWithCacheOptions): Promise<ExtractionWithCacheResult>;

package/legacy/dist/src/analyze/services/persist-extract-results.d.ts

@@ -0,0 +1,11 @@
+import type { RawComponentDefinition } from '../../types.js';
+import type { openPipelineDb } from '../../session/db.js';
+export interface PersistExtractResultsOptions {
+    db: ReturnType<typeof openPipelineDb>;
+    sessionId: string;
+    stepId: number;
+    projectRoot: string;
+    sourceFiles: string[];
+    components: RawComponentDefinition[];
+}
+export declare function persistExtractResults(options: PersistExtractResultsOptions): Promise<void>;

package/legacy/dist/src/analyze/services/resolve-composition-mapping.d.ts

@@ -0,0 +1,22 @@
+import type { AgentName } from '@contentful/experience-design-system-generation';
+import type { RawComponentDefinition } from '../../types.js';
+import type { openPipelineDb } from '../../session/db.js';
+export interface CompositionMappingOptions {
+    db: ReturnType<typeof openPipelineDb>;
+    components: RawComponentDefinition[];
+    allFiles: Array<{
+        path: string;
+        content: string;
+    }>;
+    noCache: boolean;
+    forceAgent: boolean;
+    agent: AgentName;
+    promptOverride?: string;
+    cacheVersion: string;
+    onProgress?: (phase: string) => void;
+}
+export interface CompositionMappingResult {
+    components: RawComponentDefinition[];
+    warnings: string[];
+}
+export declare function resolveCompositionMapping(options: CompositionMappingOptions): Promise<CompositionMappingResult>;

package/legacy/dist/src/analyze/services/resolve-source-directory.d.ts

@@ -0,0 +1 @@
+export declare function resolveSourceDirectory(projectRoot: string, dir: string | undefined): Promise<string>;

package/legacy/dist/src/apply/command.d.ts

@@ -1,43 +1,5 @@
 import type { Command } from 'commander';
-import type { CDFComponentEntry, CDFTokenEntry, CDFValidationError, DTCGTokenEntry } from '@contentful/experience-design-system-types';
-import { findSlotCycles } from '../analyze/cycle-detection.js';
-import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
-export declare function readTokensFromPath(flag: string, p: string): Promise<DTCGTokenEntry[]>;
-/** Adapts flat DTCGTokenEntry[] (path alongside the leaf) into the
- * {path, entry} pairs buildCDF/buildFilteredCDF expect. */
-export declare function toCDFTokens(tokens: DTCGTokenEntry[]): Array<{
-    path: string;
-    entry: CDFTokenEntry;
-}>;
-export declare function detectSlotCycles(components: Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>): ReturnType<typeof findSlotCycles>;
-export declare function formatSlotCycleReport(cycles: ReturnType<typeof findSlotCycles>): string[];
-export declare function assertNoSlotCycles(components: Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>): Promise<void>;
-/**
- * Client-side pre-flight for `$allowedComponents` references that are absent
- * from this document, so a typo'd or renamed reference fails fast instead of
- * waiting on the `previewImport`/`applyImport` round-trip. Only catches
- * document-internal misses — a name that resolves against an *existing*
- * target-environment Component still needs the network round-trip to
- * confirm, so this cannot replace the server-side check.
- *
- * `validateSlotReferences` is the detection step (shared with
- * `WizardApp.tsx` via `formatUnresolvedSlotReferences` below, mirroring how
- * `detectSlotCycles`/`formatSlotCycleReport` split for the cycle check).
- */
-export declare function formatUnresolvedSlotReferences(errors: CDFValidationError[]): string[];
-export declare function assertNoUnresolvedSlotReferences(components: Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>): Promise<void>;
-export declare function extractComponents(cdf: Record<string, unknown> | null | undefined): Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>;
-export declare function hasBreakingChangesWithImpact(preview: ServerPreviewResponse): boolean;
+export { readTokensFromPath, toCDFTokens } from './helpers/read-token-files.js';
+export { detectSlotCycles, formatSlotCycleReport, assertNoSlotCycles, formatUnresolvedSlotReferences, assertNoUnresolvedSlotReferences, extractComponents, } from './helpers/slot-validation.js';
+export { hasBreakingChangesWithImpact } from './helpers/has-breaking-changes.js';
 export declare function registerApplyCommand(program: Command): void;

package/legacy/dist/src/apply/controller/run-apply.d.ts

@@ -0,0 +1 @@
+export declare function runApply(file: string): Promise<void>;

package/legacy/dist/src/apply/helpers/build-apply-output.d.ts

@@ -0,0 +1,55 @@
+import type { ApplyOperationResponse, ServerPreviewResponse } from '@contentful/experience-design-system-types';
+export declare function buildPreviewOutput(preview: ServerPreviewResponse, spaceId: string, environmentId: string): {
+    spaceId: string;
+    environmentId: string;
+    components: {
+        new: number;
+        changed: number;
+        unchanged: number;
+        removed: number;
+        breaking: number;
+        draftOverwrites: number;
+    };
+    tokens: {
+        new: number;
+        changed: number;
+        unchanged: number;
+        removed: number;
+        draftOverwrites: number;
+    };
+    taxonomies: {
+        new: number;
+        changed: number;
+        unchanged: number;
+        removed: number;
+    };
+};
+export declare function buildApplyOutput(operation: ApplyOperationResponse, spaceId: string, environmentId: string, host: string | undefined): {
+    status: import("@contentful/experience-design-system-types").ApplyOperationStatus;
+    operationId: string;
+    spaceId: string;
+    environmentId: string;
+    summary: {
+        total: number;
+        pending: number;
+        succeeded: number;
+        failed: number;
+    };
+    componentTypes: {
+        created: number;
+        updated: number;
+        failed: number;
+    };
+    designTokens: {
+        created: number;
+        updated: number;
+        failed: number;
+    };
+    viewUrl: string;
+    tokensUrl: string;
+    failures: {
+        entityType: "ComponentType" | "DesignToken";
+        entityId: string;
+        error: string;
+    }[];
+};

package/legacy/dist/src/apply/helpers/has-breaking-changes.d.ts

@@ -0,0 +1,2 @@
+import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
+export declare function hasBreakingChangesWithImpact(preview: ServerPreviewResponse): boolean;

package/legacy/dist/src/apply/helpers/poll-apply-operation.d.ts

@@ -0,0 +1,9 @@
+import { ApiError, ImportApiClient } from '../api-client.js';
+import type { ApplyOperationResponse } from '@contentful/experience-design-system-types';
+export interface PollApplyOptions {
+    acknowledgeBreakingChanges: boolean;
+    onProgress?: (status: 'applying' | 'polling', operationId?: string) => void;
+    onStarted?: (operationId: string) => void;
+    onApiError: (error: ApiError) => Promise<void> | void;
+}
+export declare function pollApplyOperation(client: ImportApiClient, cdf: Parameters<ImportApiClient['applyImport']>[0], options: PollApplyOptions): Promise<ApplyOperationResponse | null>;

package/legacy/dist/src/apply/helpers/read-token-files.d.ts

@@ -0,0 +1,7 @@
+import type { CDFTokenEntry, DTCGTokenEntry } from '@contentful/experience-design-system-types';
+export declare function readJsonFile(flag: string, p: string): Promise<unknown>;
+export declare function readTokensFromPath(flag: string, p: string): Promise<DTCGTokenEntry[]>;
+export declare function toCDFTokens(tokens: DTCGTokenEntry[]): Array<{
+    path: string;
+    entry: CDFTokenEntry;
+}>;

package/legacy/dist/src/apply/helpers/slot-validation.d.ts

@@ -0,0 +1,20 @@
+import type { CDFComponentEntry, CDFValidationError } from '@contentful/experience-design-system-types';
+import { findSlotCycles } from '../../analyze/cycle-detection.js';
+export declare function detectSlotCycles(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>): ReturnType<typeof findSlotCycles>;
+export declare function formatSlotCycleReport(cycles: ReturnType<typeof findSlotCycles>): string[];
+export declare function assertNoSlotCycles(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>): Promise<void>;
+export declare function formatUnresolvedSlotReferences(errors: CDFValidationError[]): string[];
+export declare function assertNoUnresolvedSlotReferences(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>): Promise<void>;
+export declare function extractComponents(cdf: Record<string, unknown> | null | undefined): Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>;

package/legacy/dist/src/apply/services/apply-interactive.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { ImportApiClient } from '../api-client.js';
+export interface ApplyInteractiveOptions {
+    client: ImportApiClient;
+    cdf: Parameters<ImportApiClient['applyImport']>[0];
+    spaceId: string;
+    environmentId: string;
+    host?: string;
+    acknowledgeBreakingChanges: boolean;
+    rerender: (element: React.ReactElement) => void;
+    onDone: () => void;
+}
+export declare function applyInteractive(options: ApplyInteractiveOptions): Promise<void>;

package/legacy/dist/src/apply/services/apply-non-interactive.d.ts

@@ -0,0 +1,10 @@
+import { ImportApiClient } from '../api-client.js';
+export interface ApplyNonInteractiveOptions {
+    client: ImportApiClient;
+    cdf: Parameters<ImportApiClient['applyImport']>[0];
+    spaceId: string;
+    environmentId: string;
+    host?: string;
+    acknowledgeBreakingChanges: boolean;
+}
+export declare function applyNonInteractive(options: ApplyNonInteractiveOptions): Promise<void>;

package/legacy/dist/src/apply/services/resolve-apply-inputs.d.ts

@@ -0,0 +1,14 @@
+import type { CDFComponentEntry, DTCGTokenEntry } from '@contentful/experience-design-system-types';
+import { ImportApiClient } from '../api-client.js';
+export interface ApplyInputs {
+    components: Array<{
+        key: string;
+        entry: CDFComponentEntry;
+    }>;
+    tokens: DTCGTokenEntry[];
+    client: ImportApiClient;
+    spaceId: string;
+    environmentId: string;
+    host?: string;
+}
+export declare function resolveApplyInputsOrDie(file: string): Promise<ApplyInputs>;