@riverbankcms/sdk 0.77.1 → 0.78.0

package/dist/_dts/media-core/src/assetsInUseSummary.d.ts

@@ -0,0 +1,34 @@
+export type AssetsInUseStage = 'draft' | 'published';
+export type AssetsInUseLocationLike = Readonly<{
+    kind: 'pageBlock';
+    pageDraftPath?: string | null;
+    pagePublishedPath?: string | null;
+    pageTitle?: string | null;
+    stage: AssetsInUseStage;
+    blockKind: string;
+}> | Readonly<{
+    kind: 'contentEntry';
+    routeDraftPath?: string | null;
+    routePublishedPath?: string | null;
+    entryTitle: string;
+    stage: AssetsInUseStage;
+}> | Readonly<{
+    kind: 'productFileDownload';
+    productTitle: string;
+}>;
+export type AssetsInUseItemLike = Readonly<{
+    usedCount: number;
+}>;
+export type AssetsInUseResponseLike<TItem extends AssetsInUseItemLike> = Readonly<{
+    items: readonly TItem[];
+}>;
+export type AssetsInUseSummary<TItem extends AssetsInUseItemLike> = Readonly<{
+    usedItems: readonly TItem[];
+    totalAssets: number;
+    totalLocations: number;
+    totalAssetLabel: 'item' | 'items';
+    totalLocationLabel: 'place' | 'places';
+}>;
+export declare function formatMediaUsageStage(stage: AssetsInUseStage): string;
+export declare function mediaUsageLocationLabel(location: AssetsInUseLocationLike): string;
+export declare function summarizeAssetsInUse<TItem extends AssetsInUseItemLike>(usage: AssetsInUseResponseLike<TItem> | null): AssetsInUseSummary<TItem>;

package/dist/_dts/media-core/src/bulkDeletePlanning.d.ts

@@ -0,0 +1,24 @@
+export type MediaUsageCheckItemWithCount = Readonly<{
+    usedCount: number;
+}>;
+export type MediaUsageCheckResponseWithCounts = Readonly<{
+    items: readonly MediaUsageCheckItemWithCount[];
+}>;
+export type BulkDeleteResultLike = Readonly<{
+    deleted: number;
+    failed: number;
+}>;
+export type BulkDeleteOptions = Readonly<{
+    deleteObjects?: boolean;
+    cascadeLabels?: boolean;
+}>;
+export declare const BULK_DELETE_IN_PROGRESS_MESSAGE = "Delete already in progress";
+export type BulkDeleteCompletionToast = Readonly<{
+    kind: 'success';
+    message: string;
+}> | Readonly<{
+    kind: 'error';
+    message: string;
+}>;
+export declare function hasMediaUsage(response: MediaUsageCheckResponseWithCounts): boolean;
+export declare function planBulkDeleteCompletionToast(result: BulkDeleteResultLike): BulkDeleteCompletionToast;

package/dist/_dts/media-core/src/canonicalCropReview.d.ts

