@riverbankcms/sdk 0.129.0 → 0.129.1

package/dist/_dts/sdk/src/cli/site-commands/oneOffCommands.d.ts

@@ -1,82 +0,0 @@
-import { type Result, type SiteId } from '../../../../core/src/index';
-import type { ManagementBlock, ManagementClient, ManagementNavigationMenu, ManagementPage, NavigationItemInput, UpsertedManagementEntry } from '../../client/management/types';
-import type { EnvTarget } from '../helpers';
-import { type CliCommandCompileBatchSuccessWithReports, type CliCommandValidationCompileError } from './commandRuntime';
-import { type EntryCommandReportSubject, type EntrySiteCommand, type EntrySiteCommandType } from './entryCommands';
-import { type NavigationCommandReportSubject, type NavigationSiteCommand, type NavigationSiteCommandType } from './navigationCommands';
-import { type PageCommandReportSubject, type PageSiteCommand, type PageSiteCommandType } from './pageCommands';
-export type OneOffCommandBatchSource = 'one_off_entry' | 'one_off_page' | 'one_off_block' | 'one_off_navigation';
-type OneOffCompileInput<TMutation> = Readonly<{
-    source: OneOffCommandBatchSource;
-    siteId: SiteId;
-    targetEnv: EnvTarget;
-    mutation: TMutation;
-}>;
-export type OneOffEntryMutation = Readonly<{
-    kind: 'upsert';
-    contentType: string;
-    identifier: string;
-    data: Record<string, unknown>;
-    slug?: string;
-}> | Readonly<{
-    kind: 'publish' | 'unpublish';
-    contentType: string;
-    identifier: string;
-}>;
-export type OneOffPageMutation = Readonly<{
-    kind: 'upsert';
-    identifier: string;
-    title: string;
-    path: string;
-    seoTitle?: string;
-    seoDescription?: string;
-}> | Readonly<{
-    kind: 'publish' | 'unpublish';
-    identifier: string;
-}>;
-export type OneOffBlockMutation = Readonly<{
-    kind: 'upsert';
-    pageIdentifier: string;
-    blockIdentifier: string;
-    blockKind: string;
-    data: Record<string, unknown>;
-}> | Readonly<{
-    kind: 'reorder';
-    pageIdentifier: string;
-    blockIdentifiers: readonly string[];
-}>;
-export type OneOffNavigationMutation = Readonly<{
-    kind: 'upsert';
-    identifier?: string;
-    menuName: string;
-    items: readonly NavigationItemInput[];
-}>;
-export type OneOffEntryCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<EntrySiteCommandType, EntryCommandReportSubject>;
-export type OneOffPageCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<PageSiteCommandType, PageCommandReportSubject>;
-export type OneOffNavigationCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<NavigationSiteCommandType, NavigationCommandReportSubject>;
-export declare function compileOneOffEntryCommand(input: OneOffCompileInput<OneOffEntryMutation>): Result<OneOffEntryCommandCompileSuccess, CliCommandValidationCompileError>;
-export declare function compileOneOffPageCommand(input: OneOffCompileInput<OneOffPageMutation>): Result<OneOffPageCommandCompileSuccess, CliCommandValidationCompileError>;
-export declare function compileOneOffBlockCommand(input: OneOffCompileInput<OneOffBlockMutation>): Result<OneOffPageCommandCompileSuccess, CliCommandValidationCompileError>;
-export declare function compileOneOffNavigationCommand(input: OneOffCompileInput<OneOffNavigationMutation>): Result<OneOffNavigationCommandCompileSuccess, CliCommandValidationCompileError>;
-export declare function executeOneOffEntryCommand<TResult>(input: Readonly<{
-    compiledPlan: Pick<OneOffEntryCommandCompileSuccess, 'plan'>;
-    client: Pick<ManagementClient, 'entries'>;
-    apply: (command: EntrySiteCommand, client: Pick<ManagementClient, 'entries'>) => Promise<TResult>;
-}>): Promise<TResult>;
-export declare function executeOneOffPageCommand<TResult>(input: Readonly<{
-    compiledPlan: Pick<OneOffPageCommandCompileSuccess, 'plan'>;
-    client: Pick<ManagementClient, 'pages' | 'blocks'>;
-    apply: (command: PageSiteCommand, client: Pick<ManagementClient, 'pages' | 'blocks'>) => Promise<TResult>;
-}>): Promise<TResult>;
-export declare function executeOneOffNavigationCommand<TResult>(input: Readonly<{
-    compiledPlan: Pick<OneOffNavigationCommandCompileSuccess, 'plan'>;
-    client: Pick<ManagementClient, 'navigation'>;
-    apply: (command: NavigationSiteCommand, client: Pick<ManagementClient, 'navigation'>) => Promise<TResult>;
-}>): Promise<TResult>;
-export declare function applyOneOffEntryCommand(command: EntrySiteCommand, client: Pick<ManagementClient, 'entries'>): Promise<UpsertedManagementEntry | void>;
-export declare function applyOneOffEntryCommandReturningEntry(command: EntrySiteCommand, client: Pick<ManagementClient, 'entries'>): Promise<UpsertedManagementEntry>;
-export declare function applyOneOffPageCommand(command: PageSiteCommand, client: Pick<ManagementClient, 'pages' | 'blocks'>): Promise<ManagementPage | ManagementBlock | void>;
-export declare function applyOneOffPageCommandReturningPage(command: PageSiteCommand, client: Pick<ManagementClient, 'pages' | 'blocks'>): Promise<ManagementPage>;
-export declare function applyOneOffPageCommandReturningBlock(command: PageSiteCommand, client: Pick<ManagementClient, 'pages' | 'blocks'>): Promise<ManagementBlock>;
-export declare function applyOneOffNavigationCommand(command: NavigationSiteCommand, client: Pick<ManagementClient, 'navigation'>): Promise<ManagementNavigationMenu>;
-export {};

