@riverbankcms/sdk 0.82.0 → 0.84.1

package/dist/_dts/content-model/src/entry-slots/types.d.ts

@@ -0,0 +1,356 @@
+import type { TemplateBlockDefinition, TemplateDefinition } from '../templates/types';
+declare const __entrySlotBrand: unique symbol;
+type Brand<TValue, TBrand extends string> = TValue & {
+    readonly [__entrySlotBrand]: TBrand;
+};
+export type SlotKey = Brand<string, 'SlotKey'>;
+export type EntryBlockSlotId = Brand<string, 'EntryBlockSlotId'>;
+export type EntrySlotContentEntryId = Brand<string, 'EntrySlotContentEntryId'>;
+export type EntrySlotPageId = Brand<string, 'EntrySlotPageId'>;
+export type EntrySlotBlockId = Brand<string, 'EntrySlotBlockId'>;
+export type EntrySlotContentVersionId = Brand<string, 'EntrySlotContentVersionId'>;
+export type EntrySlotBlockOrderIndex = Brand<number, 'EntrySlotBlockOrderIndex'>;
+export type EntrySlotResult<TValue, TError> = Readonly<{
+    ok: true;
+    value: TValue;
+}> | Readonly<{
+    ok: false;
+    error: TError;
+}>;
+export type SlotKeyParseError = Readonly<{
+    kind: 'not-string';
+}> | Readonly<{
+    kind: 'empty';
+}> | Readonly<{
+    kind: 'invalid-format';
+    value: string;
+}>;
+export type BrandedUuidParseError = Readonly<{
+    kind: 'not-string';
+}> | Readonly<{
+    kind: 'empty';
+}> | Readonly<{
+    kind: 'invalid-uuid';
+    value: string;
+}>;
+export type NonEmptyStringParseError = Readonly<{
+    kind: 'not-string';
+}> | Readonly<{
+    kind: 'empty';
+}>;
+export declare function unsafeAsSlotKey(value: string): SlotKey;
+export declare function unsafeAsEntryBlockSlotId(value: string): EntryBlockSlotId;
+export declare function unsafeAsEntrySlotContentEntryId(value: string): EntrySlotContentEntryId;
+export declare function unsafeAsEntrySlotPageId(value: string): EntrySlotPageId;
+export declare function unsafeAsEntrySlotBlockId(value: string): EntrySlotBlockId;
+export declare function unsafeAsEntrySlotContentVersionId(value: string): EntrySlotContentVersionId;
+export declare function unsafeAsEntrySlotBlockOrderIndex(value: number): EntrySlotBlockOrderIndex;
+export declare function parseSlotKey(value: unknown): EntrySlotResult<SlotKey, SlotKeyParseError>;
+export declare function parseEntryBlockSlotId(value: unknown): EntrySlotResult<EntryBlockSlotId, BrandedUuidParseError>;
+export declare const SYSTEM_ENTRY_SLOT_BLOCK_KIND: "system.entry-slot";
+export declare const DEFAULT_ENTRY_SLOT_ALLOWED_BLOCKS: readonly ["block.body-text", "block.rich-text", "block.image-gallery", "block.cta-full"];
+export type DefaultEntrySlotBlockKind = (typeof DEFAULT_ENTRY_SLOT_ALLOWED_BLOCKS)[number];
+export type EntrySlotAllowedBlocks = Readonly<{
+    kind: 'default';
+    blockKinds: readonly DefaultEntrySlotBlockKind[];
+}> | Readonly<{
+    kind: 'restricted';
+    blockKinds: readonly string[];
+}> | Readonly<{
+    kind: 'none';
+    blockKinds: readonly [];
+}>;
+export type EntrySlotDefinition = Readonly<{
+    slotKey: SlotKey;
+    label: string;
+    allowedBlocks: EntrySlotAllowedBlocks;
+}>;
+export type EntrySlotDefinitionParseError = Readonly<{
+    kind: 'invalid-slot-scope';
+    blockIndex: number;
+    scope: TemplateBlockDefinition['scope'];
+}> | Readonly<{
+    kind: 'invalid-slot-content';
+    blockIndex: number;
+}> | Readonly<{
+    kind: 'invalid-slot-key';
+    blockIndex: number;
+    error: SlotKeyParseError;
+}> | Readonly<{
+    kind: 'missing-label';
+    blockIndex: number;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'invalid-allowed-blocks';
+    blockIndex: number;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'invalid-allowed-block-kind';
+    blockIndex: number;
+    slotKey: SlotKey;
+    value: unknown;
+}> | Readonly<{
+    kind: 'template-only-block-kind';
+    blockIndex: number;
+    slotKey: SlotKey;
+    blockKind: string;
+}> | Readonly<{
+    kind: 'duplicate-allowed-block-kind';
+    blockIndex: number;
+    slotKey: SlotKey;
+    blockKind: string;
+}> | Readonly<{
+    kind: 'duplicate-slot-key';
+    slotKey: SlotKey;
+    firstBlockIndex: number;
+    blockIndex: number;
+}>;
+export declare function parseEntrySlotDefinitions(template: Pick<TemplateDefinition, 'blocks'>): EntrySlotResult<readonly EntrySlotDefinition[], EntrySlotDefinitionParseError>;
+export declare function isEntrySlotTemplateBlock(block: TemplateBlockDefinition): block is TemplateBlockDefinition & Readonly<{
+    blockKind: typeof SYSTEM_ENTRY_SLOT_BLOCK_KIND;
+}>;
+export type EntrySlotBlockKindValidationError = Readonly<{
+    kind: 'template-only-block-kind';
+    blockKind: string;
+}> | Readonly<{
+    kind: 'block-kind-not-allowed';
+    blockKind: string;
+    slotKey: SlotKey;
+}>;
+export declare function validateBlockKindForEntrySlot(definition: EntrySlotDefinition, blockKind: string): EntrySlotResult<string, EntrySlotBlockKindValidationError>;
+export type StoredEntrySlotSummary = Readonly<{
+    entrySlotId: EntryBlockSlotId;
+    slotKey: SlotKey;
+    draftCompositionVersionId: EntrySlotContentVersionId | null;
+    publishedCompositionVersionId: EntrySlotContentVersionId | null;
+}>;
+export type DefinedEntrySlot = Readonly<{
+    kind: 'defined';
+    definition: EntrySlotDefinition;
+    entrySlot: StoredEntrySlotSummary | null;
+}>;
+export type OrphanedEntrySlot = Readonly<{
+    kind: 'orphaned';
+    slotKey: SlotKey;
+    entrySlot: StoredEntrySlotSummary;
+}>;
+export type VisibleEntrySlot = DefinedEntrySlot | OrphanedEntrySlot;
+export type EntryPageCompositionState = Readonly<{
+    kind: 'absent';
+}> | Readonly<{
+    kind: 'draft-only';
+    draftCompositionVersionId: EntrySlotContentVersionId;
+}> | Readonly<{
+    kind: 'published-only';
+    publishedCompositionVersionId: EntrySlotContentVersionId;
+}> | Readonly<{
+    kind: 'draft-and-published';
+    draftCompositionVersionId: EntrySlotContentVersionId;
+    publishedCompositionVersionId: EntrySlotContentVersionId;
+}> | Readonly<{
+    kind: 'invalid';
+    reason: 'orphaned-slot' | 'missing-slot-definition';
+}>;
+export declare function resolveEntrySlotVisibility(input: {
+    definitions: readonly EntrySlotDefinition[];
+    storedSlots: readonly StoredEntrySlotSummary[];
+}): readonly VisibleEntrySlot[];
+export declare function resolveEntryPageCompositionState(slot: VisibleEntrySlot): EntryPageCompositionState;
+export type EntrySlotBlockSource<TBlock> = Readonly<{
+    slotKey: SlotKey | string;
+    blocks: readonly TBlock[];
+}>;
+export declare function selectBlocksForDeclaredEntrySlot<TBlock>(input: {
+    declaredSlotKey: SlotKey;
+    entrySlots: readonly EntrySlotBlockSource<TBlock>[];
+}): readonly TBlock[];
+export type MissingEntrySlotBlockContentReason = 'new-block' | 'deleted-content-version' | 'unpublished-block';
+export type PublishedEntrySlotBlockSnapshot = Readonly<{
+    kind: 'published-block-content';
+    blockId: EntrySlotBlockId;
+    contentVersionId: EntrySlotContentVersionId;
+    identifier: string | null;
+    blockKind: string;
+    purpose: string;
+    orderIndex: EntrySlotBlockOrderIndex;
+}>;
+export type DraftEntrySlotBlockSnapshot = Readonly<{
+    kind: 'draft-block-content';
+    blockId: EntrySlotBlockId;
+    contentVersionId: EntrySlotContentVersionId | null;
+    identifier: string | null;
+    blockKind: string;
+    purpose: string;
+    orderIndex: EntrySlotBlockOrderIndex;
+}>;
+export type MissingEntrySlotBlockSnapshot = Readonly<{
+    kind: 'missing-block-content';
+    blockId: EntrySlotBlockId;
+    identifier: string | null;
+    blockKind: string;
+    purpose: string;
+    orderIndex: EntrySlotBlockOrderIndex;
+    reason: MissingEntrySlotBlockContentReason;
+}>;
+export type EntrySlotBlockSnapshot = PublishedEntrySlotBlockSnapshot | DraftEntrySlotBlockSnapshot | MissingEntrySlotBlockSnapshot;
+export type DraftEntrySlotCompositionVersionDataV1 = Readonly<{
+    schemaVersion: 1;
+    stage: 'draft';
+    entrySlotId: EntryBlockSlotId;
+    contentEntryId: EntrySlotContentEntryId;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}>;
+export type PublishedEntrySlotCompositionVersionDataV1 = Readonly<{
+    schemaVersion: 1;
+    stage: 'published';
+    entrySlotId: EntryBlockSlotId;
+    contentEntryId: EntrySlotContentEntryId;
+    slotKey: SlotKey;
+    blockSequence: readonly PublishedEntrySlotBlockSnapshot[];
+}>;
+export type EntrySlotCompositionVersionDataV1 = DraftEntrySlotCompositionVersionDataV1 | PublishedEntrySlotCompositionVersionDataV1;
+export type PublishedEntrySlotCompositionBuildError = Readonly<{
+    kind: 'published-composition-contains-unpublished-block';
+    blockId: EntrySlotBlockId;
+    snapshotKind: Exclude<EntrySlotBlockSnapshot['kind'], 'published-block-content'>;
+}>;
+export declare function buildDraftEntrySlotCompositionVersionData(input: {
+    entrySlotId: EntryBlockSlotId;
+    contentEntryId: EntrySlotContentEntryId;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}): DraftEntrySlotCompositionVersionDataV1;
+export declare function buildPublishedEntrySlotCompositionVersionData(input: {
+    entrySlotId: EntryBlockSlotId;
+    contentEntryId: EntrySlotContentEntryId;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}): EntrySlotResult<PublishedEntrySlotCompositionVersionDataV1, PublishedEntrySlotCompositionBuildError>;
+export type EntrySlotCompositionParseError = Readonly<{
+    kind: 'not-object';
+}> | Readonly<{
+    kind: 'unsupported-schema-version';
+    schemaVersion: unknown;
+}> | Readonly<{
+    kind: 'invalid-stage';
+    stage: unknown;
+}> | Readonly<{
+    kind: 'invalid-entry-slot-id';
+    error: BrandedUuidParseError | NonEmptyStringParseError;
+}> | Readonly<{
+    kind: 'invalid-content-entry-id';
+    error: NonEmptyStringParseError;
+}> | Readonly<{
+    kind: 'invalid-slot-key';
+    error: SlotKeyParseError;
+}> | Readonly<{
+    kind: 'invalid-block-sequence';
+}> | Readonly<{
+    kind: 'invalid-block-snapshot';
+    index: number;
+}> | Readonly<{
+    kind: 'published-composition-contains-unpublished-block';
+    index: number;
+}>;
+export declare function parseEntrySlotCompositionVersionData(input: unknown): EntrySlotResult<EntrySlotCompositionVersionDataV1, EntrySlotCompositionParseError>;
+export declare function blockContentVersionIdsForEntrySlotCompositionVersionData(versionData: EntrySlotCompositionVersionDataV1): readonly EntrySlotContentVersionId[];
+export type SlotPublishPlan = Readonly<{
+    kind: 'publishable';
+    slotKey: SlotKey;
+    needsBlockContentPublish: boolean;
+}> | Readonly<{
+    kind: 'blocked';
+    slotKey: SlotKey;
+    reason: 'missing-block-content';
+    blockIds: readonly EntrySlotBlockId[];
+}> | Readonly<{
+    kind: 'warning-only';
+    slotKey: SlotKey;
+    warning: 'orphaned-slot-hidden';
+}>;
+export declare function planEntrySlotPublish(input: {
+    slot: VisibleEntrySlot;
+    draftBlockSequence: readonly EntrySlotBlockSnapshot[];
+}): SlotPublishPlan;
+export type SlotDiscardPlan = Readonly<{
+    kind: 'discardable';
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'skip-hidden-orphan';
+    slotKey: SlotKey;
+}>;
+export declare function planEntrySlotDiscard(slot: VisibleEntrySlot): SlotDiscardPlan;
+export type SdkEntryBlocksPatch = Readonly<{
+    kind: 'leave-unchanged';
+}> | Readonly<{
+    kind: 'patch-slots';
+    slots: readonly SdkEntrySlotBlocksPatch[];
+}>;
+export type SdkEntrySlotBlocksPatch = Readonly<{
+    kind: 'clear-slot';
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'replace-slot';
+    slotKey: SlotKey;
+    blocks: readonly SdkEntrySlotBlockInput[];
+}>;
+export type SdkEntrySlotBlockInput = Readonly<{
+    identifier: string | null;
+    kind: string;
+    content: Record<string, unknown>;
+}>;
+export type SdkEntryBlocksPatchParseError = Readonly<{
+    kind: 'invalid-blocks-object';
+}> | Readonly<{
+    kind: 'invalid-slot-key';
+    key: string;
+    error: SlotKeyParseError;
+}> | Readonly<{
+    kind: 'invalid-slot-blocks';
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'invalid-block';
+    slotKey: SlotKey;
+    blockIndex: number;
+}> | Readonly<{
+    kind: 'template-only-block-kind';
+    slotKey: SlotKey;
+    blockIndex: number;
+    blockKind: string;
+}>;
+export declare function parseSdkEntryBlocksPatch(blocks: unknown): EntrySlotResult<SdkEntryBlocksPatch, SdkEntryBlocksPatchParseError>;
+export type ContentVersionOwner = Readonly<{
+    kind: 'block';
+    blockId: EntrySlotBlockId;
+}> | Readonly<{
+    kind: 'entry';
+    contentEntryId: EntrySlotContentEntryId;
+}> | Readonly<{
+    kind: 'page';
+    pageId: EntrySlotPageId;
+}> | Readonly<{
+    kind: 'entry-slot';
+    entrySlotId: EntryBlockSlotId;
+}>;
+export type EditableBlockOwner = Readonly<{
+    kind: 'page';
+    pageId: EntrySlotPageId;
+}> | Readonly<{
+    kind: 'entry-slot';
+    entrySlotId: EntryBlockSlotId;
+}>;
+export type EntryLifecycleRecoveryCheckpoint = 'entry-fields' | 'route-metadata' | 'slot-composition' | 'block-published-refs' | 'cache-revalidation';
+export type EntryLifecycleCommitPlan = Readonly<{
+    kind: 'transactional-commit';
+}> | Readonly<{
+    kind: 'sequential-commit-with-recovery';
+    checkpoints: readonly EntryLifecycleRecoveryCheckpoint[];
+}>;
+export type EntrySlotTemplateLifecycleDecision = Readonly<{
+    publicTemplateDefinitions: 'effective-current';
+    previewTemplateDefinitions: 'draft-current';
+    removedSlotData: 'retained-hidden-until-slot-reintroduced';
+}>;
+export declare const ENTRY_SLOT_TEMPLATE_LIFECYCLE_DECISION: EntrySlotTemplateLifecycleDecision;
+export {};

