@riverbankcms/sdk 0.129.0 → 0.129.1

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

@@ -1,170 +0,0 @@
-import { type Result, type SiteId } from '../../../../core/src/index';
-import { type DryRunReport, type SiteCommandBatch, type SiteCommandExecutionSuccess, type SiteCommandOf, type SiteCommandPlanFor, type SiteCommandRef, type SiteCommandType, type SiteCommandValidationError } from '../../../../site-commands/src/index';
-import { type ManagementApiErrorRequest } from '../../client/management';
-import type { EnvTarget } from '../helpers';
-export type CliCommandBatchRefInput<TSource extends string = string> = Readonly<{
-    source: TSource;
-    siteId: SiteId;
-    targetEnv: EnvTarget;
-}>;
-export type CliCommandExecutionError<TCommandType extends SiteCommandType> = Readonly<{
-    code: 'management_api_failed';
-    commandRef: SiteCommandRef;
-    commandType: TCommandType;
-    message: string;
-    detail?: CliCommandFailureDetail;
-}>;
-export type CliCommandFailureFieldError = Readonly<{
-    field: string;
-    message: string;
-    code?: string;
-}>;
-export type CliCommandFailureDetail = Readonly<{
-    tag: 'management_api';
-    code: string;
-    statusCode?: number;
-    request?: ManagementApiErrorRequest;
-    fieldErrors: readonly CliCommandFailureFieldError[];
-    details?: unknown;
-}> | Readonly<{
-    tag: 'unknown';
-}>;
-export type CliCommandExecutionResult<TCommandType extends SiteCommandType> = Readonly<{
-    status: 'applied';
-    applied: readonly SiteCommandExecutionSuccess[];
-}> | Readonly<{
-    status: 'failed';
-    applied: readonly SiteCommandExecutionSuccess[];
-    failed: CliCommandExecutionError<TCommandType>;
-}>;
-export type PlannedCliCommand<TCommand extends Readonly<{
-    ref: SiteCommandRef;
-    type: SiteCommandType;
-}>> = Readonly<{
-    command: TCommand;
-}>;
-export type CliCommandReportBinding<TCommand extends Readonly<{
-    ref: SiteCommandRef;
-    type: SiteCommandType;
-}>, TSubject> = Readonly<{
-    command: TCommand;
-    reportSubject: TSubject;
-}>;
-export type CliCommandReportedPlannedCommand<TCommand extends Readonly<{
-    ref: SiteCommandRef;
-    type: SiteCommandType;
-}>, TSubject> = Readonly<{
-    plannedCommand: PlannedCliCommand<TCommand>;
-    reportSubject: TSubject;
-}>;
-export type CliCommandExecutionReportFailure<TSubject> = Readonly<{
-    identifier: string;
-    message: string;
-    detail?: CliCommandFailureDetail;
-    subject?: TSubject;
-}>;
-export type CliCommandOutcome<TSubject> = Readonly<{
-    status: 'applied';
-    commandRef: SiteCommandRef;
-    commandType: SiteCommandType;
-    subject: TSubject;
-}> | Readonly<{
-    status: 'failed';
-    commandRef: SiteCommandRef;
-    commandType: SiteCommandType;
-    identifier: string;
-    message: string;
-    detail?: CliCommandFailureDetail;
-    subject?: TSubject;
-}> | Readonly<{
-    status: 'skipped_by_stop_policy';
-    commandRef: SiteCommandRef;
-    commandType: SiteCommandType;
-    identifier: string;
-    subject: TSubject;
-}> | Readonly<{
-    status: 'compile_failed';
-    identifier: string;
-    message: string;
-    subject?: TSubject;
-}> | Readonly<{
-    status: 'preflight_failed';
-    identifier: string;
-    message: string;
-    subject?: TSubject;
-}>;
-export type CliCommandExecutionReport<TSubject> = Readonly<{
-    outcomes: readonly CliCommandOutcome<TSubject>[];
-    appliedSubjects: readonly TSubject[];
-    failure: CliCommandExecutionReportFailure<TSubject> | null;
-    warnings: readonly string[];
-}>;
-export type CliCommandValidationCompileError = Readonly<{
-    code: 'command_validation_failed';
-    errors: readonly SiteCommandValidationError[];
-    message: string;
-}>;
-export type CliCommandCompileBatchSuccess<TCommandType extends SiteCommandType> = Readonly<{
-    batch: SiteCommandBatch;
-    plan: SiteCommandPlanFor<TCommandType>;
-    dryRunReport: DryRunReport;
-}>;
-export type CliCommandCompileBatchSuccessWithReports<TCommandType extends SiteCommandType, TSubject> = Readonly<{
-    reportedCommands: readonly CliCommandReportedPlannedCommand<SiteCommandOf<TCommandType>, TSubject>[];
-}> & CliCommandCompileBatchSuccess<TCommandType>;
-export declare function createCliCommandBatchRef(input: CliCommandBatchRefInput): string;
-export declare function formatSiteCommandValidationErrors(errors: readonly {
-    message: string;
-}[]): string;
-export declare function managementErrorDetail(error: unknown): CliCommandFailureDetail;
-export declare function formatManagementError(error: unknown): string;
-export declare function planCliCommandBatchForTypes<TCommandType extends SiteCommandType>(input: CliCommandBatchRefInput & Readonly<{
-    commands: readonly SiteCommandOf<TCommandType>[];
-    commandTypes: readonly TCommandType[];
-}>): Result<CliCommandCompileBatchSuccess<TCommandType>, CliCommandValidationCompileError>;
-export declare function planCliCommandBatchForBindings<TCommandType extends SiteCommandType, TSubject>(input: CliCommandBatchRefInput & Readonly<{
-    commandBindings: readonly CliCommandReportBinding<SiteCommandOf<TCommandType>, TSubject>[];
-    commandTypes: readonly TCommandType[];
-}>): Result<CliCommandCompileBatchSuccessWithReports<TCommandType, TSubject>, CliCommandValidationCompileError>;
-export declare function executeCliCommandPlan<TCommand extends Readonly<{
-    ref: SiteCommandRef;
-    type: TCommandType;
-}>, TCommandType extends SiteCommandType>(input: Readonly<{
-    commands: readonly PlannedCliCommand<TCommand>[];
-    applyCommand: (command: TCommand) => Promise<void>;
-}>): Promise<CliCommandExecutionResult<TCommandType>>;
-export declare function commandExecutionToReport<TCommand extends Readonly<{
-    ref: SiteCommandRef;
-    type: TCommandType;
-}>, TCommandType extends SiteCommandType, TSubject>(input: Readonly<{
-    execution: CliCommandExecutionResult<TCommandType>;
-    reportedCommands: readonly CliCommandReportedPlannedCommand<TCommand, TSubject>[];
-    resourceLabel: string;
-    commandDisplayIdentifier: (command: TCommand) => string;
-    includeFailureSubject?: boolean;
-}>): CliCommandExecutionReport<TSubject>;
-export declare function commandCompileFailureToReport<TSubject>(input: Readonly<{
-    identifier: string;
-    message: string;
-    detail?: CliCommandFailureDetail;
-    subject?: TSubject;
-    warnings?: readonly string[];
-}>): CliCommandExecutionReport<TSubject>;
-export declare function executeCompiledCliCommandPlanAsReport<TCompiledPlan extends Readonly<{
-    plan: Readonly<{
-        commands: readonly unknown[];
-    }>;
-}>, TExecutionResult, TSubject>(input: Readonly<{
-    compiledPlan: TCompiledPlan;
-    onBeforeExecute?: (commandCount: number) => void;
-    executePlan: (plan: TCompiledPlan['plan']) => Promise<TExecutionResult>;
-    executionToReport: (input: Readonly<{
-        execution: TExecutionResult;
-        compiledPlan: TCompiledPlan;
-    }>) => CliCommandExecutionReport<TSubject>;
-}>): Promise<CliCommandExecutionReport<TSubject>>;
-export declare function reportFromOutcomes<TSubject>(input: Readonly<{
-    outcomes: readonly CliCommandOutcome<TSubject>[];
-    warnings?: readonly string[];
-}>): CliCommandExecutionReport<TSubject>;
-export declare function commandReportHasFailures(report: CliCommandExecutionReport<unknown>): boolean;

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