package/dist/_dts/sdk/src/cli/site-commands/pageCommands.d.ts

@@ -1,84 +0,0 @@
-import { type Result, type SiteId } from '../../../../core/src/index';
-import { type SiteCommandOf } from '../../../../site-commands/src/index';
-import type { ManagementClient } from '../../client/management/types';
-import type { LocalContent } from '../content/reader';
-import type { EnvTarget } from '../helpers';
-import type { BlockFieldExtensionsMap, SdkCustomBlock } from '../../config/types';
-import type { ContentDiff } from '../sync/diff';
-import type { SyncResult } from '../sync';
-import { type CliBlockIdentifier, type CliPageIdentifier } from './commandKeys';
-import { type CliCommandCompileBatchSuccessWithReports, type CliCommandExecutionError, type CliCommandExecutionReport, type CliCommandExecutionResult, type CliCommandValidationCompileError } from './commandRuntime';
-export type CliPageCommandBatchSource = 'push_pages';
-export type CliPageCommandCompileError = Readonly<{
-    code: 'missing_local_page';
-    identifier: CliPageIdentifier;
-    message: string;
-}> | Readonly<{
-    code: 'missing_local_block';
-    identifier: `${CliPageIdentifier}/${CliBlockIdentifier}`;
-    message: string;
-}> | Readonly<{
-    code: 'invalid_page_block';
-    identifier: `${CliPageIdentifier}/${CliBlockIdentifier}`;
-    warnings: readonly string[];
-    message: string;
-}> | CliCommandValidationCompileError;
-export type CliPageCommandCompileInput = Readonly<{
-    source: CliPageCommandBatchSource;
-    siteId: SiteId;
-    targetEnv: EnvTarget;
-    diff: Pick<ContentDiff, 'pages'>;
-    local: Pick<LocalContent, 'pages'>;
-    customBlocks?: readonly SdkCustomBlock[];
-    blockFieldExtensions?: BlockFieldExtensionsMap;
-}>;
-export type CliPageCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<PageSiteCommandType, PageCommandReportSubject> & Readonly<{
-    warnings: readonly string[];
-}>;
-export type PageSiteCommandType = 'upsertPage' | 'upsertPageBlock' | 'deletePageBlock' | 'reorderPageBlocks' | 'publishPage' | 'unpublishPage';
-export type PageSiteCommand = SiteCommandOf<PageSiteCommandType>;
-export type PageSiteCommandPlan = CliPageCommandCompileSuccess['plan'];
-export type CliPageCommandExecutionError = CliCommandExecutionError<PageSiteCommandType>;
-export type CliPageCommandExecutionResult = CliCommandExecutionResult<PageSiteCommandType>;
-export declare const pageSiteCommandTypes: readonly ["upsertPage", "upsertPageBlock", "deletePageBlock", "reorderPageBlocks", "publishPage", "unpublishPage"];
-export type PageCommandSyncCounter = 'created' | 'updated' | 'published' | 'unpublished';
-export type BlockCommandSyncCounter = 'created' | 'updated' | 'deleted' | 'reordered';
-export type PageCommandReportSubject = Readonly<{
-    resource: 'page';
-    identifier: CliPageIdentifier;
-    counter: PageCommandSyncCounter;
-}> | Readonly<{
-    resource: 'block';
-    pageIdentifier: CliPageIdentifier;
-    identifier: CliBlockIdentifier | CliPageIdentifier;
-    counter: BlockCommandSyncCounter;
-}>;
-export type PageCommandExecutionReport = CliCommandExecutionReport<PageCommandReportSubject>;
-export type PageCommandCompiledPlan = Pick<CliPageCommandCompileSuccess, 'plan' | 'reportedCommands' | 'warnings'>;
-export declare function compilePagePushCommands(input: CliPageCommandCompileInput): Result<CliPageCommandCompileSuccess, CliPageCommandCompileError>;
-export type PageCommandRoutingDecision = Readonly<{
-    kind: 'no_page_changes';
-}> | Readonly<{
-    kind: 'command_backed';
-}>;
-export declare function pageCommandRouting(diff: Pick<ContentDiff, 'pages'>): PageCommandRoutingDecision;
-export declare function executePageCommandPlan(input: Readonly<{
-    client: Pick<ManagementClient, 'pages' | 'blocks'>;
-    plan: Pick<PageSiteCommandPlan, 'commands'>;
-}>): Promise<CliPageCommandExecutionResult>;
-export declare function executePageCommandPlanAsReport(input: Readonly<{
-    client: Pick<ManagementClient, 'pages' | 'blocks'>;
-    compiledPlan: PageCommandCompiledPlan;
-    onBeforeExecute?: (commandCount: number) => void;
-}>): Promise<PageCommandExecutionReport>;
-export declare function pageCommandCompileErrorToReport(error: CliPageCommandCompileError): PageCommandExecutionReport;
-export declare function pageCommandExecutionToReport(input: Readonly<{
-    execution: CliPageCommandExecutionResult;
-    compiledPlan: PageCommandCompiledPlan;
-}>): PageCommandExecutionReport;
-export declare function preflightPageCommandPlanAsReport(input: Readonly<{
-    compiledPlan: PageCommandCompiledPlan;
-    customBlocks?: readonly SdkCustomBlock[];
-    blockFieldExtensions?: BlockFieldExtensionsMap;
-}>): PageCommandExecutionReport;
-export declare function pageCommandReportToSyncResult(report: PageCommandExecutionReport): SyncResult;