@@ -0,0 +1,66 @@
+export type UploadReviewTargetLike<TAsset> = Readonly<{
+    status: string;
+    asset?: TAsset | null;
+}>;
+export type CanonicalCropTarget<TAsset, TUpload> = Readonly<{
+    kind: 'upload';
+    upload: TUpload;
+    asset: TAsset;
+}> | Readonly<{
+    kind: 'asset';
+    asset: TAsset;
+}>;
+type CanonicalCropDialogState<TAsset, TUpload> = Readonly<{
+    kind: 'closed';
+}> | Readonly<{
+    kind: 'editing';
+    target: CanonicalCropTarget<TAsset, TUpload>;
+}> | Readonly<{
+    kind: 'saving';
+    target: CanonicalCropTarget<TAsset, TUpload>;
+}> | Readonly<{
+    kind: 'error';
+    target: CanonicalCropTarget<TAsset, TUpload>;
+    message: string;
+}>;
+export type CanonicalCropReviewState<TAsset, TUpload> = Readonly<{
+    reviewingIds: ReadonlySet<string>;
+    dialog: CanonicalCropDialogState<TAsset, TUpload>;
+}>;
+export type CanonicalCropDialogView<TAsset, TUpload> = Readonly<{
+    kind: 'closed';
+    asset: null;
+    error: null;
+    saving: false;
+    target: null;
+}> | Readonly<{
+    kind: 'open';
+    asset: TAsset;
+    error: string | null;
+    saving: boolean;
+    target: CanonicalCropTarget<TAsset, TUpload>;
+}>;
+export type CanonicalCropReviewAction<TAsset, TUpload> = Readonly<{
+    type: 'mark-reviewing';
+    uploadId: string;
+    reviewing: boolean;
+}> | Readonly<{
+    type: 'open-crop';
+    target: CanonicalCropTarget<TAsset, TUpload>;
+}> | Readonly<{
+    type: 'close-crop';
+}> | Readonly<{
+    type: 'submit-crop';
+}> | Readonly<{
+    type: 'crop-failed';
+    message: string;
+}> | Readonly<{
+    type: 'crop-completed';
+}>;
+export declare function createInitialCanonicalCropReviewState<TAsset, TUpload>(): CanonicalCropReviewState<TAsset, TUpload>;
+export declare function isReviewReady<TAsset, TUpload extends UploadReviewTargetLike<TAsset>>(upload: TUpload): upload is TUpload & {
+    asset: TAsset;
+};
+export declare function canonicalCropReviewReducer<TAsset, TUpload>(state: CanonicalCropReviewState<TAsset, TUpload>, action: CanonicalCropReviewAction<TAsset, TUpload>): CanonicalCropReviewState<TAsset, TUpload>;
+export declare function getCanonicalCropDialogView<TAsset, TUpload>(state: CanonicalCropReviewState<TAsset, TUpload>): CanonicalCropDialogView<TAsset, TUpload>;
+export {};

package/dist/_dts/media-core/src/classifyAllPlanning.d.ts

@@ -0,0 +1,48 @@
+export type MediaClassifyJobStatus = 'pending' | 'processing' | 'completed' | 'failed';
+export type ClassifySummary = Readonly<{
+    processed: number;
+    skipped: number;
+    failures: number;
+}>;
+export declare const EMPTY_CLASSIFY_SUMMARY: ClassifySummary;
+export type ClassifyJobState = Readonly<{
+    id: string;
+    status: MediaClassifyJobStatus;
+    summary: ClassifySummary;
+    completed: boolean;
+}>;
+export type ClassifyRunJobLike = Readonly<{
+    id: string;
+    status: MediaClassifyJobStatus;
+}>;
+export type ClassifyRunPayloadLike = Readonly<{
+    job?: ClassifyRunJobLike | null;
+    summary?: ClassifySummary | null;
+    completed?: boolean;
+}>;
+export type ClassifyWorkflowResult = Readonly<{
+    kind: 'nothingToClassify';
+    reason: string;
+}> | Readonly<{
+    kind: 'completed';
+    summary: ClassifySummary;
+    job: ClassifyJobState;
+}>;
+export type ClassifyCompletionToast = Readonly<{
+    kind: 'none';
+}> | Readonly<{
+    kind: 'success';
+    message: string;
+}> | Readonly<{
+    kind: 'warning';
+    message: string;
+}> | Readonly<{
+    kind: 'info';
+    message: string;
+}>;
+export declare function normalizeClassifySummary(summary: ClassifySummary | null | undefined): ClassifySummary;
+export declare function createCompletedClassifyResult(input: {
+    fallbackJobId: string;
+    runPayload: ClassifyRunPayloadLike;
+}): ClassifyWorkflowResult;
+export declare function planClassifyCompletionToast(result: ClassifyWorkflowResult): ClassifyCompletionToast;

package/dist/_dts/media-core/src/filename.d.ts

@@ -0,0 +1 @@
+export declare function filenameExtension(filename: string): string | null;

package/dist/_dts/media-core/src/index.d.ts

@@ -14,7 +14,16 @@ export * from './fileDownloadResolution';
 export * from './fileAssetDeletion';
 export * from './fileAssetCompatibility';
 export * from './fileMimeDetection';
+export * from './filename';
+export * from './uploadVerificationContract';
 export * from './videoPrep';
+export * from './videoAssetRepair';
+export * from './canonicalCropReview';
+export * from './mediaAssetUsageStatus';
+export * from './assetsInUseSummary';
+export * from './bulkDeletePlanning';
+export * from './classifyAllPlanning';
+export * from './mediaSettingsState';
 export * from './videoSlotPolicy';
 export * from './identifiers';
 export { getImageUrl, getDirectImageUrl, getDirectImageUrlForRelativePath, getDirectImageUrlForSiteScopedPath, getDirectImageUrlForBucketPath, getDirectImageUrlForStoragePath, getDirectImageUrlForMediaAsset, isRelativeDirectImageStoragePath, isSiteScopedDirectImageStoragePath, type DirectImageMediaAsset, type DirectImageUrlOptions, type DirectImageUrlPathTarget, type ImageProxyFit, type ImageProxyParams, } from './url';