package/dist/_dts/content-model/src/index.d.ts

@@ -19,3 +19,4 @@ export * from './templates/bindingValidation';
 export * from './templates/manifestAdapter';
 export * from './templates/auditBindings';
 export * from './templates/editorState';
+export * from './entry-slots';

package/dist/_dts/content-model/src/templates/defaults.d.ts

@@ -126,6 +126,13 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
             readonly blockKind: "block.body-text";
             readonly scope: "entry";
             readonly bindings: import("./types").TemplateBindingRecord;
+        }, {
+            readonly blockKind: "system.entry-slot";
+            readonly scope: "template";
+            readonly content: {
+                readonly slotKey: "main";
+                readonly label: "Page content";
+            };
         }, {
             readonly blockKind: "block.event-registration";
             readonly scope: "entry";

package/dist/_dts/db/src/generated/supabase/database.types.d.ts

@@ -1463,11 +1463,12 @@ export type Database = {
                     block_id: string | null;
                     created_at: string;
                     draft_content_id: string | null;
+                    entry_slot_id: string | null;
                     id: string;
                     identifier: string;
                     kind: string;
                     order_index: number;
-                    page_id: string;
+                    page_id: string | null;
                     published_content_id: string | null;
                     purpose: string;
                     site_id: string;
@@ -1478,11 +1479,12 @@ export type Database = {
                     block_id?: string | null;
                     created_at?: string;
                     draft_content_id?: string | null;
+                    entry_slot_id?: string | null;
                     id?: string;
                     identifier: string;
                     kind: string;
                     order_index?: number;
-                    page_id: string;
+                    page_id?: string | null;
                     published_content_id?: string | null;
                     purpose: string;
                     site_id: string;
@@ -1493,11 +1495,12 @@ export type Database = {
                     block_id?: string | null;
                     created_at?: string;
                     draft_content_id?: string | null;
+                    entry_slot_id?: string | null;
                     id?: string;
                     identifier?: string;
                     kind?: string;
                     order_index?: number;
-                    page_id?: string;
+                    page_id?: string | null;
                     published_content_id?: string | null;
                     purpose?: string;
                     site_id?: string;
@@ -1512,6 +1515,13 @@ export type Database = {
                         referencedRelation: "content_versions";
                         referencedColumns: ["id"];
                     },
+                    {
+                        foreignKeyName: "blocks_entry_slot_id_fkey";
+                        columns: ["entry_slot_id"];
+                        isOneToOne: false;
+                        referencedRelation: "entry_block_slots";
+                        referencedColumns: ["id"];
+                    },
                     {
                         foreignKeyName: "blocks_page_id_fkey";
                         columns: ["page_id"];
@@ -4519,6 +4529,7 @@ export type Database = {
                     deleted_at: string | null;
                     deleted_by: string | null;
                     design_state: Json | null;
+                    entry_slot_id: string | null;
                     id: string;
                     owner_kind: Database["public"]["Enums"]["content_owner_kind"];
                     page_id: string | null;
@@ -4536,6 +4547,7 @@ export type Database = {
                     deleted_at?: string | null;
                     deleted_by?: string | null;
                     design_state?: Json | null;
+                    entry_slot_id?: string | null;
                     id?: string;
                     owner_kind?: Database["public"]["Enums"]["content_owner_kind"];
                     page_id?: string | null;
@@ -4553,6 +4565,7 @@ export type Database = {
                     deleted_at?: string | null;
                     deleted_by?: string | null;
                     design_state?: Json | null;
+                    entry_slot_id?: string | null;
                     id?: string;
                     owner_kind?: Database["public"]["Enums"]["content_owner_kind"];
                     page_id?: string | null;
@@ -4584,6 +4597,13 @@ export type Database = {
                         referencedRelation: "content_entries";
                         referencedColumns: ["id"];
                     },
+                    {
+                        foreignKeyName: "content_versions_entry_slot_id_fkey";
+                        columns: ["entry_slot_id"];
+                        isOneToOne: false;
+                        referencedRelation: "entry_block_slots";
+                        referencedColumns: ["id"];
+                    },
                     {
                         foreignKeyName: "content_versions_page_id_fkey";
                         columns: ["page_id"];
@@ -6722,6 +6742,80 @@ export type Database = {
                     }
                 ];
             };
+            entry_block_slots: {
+                Row: {
+                    content_entry_id: string;
+                    created_at: string;
+                    created_by: string | null;
+                    deleted_at: string | null;
+                    deleted_by: string | null;
+                    draft_composition_version_id: string | null;
+                    id: string;
+                    published_composition_version_id: string | null;
+                    site_id: string;
+                    slot_key: string;
+                    updated_at: string;
+                    updated_by: string | null;
+                };
+                Insert: {
+                    content_entry_id: string;
+                    created_at?: string;
+                    created_by?: string | null;
+                    deleted_at?: string | null;
+                    deleted_by?: string | null;
+                    draft_composition_version_id?: string | null;
+                    id?: string;
+                    published_composition_version_id?: string | null;
+                    site_id: string;
+                    slot_key: string;
+                    updated_at?: string;
+                    updated_by?: string | null;
+                };
+                Update: {
+                    content_entry_id?: string;
+                    created_at?: string;
+                    created_by?: string | null;
+                    deleted_at?: string | null;
+                    deleted_by?: string | null;
+                    draft_composition_version_id?: string | null;
+                    id?: string;
+                    published_composition_version_id?: string | null;
+                    site_id?: string;
+                    slot_key?: string;
+                    updated_at?: string;
+                    updated_by?: string | null;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "entry_block_slots_content_entry_id_fkey";
+                        columns: ["content_entry_id"];
+                        isOneToOne: false;
+                        referencedRelation: "content_entries";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "entry_block_slots_draft_composition_version_id_fkey";
+                        columns: ["draft_composition_version_id"];
+                        isOneToOne: false;
+                        referencedRelation: "content_versions";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "entry_block_slots_published_composition_version_id_fkey";
+                        columns: ["published_composition_version_id"];
+                        isOneToOne: false;
+                        referencedRelation: "content_versions";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "entry_block_slots_site_id_fkey";
+                        columns: ["site_id"];
+                        isOneToOne: false;
+                        referencedRelation: "sites";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
             event_attendee_guests: {
                 Row: {
                     attendee_id: string;
@@ -15551,6 +15645,7 @@ export type Database = {
                     content_entry_id: string;
                     data: Json;
                     design_state: Json;
+                    entry_slot_id: string;
                     id: string;
                     owner_kind: Database["public"]["Enums"]["content_owner_kind"];
                     page_id: string;
@@ -16556,7 +16651,7 @@ export type Database = {
             billing_interval: "monthly" | "annual";
             cancellation_context_category: "customer_requested" | "schedule_conflict" | "duplicate_or_admin_error" | "non_payment" | "policy_or_eligibility" | "other" | "legacy_client_unspecified";
             content_entry_status: "draft" | "scheduled" | "published" | "archived";
-            content_owner_kind: "block" | "entry" | "page";
+            content_owner_kind: "block" | "entry" | "page" | "entry_slot";
             content_stage: "draft" | "published";
             gsc_property_type: "domain" | "url_prefix";
             impersonation_scope: "read" | "write";
@@ -17291,7 +17386,7 @@ export declare const Constants: {
             readonly billing_interval: readonly ["monthly", "annual"];
             readonly cancellation_context_category: readonly ["customer_requested", "schedule_conflict", "duplicate_or_admin_error", "non_payment", "policy_or_eligibility", "other", "legacy_client_unspecified"];
             readonly content_entry_status: readonly ["draft", "scheduled", "published", "archived"];
-            readonly content_owner_kind: readonly ["block", "entry", "page"];
+            readonly content_owner_kind: readonly ["block", "entry", "page", "entry_slot"];
             readonly content_stage: readonly ["draft", "published"];
             readonly gsc_property_type: readonly ["domain", "url_prefix"];
             readonly impersonation_scope: readonly ["read", "write"];

package/dist/_dts/editor-blocks/src/BlockEditor.d.ts

@@ -7,6 +7,7 @@ import { type EditorStructuralCommand } from '../../core/src/index';
 import { type CustomBlockRegistryEntry, type SdkConfigForBlockPicker } from './block-editor/sdkBlockMerger';
 import { type BlockActionPresentation } from './block-editor/actionPresentation';
 import { type ReorderControlMode } from './block-editor/reorderControlMode';
+import { type BlockEditorOwner } from './block-editor/owner';
 import type { ArrayKeysManager, BlockEditorHandle, BlockItem, BlockFocusRequest, UiSlice, DraftsSlice } from './block-editor/types';
 import type { BlockDraftSaveability, FieldWidgetComponent } from '../../block-form/src/client/index';
 type UiState = {
@@ -35,7 +36,7 @@ type UiState = {
 };
 export type BlockEditorProps = {
     siteId: string;
-    pageId: string;
+    owner: BlockEditorOwner;
     blocks: BlockItem[];
     recoveryConflictBlockIds?: readonly string[];
     recoveryConflictReviewRequestId?: number | null;
@@ -43,6 +44,7 @@ export type BlockEditorProps = {
     apiClient: ApiClient;
     enableReordering?: boolean;
     enableCreation?: boolean;
+    enableDeletion?: boolean;
     onBlockSave?: (blockId: string, content: Record<string, unknown>) => void;
     onBlocksChange?: (blocks: BlockItem[]) => void;
     theme?: Theme | null;
@@ -53,6 +55,9 @@ export type BlockEditorProps = {
     enabledContentTypes?: string[];
     sdkConfig?: SdkConfigForBlockPicker | null;
     customBlocks?: readonly CustomBlockRegistryEntry[];
+    allowedBlockKinds?: readonly string[] | null;
+    emptyUnavailableMessage?: string;
+    initialCollapsed?: boolean;
     reorderControlMode?: ReorderControlMode;
     actionPresentation?: BlockActionPresentation;
 };

package/dist/_dts/editor-blocks/src/BlockForm.d.ts

@@ -4,7 +4,7 @@ import type { BlockManifest, Theme } from '../../blocks/src/index';
 import { type PageDesignEditorBlock } from '../../theme-core/src/site-styles/index';
 import { type EditorBlockId } from '../../core/src/index';
 import type { ArrayKeysManager, DraftsSlice, UiStore as BlockEditorUiStore } from './block-editor/types';
-type UiStoreState = {
+export type BlockFormUiStoreState = {
     setActivePreviewField: (field: {
         kind: 'block';
         blockId: EditorBlockId;
@@ -16,10 +16,12 @@ type UiStoreState = {
         showAllValidation: (blockId: EditorBlockId) => boolean;
         getBlockSaveability: (blockId: EditorBlockId) => BlockDraftSaveability;
     };
-    drafts: Pick<DraftsSlice, 'getBlockSnapshot' | 'getCurrentValues' | 'initNewBlock' | 'updateBlockBaseline' | 'clearError' | 'setAtPath' | 'getAtPath'>;
+    drafts: Pick<DraftsSlice, 'getBlockSnapshot' | 'getCurrentValues' | 'clearError' | 'setAtPath' | 'getAtPath'> & {
+        updateBlockBaseline?: (blockId: EditorBlockId, data: Record<string, unknown> | null) => void;
+    };
     arrayKeys: ArrayKeysManager;
 };
-type UiStore = BlockEditorUiStore<UiStoreState>;
+export type BlockFormUiStore = BlockEditorUiStore<BlockFormUiStoreState>;
 type BlockItem = {
     id?: string | null;
     kind: string;
@@ -33,11 +35,11 @@ type BlockFormFocusSignal = {
     fieldPath?: string | null;
     itemIndex?: number | null;
 };
-export declare function BlockForm({ siteId: _siteId, block, manifest, uiStore, hasRecoveryConflict, focusSignal, onFocusHandled, onSaveSuccess: _onSaveSuccess, theme, widgetOverrides, hideThemeV2RawStyleFields, pageDesignBlock, }: {
+export declare function BlockForm({ siteId: _siteId, block, manifest, uiStore, hasRecoveryConflict, focusSignal, onFocusHandled, onSaveSuccess, theme, widgetOverrides, hideThemeV2RawStyleFields, pageDesignBlock, }: {
     siteId: string;
     block: BlockItem;
     manifest: BlockManifest;
-    uiStore: UiStore;
+    uiStore: BlockFormUiStore;
     hasRecoveryConflict?: boolean;
     focusSignal?: BlockFormFocusSignal | null;
     onFocusHandled?: (requestId: number) => void;

package/dist/_dts/editor-blocks/src/block-editor/hooks/useBlockCreation.d.ts

@@ -2,6 +2,7 @@ import type { ApiClient } from '../../../../api/src/request';
 import type { BlockDescriptor } from '../../../../blocks/src/index';
 import type { EditorInsertBlockCommand } from '../../../../core/src/index';
 import type { BlockItem, BlockFocusTarget } from '../types';
+import { type BlockEditorOwner } from '../owner';
 type UiStore = {
     getState: () => {
         history: {
@@ -9,11 +10,11 @@ type UiStore = {
         };
     };
 };
-export declare function useBlockCreation({ allowCreation, apiClient, siteId, pageId, blockList, setBlockList, onBlocksChange, triggerFocus, uiStore, }: {
+export declare function useBlockCreation({ allowCreation, apiClient, siteId, owner, blockList, setBlockList, onBlocksChange, triggerFocus, uiStore, }: {
     allowCreation: boolean;
     apiClient: ApiClient;
     siteId: string;
-    pageId: string;
+    owner: BlockEditorOwner;
     blockList: BlockItem[];
     setBlockList: (next: BlockItem[]) => void;
     onBlocksChange?: (blocks: BlockItem[]) => void;