package/dist/_dts/sdk/src/cli/site-commands/pushExecution.d.ts

@@ -1,39 +0,0 @@
-import { type SiteId } from '../../../../core/src/index';
-import type { ManagementClient } from '../../client/management/types';
-import type { LocalContent } from '../content/reader';
-import type { EnvTarget } from '../helpers';
-import type { OutputContext } from '../output';
-import { type ContentDiff, type SyncResult } from '../sync';
-import { type CommandSurfaceDispatchDependencies } from './commandSurfaceDispatch';
-import { planContentPushExecution } from './pushExecutionPlan';
-import type { CommandSurface, CommandSurfaceCompileResult, CommandSurfaceCompileSuccess, CommandSurfaceExecutionReport, CompiledContentPushExecutionPlan, ContentPushScope, ContentPushExecutionPlan, ContentPushExecutionReport, ContentPushExecutionStep } from './pushExecutionTypes';
-import type { compilePagePushCommands } from './pageCommands';
-export { planContentPushExecution };
-export type { CommandSurface, CommandSurfaceCompileResult, CommandSurfaceCompileSuccess, CommandSurfaceExecutionReport, ContentPushScope, ContentPushExecutionPlan, ContentPushExecutionReport, ContentPushExecutionStep, };
-export type ContentPushExecutionInput = Readonly<{
-    pushScope: ContentPushScope;
-    siteId: SiteId;
-    target: EnvTarget;
-    diff: ContentDiff;
-    local: LocalContent;
-    client: ManagementClient;
-    customBlocks?: Parameters<typeof compilePagePushCommands>[0]['customBlocks'];
-    blockFieldExtensions: Parameters<typeof compilePagePushCommands>[0]['blockFieldExtensions'];
-    output: OutputContext;
-    onEntryCommandCount?: (commandCount: number) => void;
-    onFormCommandCount?: (commandCount: number) => void;
-    onNavigationCommandCount?: (commandCount: number) => void;
-    onPageCommandCount?: (commandCount: number) => void;
-}>;
-export declare function executeContentPushPlan(input: ContentPushExecutionInput): Promise<SyncResult>;
-export declare function executeContentPushPlanAsCommandReport(input: ContentPushExecutionInput, dependencies?: CommandSurfaceDispatchDependencies): Promise<ContentPushExecutionReport>;
-export type ContentPushPreflightOutcome = Readonly<{
-    ok: true;
-    compiled: CompiledContentPushExecutionPlan;
-    report: ContentPushExecutionReport;
-}> | Readonly<{
-    ok: false;
-    report: ContentPushExecutionReport;
-}>;
-export declare function preflightContentPushPlanAsCommandReport(input: ContentPushExecutionInput, dependencies?: CommandSurfaceDispatchDependencies): ContentPushPreflightOutcome;
-export declare function contentPushExecutionReportToSyncResult(report: ContentPushExecutionReport): SyncResult;