@@ -32,3 +41,4 @@ export * from './mediaWriteNormalizer';
 export { walkAndCollectImageAttrs, pickFilenameFromUrl, type RichTextImageAttrsRef, } from './richTextImageCollector';
 export * from './richTextImageWriteNormalizer';
 export * from './mediaUsageProjection';
+export * from './portableMediaReferences';

package/dist/_dts/media-core/src/mediaAssetUsageStatus.d.ts

@@ -0,0 +1,47 @@
+export type UsageCheckedAssetLike = Readonly<{
+    id: string;
+    mimeType: string;
+}>;
+export type MediaUsageCheckItemLike = Readonly<{
+    assetId: string;
+    usedCount: number;
+}>;
+export type MediaUsageCheckResponseLike = Readonly<{
+    items: readonly MediaUsageCheckItemLike[];
+}>;
+export type StoredAssetUsageStatus = Readonly<{
+    kind: 'unknown';
+}> | Readonly<{
+    kind: 'checking';
+}> | Readonly<{
+    kind: 'eligible';
+    usedCount: 0;
+}> | Readonly<{
+    kind: 'ineligible';
+    usedCount: number;
+}> | Readonly<{
+    kind: 'notApplicable';
+}> | Readonly<{
+    kind: 'failed';
+    message: string;
+}>;
+export type StoredAssetUsageStatusByAssetId = Readonly<Record<string, StoredAssetUsageStatus>>;
+export declare function getRasterAssetIds(assets: readonly UsageCheckedAssetLike[]): readonly string[];
+export declare function getMissingAssetUsageIds(input: {
+    rasterAssetIds: readonly string[];
+    storedStatusByAssetId: StoredAssetUsageStatusByAssetId;
+    inFlightAssetIds: ReadonlySet<string>;
+}): readonly string[];
+export declare function markAssetUsageChecking(statusByAssetId: StoredAssetUsageStatusByAssetId, assetIds: readonly string[]): StoredAssetUsageStatusByAssetId;
+export declare function applyAssetUsageResponse(input: {
+    statusByAssetId: StoredAssetUsageStatusByAssetId;
+    requestedAssetIds: readonly string[];
+    response: MediaUsageCheckResponseLike;
+}): StoredAssetUsageStatusByAssetId;
+export declare function applyAssetUsageFailure(input: {
+    statusByAssetId: StoredAssetUsageStatusByAssetId;
+    requestedAssetIds: readonly string[];
+    message: string;
+}): StoredAssetUsageStatusByAssetId;
+export declare function removeInFlightAssetIds(inFlightAssetIds: ReadonlySet<string>, completedAssetIds: readonly string[]): ReadonlySet<string>;
+export declare function getStoredAssetUsageStatusForAsset(asset: UsageCheckedAssetLike, statusByAssetId: StoredAssetUsageStatusByAssetId): StoredAssetUsageStatus;

package/dist/_dts/media-core/src/mediaSettingsState.d.ts

@@ -0,0 +1,3 @@
+export declare function readPersistVariantsEnabled(settings: Readonly<{
+    persistVariants: boolean | null | undefined;
+}>): boolean;

package/dist/_dts/media-core/src/portableMediaReferences.d.ts