@@ -1,21 +0,0 @@
-import { type SyncResult } from '../sync';
-import { type CliCommandExecutionReport } from './commandRuntime';
-export declare function commandReportToSyncResult<TSubject>(input: Readonly<{
-    report: CliCommandExecutionReport<TSubject>;
-    incrementSuccess: (result: SyncResult, subject: TSubject) => void;
-    recordFailure: (result: SyncResult, identifier: string, message: string, subject: TSubject | undefined) => void;
-}>): SyncResult;
-export declare function executeCompiledCliCommandPlanAsSyncResult<TCompiledPlan extends Readonly<{
-    plan: Readonly<{
-        commands: readonly unknown[];
-    }>;
-}>, TExecutionResult, TSubject>(input: Readonly<{
-    compiledPlan: TCompiledPlan;
-    onBeforeExecute?: (commandCount: number) => void;
-    executePlan: (plan: TCompiledPlan['plan']) => Promise<TExecutionResult>;
-    executionToReport: (input: Readonly<{
-        execution: TExecutionResult;
-        compiledPlan: TCompiledPlan;
-    }>) => CliCommandExecutionReport<TSubject>;
-    reportToSyncResult: (report: CliCommandExecutionReport<TSubject>) => SyncResult;
-}>): Promise<SyncResult>;

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