package/dist/_dts/sdk/src/cli/site-commands/pushExecutionPlan.d.ts

@@ -1,8 +0,0 @@
-import type { LocalContent } from '../content/reader';
-import type { ContentDiff } from '../sync';
-import type { ContentPushScope, ContentPushExecutionPlan } from './pushExecutionTypes';
-export declare function planContentPushExecution(input: Readonly<{
-    pushScope: ContentPushScope;
-    diff: ContentDiff;
-    local: LocalContent;
-}>): ContentPushExecutionPlan;

package/dist/_dts/sdk/src/cli/site-commands/pushExecutionTypes.d.ts

@@ -1,97 +0,0 @@
-import type { SiteCommandRef, SiteCommandType } from '../../../../site-commands/src/index';
-import type { SyncResult, ResidualSettingsDiff, ResidualSettingsLocalContent } from '../sync';
-import type { PushScope } from '../commands/push/consts';
-import type { compileEntryPushCommands, EntryCommandExecutionReport } from './entryCommands';
-import type { compileFormPushCommands, FormCommandExecutionReport } from './formCommands';
-import type { compileNavigationPushCommands, NavigationCommandExecutionReport } from './navigationCommands';
-import type { compilePagePushCommands, PageCommandExecutionReport } from './pageCommands';
-export type CommandSurface = 'entry' | 'page' | 'form' | 'navigation';
-export type CommandSurfaceFailurePolicy = 'continue' | 'stop';
-export type ContentPushScope = Extract<PushScope, 'entries' | 'pages' | 'navigation' | 'forms' | 'settings' | 'all'>;
-export type ResidualSettingsPushPlan = Readonly<{
-    diff: ResidualSettingsDiff;
-    local: ResidualSettingsLocalContent;
-}>;
-export type CommandSurfaceCompileResult = Readonly<{
-    surface: 'entry';
-    compileResult: ReturnType<typeof compileEntryPushCommands>;
-}> | Readonly<{
-    surface: 'page';
-    compileResult: ReturnType<typeof compilePagePushCommands>;
-}> | Readonly<{
-    surface: 'form';
-    compileResult: ReturnType<typeof compileFormPushCommands>;
-}> | Readonly<{
-    surface: 'navigation';
-    compileResult: ReturnType<typeof compileNavigationPushCommands>;
-}>;
-export type CommandSurfaceCompileSuccess = Readonly<{
-    surface: 'entry';
-    compileValue: OkValue<ReturnType<typeof compileEntryPushCommands>>;
-}> | Readonly<{
-    surface: 'page';
-    compileValue: OkValue<ReturnType<typeof compilePagePushCommands>>;
-}> | Readonly<{
-    surface: 'form';
-    compileValue: OkValue<ReturnType<typeof compileFormPushCommands>>;
-}> | Readonly<{
-    surface: 'navigation';
-    compileValue: OkValue<ReturnType<typeof compileNavigationPushCommands>>;
-}>;
-type OkValue<T> = T extends Readonly<{
-    ok: true;
-    value: infer TValue;
-}> ? TValue : never;
-export type ContentPushExecutionStep = Readonly<{
-    kind: 'residual-settings-sync';
-    residual: ResidualSettingsPushPlan;
-    onFailure: CommandSurfaceFailurePolicy;
-}> | Readonly<{
-    kind: 'command-surface';
-    surface: CommandSurface;
-    onFailure: CommandSurfaceFailurePolicy;
-}>;
-export type CompiledContentPushExecutionStep = Readonly<{
-    kind: 'residual-settings-sync';
-    residual: ResidualSettingsPushPlan;
-    onFailure: CommandSurfaceFailurePolicy;
-}> | Readonly<{
-    kind: 'command-surface';
-    surface: CommandSurfaceCompileSuccess;
-    onFailure: CommandSurfaceFailurePolicy;
-}>;
-export type ContentPushExecutionPlan = Readonly<{
-    kind: 'sync-steps';
-    steps: readonly ContentPushExecutionStep[];
-}>;
-export type CompiledContentPushExecutionPlan = Readonly<{
-    kind: 'compiled-sync-steps';
-    steps: readonly CompiledContentPushExecutionStep[];
-}>;
-export type CommandSurfaceExecutionReport = Readonly<{
-    surface: 'entry';
-    report: EntryCommandExecutionReport;
-}> | Readonly<{
-    surface: 'page';
-    report: PageCommandExecutionReport;
-}> | Readonly<{
-    surface: 'form';
-    report: FormCommandExecutionReport;
-}> | Readonly<{
-    surface: 'navigation';
-    report: NavigationCommandExecutionReport;
-}>;
-export type ContentPushExecutionReport = Readonly<{
-    commandReports: readonly CommandSurfaceExecutionReport[];
-    residualSyncResults: readonly SyncResult[];
-}>;
-export type ReportedCommandWithSubject<TSubject> = Readonly<{
-    plannedCommand: Readonly<{
-        command: Readonly<{
-            ref: SiteCommandRef;
-            type: SiteCommandType;
-        }>;
-    }>;
-    reportSubject: TSubject;
-}>;
-export {};