@@ -0,0 +1,38 @@
+type PortableMediaReferenceSource = 'media-field' | 'rich-text-image';
+export type PortableMediaReference = Readonly<{
+    kind: 'assetId';
+    assetId: string;
+    location: string;
+    source: PortableMediaReferenceSource;
+} | {
+    kind: 'identifier';
+    identifier: string;
+    location: string;
+    source: PortableMediaReferenceSource;
+}>;
+export type PortableMediaReferenceSummary = Readonly<{
+    references: PortableMediaReference[];
+    assetIds: string[];
+    identifiers: string[];
+}>;
+type PortableMediaLookupAsset = Readonly<{
+    id: string;
+    identifier?: string | null;
+}>;
+type PortableMediaLookup<TAsset extends PortableMediaLookupAsset> = Readonly<{
+    byId: Map<string, TAsset>;
+    byIdentifier: Map<string, TAsset>;
+}>;
+export type PortableMediaResolution<TAsset extends PortableMediaLookupAsset> = Readonly<{
+    kind: 'resolved';
+    reference: PortableMediaReference;
+    asset: TAsset;
+} | {
+    kind: 'missing';
+    reference: PortableMediaReference;
+}>;
+export declare function summarizePortableMediaReferences(references: readonly PortableMediaReference[]): PortableMediaReferenceSummary;
+export declare function collectPortableMediaReferencesFromContent(content: unknown): PortableMediaReferenceSummary;
+export declare function buildPortableMediaLookup<TAsset extends PortableMediaLookupAsset>(assets: readonly TAsset[]): PortableMediaLookup<TAsset>;
+export declare function resolvePortableMediaReferences<TAsset extends PortableMediaLookupAsset>(references: readonly PortableMediaReference[], lookup: PortableMediaLookup<TAsset>): PortableMediaResolution<TAsset>[];
+export {};

package/dist/_dts/media-core/src/uploadVerificationContract.d.ts

@@ -0,0 +1,28 @@
+import { type FileKind, type UploadIntent } from './fileDomain';
+/**
+ * Shared upload boundary contract derived from the caller-provided filename and
+ * declared MIME type. Accept surfaces, session creation, and finalization
+ * should all consult this module so file-kind acceptance and verification
+ * cannot drift apart.
+ */
+export type UploadCandidateDescriptor = Readonly<{
+    name: string;
+    type?: string | null;
+}>;
+export type UploadVerificationStrategy = Readonly<{
+    tag: 'magic-only';
+}> | Readonly<{
+    tag: 'text-fallback';
+    detectedMimeType: 'text/plain' | 'text/csv';
+}> | Readonly<{
+    tag: 'rtf-fallback';
+    detectedMimeType: 'application/rtf';
+}>;
+export type AcceptedUploadKindContract = Readonly<{
+    kind: FileKind;
+    verification: UploadVerificationStrategy;
+}>;
+export declare const PRODUCT_FILE_EXTENSION_TAGS: readonly ["pdf", "docx", "txt", "rtf", "csv", "zip", "mp3", "m4a", "wav", "ogg", "flac", "webm", "mp4", "mov"];
+export declare function resolveAcceptedUploadKindContract(candidate: UploadCandidateDescriptor): AcceptedUploadKindContract | undefined;
+export declare function isUploadKindCompatibleWithIntent(intent: UploadIntent, kind: FileKind): boolean;
+export declare function resolveVerifiedMimeTypeFromContract(buffer: Uint8Array | null, contract: AcceptedUploadKindContract | undefined): string | undefined;

package/dist/_dts/media-core/src/videoAssetRepair.d.ts

@@ -0,0 +1,38 @@
+import type { MediaAssetId } from '../../core/src/index';
+export type VideoRepairAssetLike = Readonly<{
+    id: MediaAssetId;
+    filename: string;
+    siteId: string;
+    mimeType: string;
+    thumbnailAssetId?: string | null;
+    durationSeconds?: number | null;
+    width?: number | null;
+    height?: number | null;
+}>;
+export type VideoAssetRepairPlan = Readonly<{
+    tag: 'none';
+}> | Readonly<{
+    tag: 'repair-metadata';
+    assetId: MediaAssetId;
+    filename: string;
+    siteId: string;
+    processingLabel: 'Reading video metadata';
+    processingText: 'Reading video metadata...';
+}> | Readonly<{
+    tag: 'repair-thumbnail-and-metadata';
+    assetId: MediaAssetId;
+    filename: string;
+    siteId: string;
+    processingLabel: 'Generating thumbnail';
+    processingText: 'Generating thumbnail...';
+}>;
+export type RunnableVideoAssetRepairPlan = Exclude<VideoAssetRepairPlan, {
+    tag: 'none';
+}>;
+export type VideoAssetRepairQueueState = Readonly<{
+    isProcessing: boolean;
+    isCompleted: boolean;
+    isFailed: boolean;
+}>;
+export declare function planVideoAssetRepair(asset: VideoRepairAssetLike): VideoAssetRepairPlan;
+export declare function shouldQueueVideoAssetRepair(plan: VideoAssetRepairPlan, queueState: VideoAssetRepairQueueState): plan is RunnableVideoAssetRepairPlan;