@@ -1,32 +0,0 @@
-import { type Result, 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 { ContentDiff, SyncResult } from '../sync';
-import { compilePagePushCommands } from './pageCommands';
-import type { CommandSurface, CommandSurfaceCompileResult, CommandSurfaceCompileSuccess, CommandSurfaceExecutionReport, CompiledContentPushExecutionPlan, CompiledContentPushExecutionStep, ContentPushExecutionPlan, ContentPushExecutionReport } from './pushExecutionTypes';
-export type CommandSurfaceDispatchInput = Readonly<{
-    siteId: SiteId;
-    target: EnvTarget;
-    diff: ContentDiff;
-    local: LocalContent;
-    client: ManagementClient;
-    customBlocks?: Parameters<typeof compilePagePushCommands>[0]['customBlocks'];
-    blockFieldExtensions: Parameters<typeof compilePagePushCommands>[0]['blockFieldExtensions'];
-    onEntryCommandCount?: (commandCount: number) => void;
-    onFormCommandCount?: (commandCount: number) => void;
-    onNavigationCommandCount?: (commandCount: number) => void;
-    onPageCommandCount?: (commandCount: number) => void;
-}>;
-export type CommandSurfaceDispatchDependencies = Readonly<{
-    compileCommandSurface?: (surface: CommandSurface, input: CommandSurfaceDispatchInput) => CommandSurfaceCompileResult;
-    preflightCommandSurfaceAsReport?: (surface: CommandSurfaceCompileSuccess, input: CommandSurfaceDispatchInput) => CommandSurfaceExecutionReport;
-    executeCommandSurfaceAsReport?: (surface: CommandSurfaceCompileSuccess, input: CommandSurfaceDispatchInput) => Promise<CommandSurfaceExecutionReport>;
-}>;
-export declare function compileContentPushExecutionPlan(plan: ContentPushExecutionPlan, input: CommandSurfaceDispatchInput, dependencies?: CommandSurfaceDispatchDependencies): Result<CompiledContentPushExecutionPlan, ContentPushExecutionReport>;
-export declare function preflightContentPushExecutionPlan(steps: readonly CompiledContentPushExecutionStep[], input: CommandSurfaceDispatchInput, dependencies?: CommandSurfaceDispatchDependencies): ContentPushExecutionReport;
-export declare function contentPushExecutionReportHasFailures(report: ContentPushExecutionReport): boolean;
-export declare function executeCommandSurfaceAsReport(surface: CommandSurfaceCompileSuccess, input: CommandSurfaceDispatchInput): Promise<CommandSurfaceExecutionReport>;
-export declare function preflightCommandSurfaceAsReport(surface: CommandSurfaceCompileSuccess, input: CommandSurfaceDispatchInput): CommandSurfaceExecutionReport;
-export declare function skippedRemainingCommandReports(steps: readonly CompiledContentPushExecutionStep[]): CommandSurfaceExecutionReport[];
-export declare function commandSurfaceReportToSyncResult(report: CommandSurfaceExecutionReport): SyncResult;

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

@@ -1,53 +0,0 @@
-import { type Result, type SiteId } from '../../../../core/src/index';
-import type { ManagementClient } from '../../client/management/types';
-import type { LocalEvent, LocalEventCategory, LocalVenue } from '../content/reader';
-import type { EnvTarget } from '../helpers';
-import type { PushScopeResult } from '../commands/push/scopes/types';
-import { type CliCommandCompileBatchSuccessWithReports, type CliCommandValidationCompileError } from './commandRuntime';
-export type CliDatedOfferingCommandBatchSource = 'push_venues' | 'push_event_categories' | 'push_events' | 'push_all_dated_offerings';
-export type DatedOfferingSiteCommandType = 'upsertVenue' | 'deleteVenue' | 'upsertEventCategory' | 'deleteEventCategory' | 'upsertEventSeries' | 'deleteEventSeries';
-type DatedOfferingCounter = 'created' | 'updated' | 'deleted';
-export type DatedOfferingReportSubject = Readonly<{
-    scopeCommand: 'venues' | 'event-categories' | 'events';
-    scopeName: string;
-    itemLabelSingular: string;
-    identifier: string;
-    counter: DatedOfferingCounter;
-}>;
-export type CliDatedOfferingCommandCompileError = Readonly<{
-    code: 'unsupported_local_shape';
-    identifier: string;
-    message: string;
-}> | CliCommandValidationCompileError;
-export type CliDatedOfferingCommandCompileInput = Readonly<{
-    source: CliDatedOfferingCommandBatchSource;
-    siteId: SiteId;
-    targetEnv: EnvTarget;
-    venues?: DatedOfferingUpsertInput<LocalVenue>;
-    eventCategories?: DatedOfferingUpsertInput<LocalEventCategory>;
-    events?: DatedOfferingUpsertInput<LocalEvent>;
-    delete?: DatedOfferingDeleteInput;
-}>;
-export type DatedOfferingUpsertInput<TItem> = Readonly<{
-    items: readonly DatedOfferingUpsertItem<TItem>[];
-}>;
-export type DatedOfferingUpsertItem<TItem> = Readonly<{
-    item: TItem;
-    exists: boolean;
-}>;
-export type DatedOfferingDeleteInput = Readonly<{
-    venues?: readonly string[];
-    eventCategories?: readonly string[];
-    events?: readonly string[];
-}>;
-export type CliDatedOfferingCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<DatedOfferingSiteCommandType, DatedOfferingReportSubject>;
-export declare const datedOfferingSiteCommandTypes: readonly ["upsertVenue", "deleteVenue", "upsertEventCategory", "deleteEventCategory", "upsertEventSeries", "deleteEventSeries"];
-export declare function compileDatedOfferingPushCommands(input: CliDatedOfferingCommandCompileInput): Result<CliDatedOfferingCommandCompileSuccess, CliDatedOfferingCommandCompileError>;
-export declare function executeDatedOfferingCommandPlanAsPushScopeResult(input: Readonly<{
-    client: Pick<ManagementClient, 'venues' | 'eventCategories' | 'events'>;
-    compiledPlan: CliDatedOfferingCommandCompileSuccess;
-    scopeCommand: DatedOfferingReportSubject['scopeCommand'];
-    scopeName: string;
-}>): Promise<PushScopeResult>;
-export declare function syncResultForDatedOfferingCommandCompileError(error: CliDatedOfferingCommandCompileError, scopeCommand: DatedOfferingReportSubject['scopeCommand'], scopeName: string): PushScopeResult;
-export {};

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

@@ -1,65 +0,0 @@
-import { type Result, type SiteId } from '../../../../core/src/index';
-import { type AllowedRuntime, 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 { ContentDiff } from '../sync/diff';
-import type { SyncResult } from '../sync';
-import { type CliContentTypeKey, type CliEntryIdentifier } from './commandKeys';
-import { type CliCommandCompileBatchSuccessWithReports, type CliCommandValidationCompileError, type CliCommandExecutionError, type CliCommandExecutionReport, type CliCommandExecutionResult } from './commandRuntime';
-export type CliEntryCommandBatchSource = 'push_entries' | 'merge_remote_entries';
-export type CliCommandCompileError = Readonly<{
-    code: 'missing_local_entry';
-    contentType: CliContentTypeKey;
-    identifier: CliEntryIdentifier;
-    message: string;
-}> | CliCommandValidationCompileError;
-export type CliEntryCommandCompileInput = Readonly<{
-    source: CliEntryCommandBatchSource;
-    siteId: SiteId;
-    targetEnv: EnvTarget;
-    diff: Pick<ContentDiff, 'entries'>;
-    local: Pick<LocalContent, 'entries'>;
-}>;
-export type CliEntryCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<EntrySiteCommandType, EntryCommandReportSubject>;
-export type CliEntryCommandExecutionError = CliCommandExecutionError<EntrySiteCommandType>;
-export type CliEntryCommandExecutionResult = CliCommandExecutionResult<EntrySiteCommandType>;
-export type CliEntryCommandSyncInput = Readonly<{
-    client: Pick<ManagementClient, 'entries'>;
-    compiledPlan: EntryCommandCompiledPlan;
-    onBeforeExecute?: (commandCount: number) => void;
-}>;
-export type EntrySiteCommandType = 'upsertContentEntry' | 'publishContentEntry' | 'unpublishContentEntry' | 'deleteContentEntry';
-export type EntrySiteCommand = SiteCommandOf<EntrySiteCommandType>;
-export type EntrySiteCommandPlan = CliEntryCommandCompileSuccess['plan'];
-export declare const entrySiteCommandTypes: readonly ["upsertContentEntry", "publishContentEntry", "unpublishContentEntry", "deleteContentEntry"];
-export type EntryCommandSyncCounter = 'created' | 'updated' | 'deleted' | 'published' | 'unpublished';
-export type EntryCommandReportSubject = Readonly<{
-    contentType: CliContentTypeKey;
-    identifier: CliEntryIdentifier;
-    counter: EntryCommandSyncCounter;
-}>;
-export type EntryCommandExecutionReport = CliCommandExecutionReport<EntryCommandReportSubject>;
-type EntryCommandCompiledPlan = Pick<CliEntryCommandCompileSuccess, 'plan' | 'reportedCommands'>;
-export declare function compileEntryPushCommands(input: CliEntryCommandCompileInput): Result<CliEntryCommandCompileSuccess, CliCommandCompileError>;
-/** SDK push only distinguishes local development and remote production targets today. */
-export declare function runtimeForCliTarget(targetEnv: EnvTarget): AllowedRuntime;
-export declare function executeEntryCommandPlan(input: Readonly<{
-    client: Pick<ManagementClient, 'entries'>;
-    plan: Pick<EntrySiteCommandPlan, 'commands'>;
-}>): Promise<CliEntryCommandExecutionResult>;
-export declare function executeEntryCommandPlanAsSyncResult(input: CliEntryCommandSyncInput): Promise<SyncResult>;
-export declare function executeEntryCommandPlanAsReport(input: CliEntryCommandSyncInput): Promise<EntryCommandExecutionReport>;
-export declare function syncResultForEntryCommandCompileError(error: CliCommandCompileError): SyncResult;
-export declare function entryCommandCompileErrorToReport(error: CliCommandCompileError): EntryCommandExecutionReport;
-export declare function entryCommandExecutionToSyncResult(input: Readonly<{
-    execution: CliEntryCommandExecutionResult;
-    compiledPlan: EntryCommandCompiledPlan;
-}>): SyncResult;
-export declare function entryCommandExecutionToReport(input: Readonly<{
-    execution: CliEntryCommandExecutionResult;
-    compiledPlan: EntryCommandCompiledPlan;
-}>): EntryCommandExecutionReport;
-export declare function entryCommandReportToSyncResult(report: EntryCommandExecutionReport): SyncResult;
-export declare function titleFromEntryData(data: Record<string, unknown>): string | undefined;
-export {};

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

@@ -1,24 +0,0 @@
-import { type Result } from '../../../../core/src/index';
-import type { SiteCommandOf } from '../../../../site-commands/src/index';
-import type { EventSeriesUpsertInput } from '../../client/management/types';
-type EventOccurrenceCompileInput = Readonly<{
-    startsAt: string;
-    endsAt: string;
-    timeZone: string;
-}>;
-type EventScheduleCompileInput = Readonly<{
-    identifier: string;
-    occurrences: ReadonlyArray<EventOccurrenceCompileInput>;
-}>;
-type ScheduleCompileError = Readonly<{
-    code: 'unsupported_local_shape';
-    identifier: string;
-    message: string;
-}>;
-export declare function compileExplicitEventSchedule(event: EventScheduleCompileInput): Result<Readonly<{
-    timeZone: string;
-    occurrences: SiteCommandOf<'upsertEventSeries'>['input']['occurrences'];
-}>, ScheduleCompileError>;
-export declare function scheduleFromExplicitEventOccurrence(occurrence: EventOccurrenceCompileInput): EventSeriesUpsertInput['schedule'];
-export declare function scheduleFromCommandOccurrence(occurrence: SiteCommandOf<'upsertEventSeries'>['input']['occurrences'][number], timeZone: SiteCommandOf<'upsertEventSeries'>['input']['timezone']): EventSeriesUpsertInput['schedule'];
-export {};

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

@@ -1,68 +0,0 @@
-import { type Result, type SiteId } from '../../../../core/src/index';
-import { type SiteCommandOf } from '../../../../site-commands/src/index';
-import type { ManagementClient, ManagementFooterContent } from '../../client/management/types';
-import type { LocalFooterContent } from '../content/reader';
-import type { EnvTarget } from '../helpers';
-import type { FooterDiff } from '../sync/diff';
-import type { SyncResult } from '../sync';
-import { type CliCommandCompileBatchSuccessWithReports, type CliCommandExecutionError, type CliCommandExecutionReport, type CliCommandExecutionResult, type CliCommandValidationCompileError } from './commandRuntime';
-export type CliFooterCommandBatchSource = 'push_footer';
-export type CliFooterCommandCompileError = CliCommandValidationCompileError;
-export type CliFooterCommandCompileInput = Readonly<{
-    source: CliFooterCommandBatchSource;
-    siteId: SiteId;
-    targetEnv: EnvTarget;
-    diff: FooterDiff;
-    local: LocalFooterContent;
-}>;
-export type CliFooterCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<FooterSiteCommandType, FooterCommandReportSubject>;
-export type FooterSiteCommandType = 'upsertFooterContent';
-export type FooterSiteCommand = SiteCommandOf<FooterSiteCommandType>;
-export type FooterSiteCommandPlan = CliFooterCommandCompileSuccess['plan'];
-export type CliFooterCommandExecutionError = CliCommandExecutionError<FooterSiteCommandType>;
-export type CliFooterCommandApplication = Readonly<{
-    kind: 'not-applied';
-}> | Readonly<{
-    kind: 'applied';
-    authoritativeFooter: ManagementFooterContent | null;
-}>;
-export type CliFooterCommandExecutionResult = Readonly<{
-    execution: CliCommandExecutionResult<FooterSiteCommandType>;
-    application: CliFooterCommandApplication;
-}>;
-export declare const footerSiteCommandTypes: readonly ["upsertFooterContent"];
-export type FooterCommandReportSubject = Readonly<{
-    identifier: 'footer';
-}>;
-export type FooterCommandExecutionReport = CliCommandExecutionReport<FooterCommandReportSubject>;
-type FooterCommandCompiledPlan = Pick<CliFooterCommandCompileSuccess, 'plan' | 'reportedCommands'>;
-export declare function compileFooterPushCommands(input: CliFooterCommandCompileInput): Result<CliFooterCommandCompileSuccess, CliFooterCommandCompileError>;
-export declare function executeFooterCommandPlan(input: Readonly<{
-    client: Pick<ManagementClient, 'footer'>;
-    plan: Pick<FooterSiteCommandPlan, 'commands'>;
-}>): Promise<CliFooterCommandExecutionResult>;
-export declare function executeFooterCommandPlanAsSyncResult(input: Readonly<{
-    client: Pick<ManagementClient, 'footer'>;
-    compiledPlan: FooterCommandCompiledPlan;
-    onBeforeExecute?: (commandCount: number) => void;
-}>): Promise<Readonly<{
-    syncResult: SyncResult;
-    application: CliFooterCommandApplication;
-}>>;
-export declare function executeFooterCommandPlanAsReport(input: Readonly<{
-    client: Pick<ManagementClient, 'footer'>;
-    compiledPlan: FooterCommandCompiledPlan;
-    onBeforeExecute?: (commandCount: number) => void;
-}>): Promise<FooterCommandExecutionReport>;
-export declare function syncResultForFooterCommandCompileError(error: CliFooterCommandCompileError): SyncResult;
-export declare function footerCommandCompileErrorToReport(error: CliFooterCommandCompileError): FooterCommandExecutionReport;
-export declare function footerCommandExecutionToSyncResult(input: Readonly<{
-    execution: CliFooterCommandExecutionResult;
-    compiledPlan: FooterCommandCompiledPlan;
-}>): SyncResult;
-export declare function footerCommandExecutionToReport(input: Readonly<{
-    execution: CliFooterCommandExecutionResult;
-    compiledPlan: FooterCommandCompiledPlan;
-}>): FooterCommandExecutionReport;
-export declare function footerCommandReportToSyncResult(report: FooterCommandExecutionReport): SyncResult;
-export {};

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

@@ -1,53 +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 { ContentDiff } from '../sync/diff';
-import type { SyncResult } from '../sync';
-import { type CliFormSlug } from './commandKeys';
-import { type CliCommandCompileBatchSuccessWithReports, type CliCommandExecutionError, type CliCommandExecutionReport, type CliCommandExecutionResult, type CliCommandValidationCompileError } from './commandRuntime';
-export type CliFormCommandBatchSource = 'push_forms';
-export type CliFormCommandCompileError = Readonly<{
-    code: 'missing_local_form';
-    slug: CliFormSlug;
-    message: string;
-}> | CliCommandValidationCompileError;
-export type CliFormCommandCompileInput = Readonly<{
-    source: CliFormCommandBatchSource;
-    siteId: SiteId;
-    targetEnv: EnvTarget;
-    diff: Pick<ContentDiff, 'forms'>;
-    local: Pick<LocalContent, 'forms'>;
-}>;
-export type CliFormCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<FormSiteCommandType, FormCommandReportSubject>;
-export type FormSiteCommandType = 'upsertForm';
-export type FormSiteCommand = SiteCommandOf<FormSiteCommandType>;
-export type FormSiteCommandPlan = CliFormCommandCompileSuccess['plan'];
-export type CliFormCommandExecutionError = CliCommandExecutionError<FormSiteCommandType>;
-export type CliFormCommandExecutionResult = CliCommandExecutionResult<FormSiteCommandType>;
-export declare const formSiteCommandTypes: readonly ["upsertForm"];
-export type FormCommandSyncCounter = 'created' | 'updated';
-export type FormCommandReportSubject = Readonly<{
-    slug: CliFormSlug;
-    counter: FormCommandSyncCounter;
-}>;
-export type FormCommandExecutionReport = CliCommandExecutionReport<FormCommandReportSubject>;
-type FormCommandCompiledPlan = Pick<CliFormCommandCompileSuccess, 'plan' | 'reportedCommands'>;
-export declare function compileFormPushCommands(input: CliFormCommandCompileInput): Result<CliFormCommandCompileSuccess, CliFormCommandCompileError>;
-export declare function executeFormCommandPlan(input: Readonly<{
-    client: Pick<ManagementClient, 'forms'>;
-    plan: Pick<FormSiteCommandPlan, 'commands'>;
-}>): Promise<CliFormCommandExecutionResult>;
-export declare function executeFormCommandPlanAsReport(input: Readonly<{
-    client: Pick<ManagementClient, 'forms'>;
-    compiledPlan: FormCommandCompiledPlan;
-    onBeforeExecute?: (commandCount: number) => void;
-}>): Promise<FormCommandExecutionReport>;
-export declare function formCommandCompileErrorToReport(error: CliFormCommandCompileError): FormCommandExecutionReport;
-export declare function formCommandExecutionToReport(input: Readonly<{
-    execution: CliFormCommandExecutionResult;
-    compiledPlan: FormCommandCompiledPlan;
-}>): FormCommandExecutionReport;
-export declare function formCommandReportToSyncResult(report: FormCommandExecutionReport): SyncResult;
-export {};

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

@@ -1,8 +0,0 @@
-export * from './commandRuntime';
-export * from './datedOfferingCommands';
-export * from './entryCommands';
-export * from './formCommands';
-export * from './footerCommands';
-export * from './navigationCommands';
-export * from './pageCommands';
-export * from './pushExecution';

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

@@ -1,31 +0,0 @@
-import type { BlockFieldExtensionsMap, FieldDefinition, SdkCustomBlock } from '../../config/types';
-export type LocalBlockManifest = Readonly<{
-    name: string;
-    fields: readonly FieldDefinition[];
-}> & Record<string, unknown>;
-export type LocalBlockManifestResolution = Readonly<{
-    kind: 'builtin_found';
-    manifest: LocalBlockManifest;
-    extensionFields: readonly FieldDefinition[];
-}> | Readonly<{
-    kind: 'custom_found';
-    manifest: LocalBlockManifest;
-    extensionFields: readonly FieldDefinition[];
-}> | Readonly<{
-    kind: 'extension_only_custom_found';
-    manifest: LocalBlockManifest;
-}> | Readonly<{
-    kind: 'unknown_builtin';
-}> | Readonly<{
-    kind: 'unknown_custom';
-}>;
-export type ResolveLocalBlockManifestInput = Readonly<{
-    kind: string;
-    customBlocks?: readonly SdkCustomBlock[];
-    blockFieldExtensions?: BlockFieldExtensionsMap;
-}>;
-export type ResolveLocalBlockManifestFromSourcesInput = ResolveLocalBlockManifestInput & Readonly<{
-    builtInManifest?: LocalBlockManifest;
-}>;
-export declare function resolveLocalBlockManifest(input: ResolveLocalBlockManifestInput): LocalBlockManifestResolution;
-export declare function resolveLocalBlockManifestFromSources(input: ResolveLocalBlockManifestFromSourcesInput): LocalBlockManifestResolution;

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

@@ -1,57 +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 { NavigationDiff } from '../sync/diff';
-import type { SyncResult } from '../sync';
-import { type CliNavigationMenuName } from './commandKeys';
-import { type CliCommandCompileBatchSuccessWithReports, type CliCommandExecutionError, type CliCommandExecutionReport, type CliCommandExecutionResult, type CliCommandValidationCompileError } from './commandRuntime';
-export type CliNavigationCommandBatchSource = 'push_navigation';
-export type CliNavigationCommandCompileError = Readonly<{
-    code: 'missing_local_navigation_menu';
-    name: CliNavigationMenuName;
-    message: string;
-}> | Readonly<{
-    code: 'duplicate_navigation_identity';
-    identity: string;
-    message: string;
-}> | CliCommandValidationCompileError;
-export type CliNavigationCommandCompileInput = Readonly<{
-    source: CliNavigationCommandBatchSource;
-    siteId: SiteId;
-    targetEnv: EnvTarget;
-    diff: readonly NavigationDiff[];
-    local: Pick<LocalContent, 'navigation'>;
-}>;
-export type CliNavigationCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<NavigationSiteCommandType, NavigationCommandReportSubject>;
-export type CliNavigationCommandExecutionError = CliCommandExecutionError<NavigationSiteCommandType>;
-export type CliNavigationCommandExecutionResult = CliCommandExecutionResult<NavigationSiteCommandType>;
-export type NavigationSiteCommandType = 'upsertNavigationMenu';
-export type NavigationSiteCommand = SiteCommandOf<NavigationSiteCommandType>;
-export type NavigationSiteCommandPlan = CliNavigationCommandCompileSuccess['plan'];
-export declare const navigationSiteCommandTypes: readonly ["upsertNavigationMenu"];
-export type NavigationCommandSyncCounter = 'created' | 'updated';
-export type NavigationCommandReportSubject = Readonly<{
-    name: CliNavigationMenuName;
-    counter: NavigationCommandSyncCounter;
-}>;
-export type NavigationCommandExecutionReport = CliCommandExecutionReport<NavigationCommandReportSubject>;
-type NavigationCommandCompiledPlan = Pick<CliNavigationCommandCompileSuccess, 'plan' | 'reportedCommands'>;
-export declare function compileNavigationPushCommands(input: CliNavigationCommandCompileInput): Result<CliNavigationCommandCompileSuccess, CliNavigationCommandCompileError>;
-export declare function executeNavigationCommandPlan(input: Readonly<{
-    client: Pick<ManagementClient, 'navigation'>;
-    plan: Pick<NavigationSiteCommandPlan, 'commands'>;
-}>): Promise<CliNavigationCommandExecutionResult>;
-export declare function executeNavigationCommandPlanAsReport(input: Readonly<{
-    client: Pick<ManagementClient, 'navigation'>;
-    compiledPlan: NavigationCommandCompiledPlan;
-    onBeforeExecute?: (commandCount: number) => void;
-}>): Promise<NavigationCommandExecutionReport>;
-export declare function navigationCommandCompileErrorToReport(error: CliNavigationCommandCompileError): NavigationCommandExecutionReport;
-export declare function navigationCommandExecutionToReport(input: Readonly<{
-    execution: CliNavigationCommandExecutionResult;
-    compiledPlan: NavigationCommandCompiledPlan;
-}>): NavigationCommandExecutionReport;
-export declare function navigationCommandReportToSyncResult(report: NavigationCommandExecutionReport): SyncResult;
-export {};