package/dist/_dts/sdk/src/cli/site-commands/residualSettingsTrimming.d.ts

@@ -1,15 +0,0 @@
-import type { LocalContent } from '../content/reader';
-import type { ContentDiff } from '../sync';
-import type { CommandSurface, ResidualSettingsPushPlan } from './pushExecutionTypes';
-export declare const baselineResidualOmittedCommandSurfaces: readonly ["navigation"];
-export declare const baselineResidualOmittedCommandSurfaceSet: ReadonlySet<CommandSurface>;
-export declare function syncPlanResidual(input: Readonly<{
-    diff: ContentDiff;
-    local: LocalContent;
-    omitSurfaces: ReadonlySet<CommandSurface>;
-}>): ResidualSettingsPushPlan;
-export declare function residualSettingsPlan(input: Readonly<{
-    diff: ContentDiff;
-    local: LocalContent;
-    commandSurfaces: readonly CommandSurface[];
-}>): ResidualSettingsPushPlan | null;

package/dist/_dts/sdk/src/cli/sync/diff.d.ts

@@ -1,222 +0,0 @@
-/**
- * Content Diff Calculator
- *
- * Compares local content with remote CMS state to determine
- * what changes need to be made during push operations.
- */
-import type { LocalContent, LocalFooterContent } from '../content/reader';
-import type { PulledContent, ManagementFooterContent } from '../../client/management/types';
-import { type BuildFieldDiffOptions, type FieldChange } from './field-diff';
-export type { FieldChange } from './field-diff';
-export type DiffType = 'create' | 'update' | 'unchanged';
-export interface EntryDiff {
-    type: DiffType | 'delete';
-    identifier: string;
-    contentType: string;
-    /** List of changed field paths (for updates) */
-    changes?: string[];
-    /** Status change needed: publish or unpublish */
-    statusChange?: 'publish' | 'unpublish';
-}
-export interface PageDiff {
-    type: DiffType;
-    identifier: string;
-    /** List of changed field paths (for updates) */
-    changes?: string[];
-    /** Block diffs for this page */
-    blocks?: BlockDiff[];
-    /** Status change needed: publish or unpublish */
-    statusChange?: 'publish' | 'unpublish';
-}
-export interface BlockDiff {
-    type: DiffType | 'delete' | 'reorder';
-    identifier: string;
-    pageIdentifier: string;
-    /** List of changed field paths (for updates) */
-    changes?: string[];
-}
-export interface NavigationDiff {
-    type: DiffType;
-    identifier?: string | null;
-    name: string;
-    /** List of changed field paths (for updates) */
-    changes?: string[];
-}
-export interface SettingsDiff {
-    type: 'update';
-    /** List of changed field paths */
-    changes: string[];
-}
-export interface FormDiff {
-    type: DiffType;
-    slug: string;
-    /** List of changed field paths (for updates) */
-    changes?: string[];
-}
-export interface FooterDiff {
-    type: 'update' | 'unchanged';
-    /** List of changed field paths (for updates) */
-    changes?: string[];
-}
-export interface ContentDiff {
-    /** Entry diffs grouped by content type */
-    entries: Map<string, EntryDiff[]>;
-    /** Page diffs */
-    pages: PageDiff[];
-    /** Navigation menu diffs */
-    navigation: NavigationDiff[];
-    /** Settings diff (null if no local settings file) */
-    settings: SettingsDiff | null;
-    /** Form diffs */
-    forms: FormDiff[];
-    /** Footer diff (null if no local footer file) */
-    footer: FooterDiff | null;
-    /** Summary statistics */
-    summary: {
-        entries: {
-            create: number;
-            update: number;
-            delete: number;
-            unchanged: number;
-            publish: number;
-            unpublish: number;
-        };
-        pages: {
-            create: number;
-            update: number;
-            unchanged: number;
-            publish: number;
-            unpublish: number;
-        };
-        blocks: {
-            create: number;
-            update: number;
-            delete: number;
-            unchanged: number;
-        };
-        navigation: {
-            create: number;
-            update: number;
-            unchanged: number;
-        };
-        settings: {
-            update: number;
-            unchanged: number;
-        };
-        forms: {
-            create: number;
-            update: number;
-            unchanged: number;
-        };
-        footer: {
-            update: number;
-            unchanged: number;
-        };
-    };
-    /** Warnings about content that couldn't be processed */
-    warnings?: {
-        /** Number of remote entries without identifiers (can't be deleted via CLI) */
-        entriesWithoutIdentifier?: number;
-    };
-}
-export interface DiffOptions {
-    /** How to handle existing entries: 'skip' ignores updates, 'update' includes them */
-    existingEntries: 'skip' | 'update';
-    /** Whether to include delete diffs for remote entries not in local (default: false) */
-    deleteMissing?: boolean;
-}
-export type JsonDiffMode = 'summary' | 'full';
-export type JsonDiffOperation = 'create' | 'update' | 'delete';
-export type JsonDiffChangeType = 'entry' | 'page' | 'block' | 'navigation' | 'settings' | 'form';
-export interface JsonDiffChange {
-    type: JsonDiffChangeType;
-    identifier: string;
-    operation: JsonDiffOperation;
-    before?: unknown;
-    after?: unknown;
-    diff?: unknown;
-    /** Status change: publish or unpublish */
-    statusChange?: 'publish' | 'unpublish';
-}
-export interface JsonDiffWarning {
-    type: 'duplicate_navigation_identity';
-    source: 'local' | 'remote';
-    identity: string;
-    menuNames: readonly string[];
-    message: string;
-}
-export interface JsonDiff {
-    summary: {
-        creates: number;
-        updates: number;
-        deletes: number;
-        publishes: number;
-        unpublishes: number;
-    };
-    changes: JsonDiffChange[];
-    warnings?: readonly JsonDiffWarning[];
-}
-/** JSON diff output for pull --dry-run --json-diff */
-export interface PullJsonDiff {
-    mode: JsonDiffMode;
-    direction: 'pull';
-    summary: ContentDiff['summary'];
-    changes?: PullJsonDiffChange[];
-}
-export interface PullJsonDiffChange {
-    type: 'entry' | 'page' | 'navigation' | 'settings';
-    operation: 'create' | 'update';
-    identifier: string;
-    contentType?: string;
-    before?: unknown;
-    after?: unknown;
-}
-export declare function buildJsonDiff(diff: ContentDiff, local: LocalContent, remote: PulledContent, mode: JsonDiffMode): JsonDiff;
-export declare function calculateFooterDiff(localFooter: LocalFooterContent | null, remoteFooter: ManagementFooterContent | null): {
-    diff: FooterDiff | null;
-    summary: ContentDiff['summary']['footer'];
-};
-/**
- * Calculate differences between local content and remote CMS state.
- *
- * @param local - Local content from JSON files
- * @param remote - Remote content pulled from CMS
- * @param options - Diff options
- * @returns Content diff with all changes categorized
- */
-export declare function calculateDiff(local: LocalContent, remote: PulledContent, options: DiffOptions): ContentDiff;
-/**
- * Check if there are any pending changes in the diff.
- */
-export declare function hasPendingChanges(diff: ContentDiff): boolean;
-/**
- * Format diff summary for display.
- */
-export declare function formatDiffSummary(diff: ContentDiff): string;
-/**
- * Format detailed diff for display.
- */
-export declare function formatDiffDetail(diff: ContentDiff): string;
-/**
- * Calculate differences for pull operation (remote → local).
- * This is the inverse of calculateDiff - it shows what would change locally
- * if we pulled content from remote.
- *
- * @param remote - Remote content from CMS (source)
- * @param local - Local content from files (target, may be null if no local content)
- * @returns Content diff showing what would be created/updated locally
- */
-export declare function calculatePullDiff(remote: PulledContent, local: LocalContent | null): ContentDiff;
-/**
- * Find changed fields between two objects with their before/after values.
- */
-export declare function findChangedFieldsWithValues(local: Record<string, unknown>, remote: Record<string, unknown>, prefix?: string, options?: BuildFieldDiffOptions): FieldChange[];
-/**
- * Format a value for human-readable display.
- */
-export declare function formatValue(value: unknown): string;
-/**
- * Format a ContentDiff with field-level before/after values for human display.
- * Used by push --dry-run --diff.
- */
-export declare function formatHumanDiff(diff: ContentDiff, local: LocalContent, remote: PulledContent): string;