package/dist/_dts/media-editor/src/mediaEditorDebug.d.ts

@@ -0,0 +1 @@
+export declare function logMediaEditorDebug(event: string, payload: Record<string, unknown>): void;

package/dist/_dts/path-utils/src/index.d.ts

@@ -0,0 +1,8 @@
+export type PathSegment = string | number;
+export declare function parsePath(path: string | Array<PathSegment>): Array<PathSegment>;
+export declare function segmentsToPath(segments: Array<PathSegment>): string | undefined;
+export declare function getAtPath<T = unknown>(source: unknown, path: string | Array<PathSegment>): T | undefined;
+export declare function setAtPath(target: Record<string, unknown> | Array<unknown>, path: string | Array<PathSegment>, value: unknown): void;
+export declare function toAbsolutePath(base: string | undefined | null, path: string): string;
+export * from './redirectPaths';
+export * from './safeAppPath';

package/dist/_dts/path-utils/src/redirectPaths.d.ts

@@ -0,0 +1,26 @@
+export type RedirectPathParseError = {
+    tag: 'MISSING';
+} | {
+    tag: 'EMPTY';
+} | {
+    tag: 'CONTROL_CHAR';
+} | {
+    tag: 'BACKSLASH';
+} | {
+    tag: 'EXTERNAL_URL';
+} | {
+    tag: 'INVALID_PATH';
+} | {
+    tag: 'ENCODED_SEPARATOR';
+};
+export type RedirectPathParseResult = {
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    error: RedirectPathParseError;
+};
+export declare function parseInternalRedirectPath(value: unknown): RedirectPathParseResult;
+export declare function sanitizeInternalRedirectPath(value: unknown): string | null;
+export declare function parseSameOriginRedirectPath(value: unknown, baseUrl: string | URL): RedirectPathParseResult;
+export declare function sanitizeSameOriginRedirectPath(value: unknown, baseUrl: string | URL): string | null;

package/dist/_dts/path-utils/src/safeAppPath.d.ts

@@ -0,0 +1,26 @@
+import { type RedirectPathParseError } from './redirectPaths';
+declare const __brand: unique symbol;
+type Brand<T, B extends string> = T & {
+    readonly [__brand]: B;
+};
+/**
+ * A redirect path that has been validated as a safe, same-origin relative path.
+ *
+ * Parse once at the boundary, then carry the branded value inward instead of
+ * re-validating ad hoc string inputs in every auth flow.
+ */
+export type SafeAppPath = Brand<string, 'SafeAppPath'>;
+export type SafeAppPathParseError = RedirectPathParseError;
+export type SafeAppPathParseResult = {
+    ok: true;
+    value: SafeAppPath;
+} | {
+    ok: false;
+    error: SafeAppPathParseError;
+};
+export declare function parseSafeAppPath(value: unknown): SafeAppPathParseResult;
+export declare function sanitizeSafeAppPath(value: unknown): SafeAppPath | null;
+export declare function assertSafeAppPath(value: string): SafeAppPath;
+export declare function safeAppPathOrFallback(value: unknown, fallback: SafeAppPath): SafeAppPath;
+export declare function buildSafeRedirectUrl(path: SafeAppPath, baseUrl: string | URL): URL;
+export {};

package/dist/_dts/preview-next/src/client/preview/SiteChromeCustomizeButton.d.ts

@@ -1,4 +1,5 @@
 import type { SiteChromeEditableSurfaceKind } from './SiteChromeEditableSurface';