package/dist/_dts/sdk/src/cli/sync/executor.d.ts

@@ -1,84 +0,0 @@
-/**
- * Residual Sync Executor
- *
- * Applies the small set of SDK CLI writes that have not yet moved onto the
- * shared site-command IR. Command-backed surfaces fail closed here so direct
- * writes cannot silently come back through this path.
- */
-import type { ManagementClient } from '../../client/management/types';
-import type { LocalContent } from '../content/reader';
-import type { OutputContext } from '../output';
-import type { ContentDiff } from './diff';
-/**
- * Format API errors with detailed field validation info when available.
- */
-export declare function formatApiError(error: unknown): string;
-export interface SyncOptions {
-    /** If true, don't actually make changes */
-    dryRun: boolean;
-}
-export interface SyncResult {
-    entries: {
-        created: number;
-        updated: number;
-        deleted: number;
-        failed: number;
-        published: number;
-        unpublished: number;
-    };
-    pages: {
-        created: number;
-        updated: number;
-        failed: number;
-        published: number;
-        unpublished: number;
-    };
-    blocks: {
-        created: number;
-        updated: number;
-        deleted: number;
-        failed: number;
-    };
-    navigation: {
-        created: number;
-        updated: number;
-        failed: number;
-    };
-    settings: {
-        updated: number;
-        failed: number;
-    };
-    forms: {
-        created: number;
-        updated: number;
-        failed: number;
-    };
-    footer: {
-        updated: number;
-        failed: number;
-    };
-    errors: Array<{
-        resource: string;
-        identifier: string;
-        error: string;
-    }>;
-    warnings: string[];
-}
-export type ResidualSettingsDiff = Readonly<Pick<ContentDiff, 'settings' | 'summary'>>;
-export type ResidualSettingsLocalContent = Readonly<Pick<LocalContent, 'settings'>>;
-export declare function createEmptySyncResult(): SyncResult;
-/**
- * Execute the remaining settings-only sync plan.
- *
- * @param client - Management client
- * @param diff - Calculated content diff
- * @param local - Local content
- * @param options - Sync options (dryRun)
- * @param output - Output context for progress reporting
- * @returns Sync result with counts and errors
- */
-export declare function executeResidualSettingsSyncPlan(client: ManagementClient, diff: ResidualSettingsDiff, local: ResidualSettingsLocalContent, options: SyncOptions, output: OutputContext): Promise<SyncResult>;
-/**
- * Format sync result for display.
- */
-export declare function formatSyncResult(result: SyncResult, dryRun: boolean): string;

package/dist/_dts/sdk/src/cli/sync/field-diff.d.ts

@@ -1,39 +0,0 @@
-export type FieldPathSegment = Readonly<{
-    type: 'property';
-    key: string;
-}> | Readonly<{
-    type: 'index';
-    index: number;
-}> | Readonly<{
-    type: 'item';
-    key: string;
-}>;
-export type FieldDiffKind = 'added' | 'removed' | 'changed' | 'list_reordered';
-export type FieldDiff = Readonly<{
-    kind: FieldDiffKind;
-    path: readonly FieldPathSegment[];
-    before: unknown;
-    after: unknown;
-}>;
-export type FieldChange = Readonly<{
-    kind: FieldDiffKind;
-    path: string;
-    before: unknown;
-    after: unknown;
-    redacted?: true;
-}>;
-export type FieldDiffIdentityInput = Readonly<{
-    path: readonly FieldPathSegment[];
-    item: unknown;
-    index: number;
-}>;
-export type FieldDiffIdentity = (input: FieldDiffIdentityInput) => string | null | undefined;
-export type BuildFieldDiffOptions = Readonly<{
-    identifyArrayItem?: FieldDiffIdentity;
-}>;
-export declare function buildFieldDiffs(local: Record<string, unknown>, remote: Record<string, unknown>, options?: BuildFieldDiffOptions): FieldDiff[];
-export declare function formatFieldPath(path: readonly FieldPathSegment[]): string;
-export declare function fieldDiffToChange(diff: FieldDiff): FieldChange;
-export declare function buildFieldChanges(local: Record<string, unknown>, remote: Record<string, unknown>, options?: BuildFieldDiffOptions): FieldChange[];
-export declare function formatFieldDiffValue(value: unknown, maxChars?: number): string;
-export declare function formatFieldChange(change: FieldChange): string;