-export declare function SiteChromeCustomizeButton({ surface, }: {
+export declare function SiteChromeCustomizeButton({ surface, containerClassName, }: {
     surface: SiteChromeEditableSurfaceKind;
+    containerClassName?: string;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/_dts/preview-next/src/client/preview/SiteChromeCustomizeContext.d.ts

@@ -13,6 +13,9 @@ type SiteChromeCustomizeSurfaceState = Readonly<{
     kind: 'available';
     surface: 'header';
     label: string;
+    currentLayoutId: HeaderLayoutId;
+    currentLayoutLabel: string;
+    layoutOptions: readonly SiteChromeLookOption<HeaderLayoutId>[];
     currentId: HeaderStyleId;
     currentLabel: string;
     options: readonly SiteChromeLookOption<HeaderStyleId>[];
@@ -35,6 +38,7 @@ type SiteChromeCustomizeSurfaceState = Readonly<{
 type SiteChromeCustomizeContextValue = Readonly<{
     getSurfaceState: (surface: SiteChromeEditableSurfaceKind) => SiteChromeCustomizeSurfaceState;
     cycleSurfaceLook: (surface: SiteChromeEditableSurfaceKind, direction: 'prev' | 'next') => void;
+    cycleSurfaceLayout: (surface: SiteChromeEditableSurfaceKind, direction: 'prev' | 'next') => void;
 }>;
 export type SiteChromeCustomizeProviderProps = Readonly<{
     children: ReactNode;

package/dist/_dts/preview-next/src/client/preview/previewDocumentFrame.d.ts

@@ -0,0 +1,31 @@
+import type { CSSProperties } from "react";
+import type { ViewportMode, ViewportWidth } from "./PreviewViewportControls";
+type ZoomableStyle = CSSProperties & Readonly<{
+    zoom?: number;
+}>;
+export type PreviewDocumentFramePlan = Readonly<{
+    kind: "squeeze";
+    frameClassName: string;
+    frameDataProps: PreviewDocumentFrameDataProps;
+}> | Readonly<{
+    kind: "fixed";
+    targetWidthPx: number;
+    wrapperStyle: CSSProperties;
+    contentStyle: ZoomableStyle;
+    siteDocumentStyle: CSSProperties;
+    frameClassName: string;
+    frameDataProps: PreviewDocumentFrameDataProps;
+}>;
+export type PreviewDocumentFrameDataProps = Readonly<{
+    "data-builder-preview-document-frame": "squeeze" | "fixed";
+    "data-builder-preview-document-scale": "none" | "scaled";
+    "data-builder-preview-fixed-header-behavior"?: "fixed-as-sticky";
+}>;
+export type PreviewDocumentFrameInput = Readonly<{
+    viewportMode: ViewportMode;
+    viewportWidth: ViewportWidth;
+    scale: number;
+    contentHeight: number;
+}>;
+export declare function planPreviewDocumentFrame(input: PreviewDocumentFrameInput): PreviewDocumentFramePlan;
+export {};

package/dist/_dts/sdk/src/client/error.d.ts

@@ -5,6 +5,7 @@
  * Provides typed access to error details including code, message, request ID, and field errors.
  */
 import type { ApiError, ApiErrorCode, FieldError } from '../public-api/contracts';
+import type { ResilienceStatus } from './types';
 /**
  * Error options for creating RiverbankApiError
  */
@@ -147,3 +148,5 @@ export declare class RiverbankApiError extends Error {
      */
     toDetailedString(): string;
 }
+export declare function attachResilienceStatusToError(error: unknown, resilienceStatus: ResilienceStatus): unknown;
+export declare function getResilienceStatusFromError(error: unknown): ResilienceStatus | undefined;

package/dist/_dts/sdk/src/client/index.d.ts

@@ -13,6 +13,6 @@ import type { RiverbankClient, RiverbankClientConfig } from './types';
  * ```
  */
 export declare function createRiverbankClient(config: RiverbankClientConfig): RiverbankClient;
-export type { RiverbankClient, RiverbankClientConfig, ResilienceConfig, ResilienceStatus, ApiKeyType, SdkAuthConfig } from './types';
-export { RiverbankApiError } from './error';
+export type { ApiKeyType, GetPageParams, GetSiteParams, ResilienceConfig, ResilienceStatus, ResilientData, RiverbankClient, RiverbankClientConfig, SdkAuthConfig, } from './types';
+export { getResilienceStatusFromError, RiverbankApiError } from './error';
 export { CircuitOpenError } from './resilience';

package/dist/_dts/sdk/src/client/types.d.ts

@@ -30,6 +30,24 @@ export interface SdkMethodOptions {
     /** AbortSignal for cancelling the request */
     signal?: AbortSignal;
 }
+export type GetSiteParams = {
+    slug?: string;
+    domain?: string;
+    id?: string;
+    /**
+     * Bypass SDK in-memory cache and Next.js fetch caching (uses `cache: 'no-store'`).
+     *
+     * Useful right after `riverbankcms push-config` in development to avoid waiting
+     * for cache revalidation.
+     */
+    force?: boolean;
+    currentPath?: string;
+} & SdkMethodOptions;
+export type GetPageParams = {
+    siteId: string;
+    path: string;
+    preview?: boolean;
+} & SdkMethodOptions;
 /**
  * Base parameters for getEntries - shared across all overloads
  */
@@ -69,6 +87,7 @@ export interface ResilienceStatus {
     error?: {
         code?: string;
         message: string;
+        status?: number;
     };
     /** Seconds since cache TTL expired (when source='stale') */
     staleAgeSec?: number;
@@ -81,6 +100,13 @@ export interface ResilienceStatus {
     /** Total request duration including retries (ms) */
     durationMs?: number;
 }
+/**
+ * Data returned with the resilience status for the exact request that produced it.
+ */
+export type ResilientData<T> = Readonly<{
+    data: T;
+    resilience: ResilienceStatus;
+}>;
 /**
  * Circuit breaker state information
  */
@@ -201,7 +227,7 @@ export type SdkAuthConfig = {
     token: string;
 };
 export declare const SDK_CORRELATION_HEADER_NAMES: readonly ["x-request-id", "x-correlation-id", "x-riverbank-monitor-run-id"];
-export type SdkCorrelationHeaderName = typeof SDK_CORRELATION_HEADER_NAMES[number];
+export type SdkCorrelationHeaderName = (typeof SDK_CORRELATION_HEADER_NAMES)[number];
 export type SdkCorrelationHeaders = Readonly<Partial<Record<SdkCorrelationHeaderName, string>>>;
 /**
  * Configuration for creating a Riverbank CMS client
@@ -276,29 +302,21 @@ export interface RiverbankClient {
     /**
      * Fetch site data by slug, domain, or ID
      */
-    getSite(params: {
-        slug?: string;
-        domain?: string;
-        id?: string;
-        /**
-         * Bypass SDK in-memory cache and Next.js fetch caching (uses `cache: 'no-store'`).
-         *
-         * Useful right after `riverbankcms push-config` in development to avoid waiting
-         * for cache revalidation.
-         */
-        force?: boolean;
-        currentPath?: string;
-    } & SdkMethodOptions): Promise<SiteResponse>;
+    getSite(params: GetSiteParams): Promise<SiteResponse>;
+    /**
+     * Fetch site data and return the resilience status for this exact request.
+     */
+    getSiteWithResilience(params: GetSiteParams): Promise<ResilientData<SiteResponse>>;
     /**
      * Fetch a specific page by path
      *
      * @param params.preview - If true, returns draft content instead of published content (requires API key with site access)
      */
-    getPage(params: {
-        siteId: string;
-        path: string;
-        preview?: boolean;
-    } & SdkMethodOptions): Promise<PageResponse>;
+    getPage(params: GetPageParams): Promise<PageResponse>;
+    /**
+     * Fetch page content and return the resilience status for this exact request.
+     */
+    getPageWithResilience(params: GetPageParams): Promise<ResilientData<PageResponse>>;
     /**
      * Fetch published content entries with optional pagination, sorting, and preview mode
      *

package/dist/_dts/sdk/src/index.d.ts

@@ -17,9 +17,9 @@
  *
  * @packageDocumentation
  */
-export { createRiverbankClient, RiverbankApiError } from './client/index';
+export { createRiverbankClient, getResilienceStatusFromError, RiverbankApiError, } from './client/index';
 export { SDK_CORRELATION_HEADER_NAMES } from './client/types';
-export type { RiverbankClient, RiverbankClientConfig, SdkCorrelationHeaderName, SdkCorrelationHeaders, SdkAuthConfig, SiteResponse, PageResponse, EntriesResponse, EntriesResponseWithMeta, PaginationMeta, EntryResponse, ResilienceConfig, ResilienceStatus, ResilienceSource, CircuitState, RetryConfig, CircuitBreakerConfig, } from './client/types';
+export type { RiverbankClient, RiverbankClientConfig, SdkCorrelationHeaderName, SdkCorrelationHeaders, SdkAuthConfig, SiteResponse, PageResponse, EntriesResponse, EntriesResponseWithMeta, GetPageParams, GetSiteParams, PaginationMeta, EntryResponse, ResilienceConfig, ResilienceStatus, ResilientData, ResilienceSource, CircuitState, RetryConfig, CircuitBreakerConfig, } from './client/types';
 export { prebuildCache } from './prebuild/index';
 export type { PrebuildOptions, PrebuildResult, PrebuildProgress, PrebuildManifest, PrebuildContentType, } from './prebuild/types';
 export { PrebuildLoader, createPrebuildLoader, canUsePrebuild, } from './prebuild/loader';