@riverbankcms/sdk 0.130.2 → 0.132.0

package/dist/_dts/core/src/booking-vertical-config.d.ts

@@ -0,0 +1,66 @@
+import type { VerticalBookingPresetDefinition, VerticalDefinition, VerticalId, VerticalPresetId } from './booking-verticals';
+export type NonEmptyVerticalPresetIds = readonly [
+    VerticalPresetId,
+    ...VerticalPresetId[]
+];
+export type UnconfiguredSiteVerticalBookingConfig = Readonly<{
+    verticalId: null;
+    selectedPresetIds: readonly [];
+}>;
+export type ConfiguredSiteVerticalBookingConfig = Readonly<{
+    verticalId: VerticalId;
+    selectedPresetIds: NonEmptyVerticalPresetIds;
+}>;
+export type SiteVerticalBookingConfig = UnconfiguredSiteVerticalBookingConfig | ConfiguredSiteVerticalBookingConfig;
+export type ParsedSiteVerticalBookingConfig = Readonly<{
+    verticalId: VerticalId | null;
+    selectedPresetIds: readonly VerticalPresetId[];
+}>;
+export type RawSiteVerticalBookingConfig = Readonly<{
+    verticalId?: unknown;
+    selectedPresetIds?: unknown;
+}>;
+export type SiteVerticalConfigIssue = Readonly<{
+    code: 'unknown_vertical';
+    rawValue: unknown;
+}> | Readonly<{
+    code: 'missing_vertical';
+}> | Readonly<{
+    code: 'unknown_preset';
+    rawValue: unknown;
+}> | Readonly<{
+    code: 'empty_selected_presets';
+}> | Readonly<{
+    code: 'preset_vertical_mismatch';
+}> | Readonly<{
+    code: 'duplicate_preset_id';
+}> | Readonly<{
+    code: 'duplicate_canonical_behaviour';
+}> | Readonly<{
+    code: 'future_preset_selected';
+}>;
+export type ResolvedSiteVerticalBookingConfig = Readonly<{
+    kind: 'unconfigured';
+    config: SiteVerticalBookingConfig;
+}> | Readonly<{
+    kind: 'configured';
+    config: ConfiguredSiteVerticalBookingConfig;
+    selectedPresets: readonly VerticalBookingPresetDefinition[];
+}> | Readonly<{
+    kind: 'invalid';
+    config: ParsedSiteVerticalBookingConfig;
+    issues: readonly SiteVerticalConfigIssue[];
+}>;
+export declare function parseVerticalId(value: unknown): VerticalId | null;
+export declare function parseVerticalPresetId(value: unknown): VerticalPresetId | null;
+export declare function getVerticalDefinition(verticalId: VerticalId): VerticalDefinition;
+export declare function getVerticalPresetDefinition(presetId: VerticalPresetId): VerticalBookingPresetDefinition;
+export declare function getDefaultOnboardingPresetForVertical(verticalId: VerticalId): VerticalBookingPresetDefinition | null;
+/**
+ * Construct a configured booking selection only when the supplied preset IDs
+ * form a valid selection for the vertical. Invalid, cross-vertical, future,
+ * duplicate, or empty selections return null.
+ */
+export declare function createSiteVerticalBookingConfig(verticalId: VerticalId, selectedPresetIds: readonly VerticalPresetId[]): ConfiguredSiteVerticalBookingConfig | null;
+export declare const DEFAULT_SITE_VERTICAL_BOOKING_CONFIG: SiteVerticalBookingConfig;
+export declare function resolveSiteVerticalBookingConfig(rawConfig: RawSiteVerticalBookingConfig | null | undefined): ResolvedSiteVerticalBookingConfig;

package/dist/_dts/core/src/booking-vertical-definitions.d.ts

@@ -0,0 +1,68 @@
+export type VerticalDefinition = Readonly<{
+    id: string;
+    label: string;
+    description: string;
+}>;
+export declare const VERTICAL_DEFINITIONS: readonly [{
+    readonly id: "yoga_wellness";
+    readonly label: "Yoga, meditation or mindfulness";
+    readonly description: "Yoga studios, wellness teachers, and movement practitioners.";
+}, {
+    readonly id: "fitness_pt";
+    readonly label: "Fitness and personal training";
+    readonly description: "Personal trainers, group training, and fitness programmes.";
+}, {
+    readonly id: "dance_school";
+    readonly label: "Dance school";
+    readonly description: "Dance classes, courses or terms, workshops, private lessons, and shows.";
+}, {
+    readonly id: "physiotherapy_physical_health";
+    readonly label: "Physiotherapy & physical health";
+    readonly description: "Physiotherapists, chiropractors, osteopaths, sports therapists, and rehabilitation practitioners.";
+}, {
+    readonly id: "massage_bodywork";
+    readonly label: "Massage & bodywork";
+    readonly description: "Massage therapists, bodyworkers, and somatic practitioners.";
+}, {
+    readonly id: "therapist_practitioner";
+    readonly label: "Therapist or practitioner";
+    readonly description: "Appointments, sessions, consultations, and occasional group work.";
+}, {
+    readonly id: "beauty_spa";
+    readonly label: "Beauty or spa";
+    readonly description: "Treatment-led businesses with optional workshops.";
+}, {
+    readonly id: "consultant_coach";
+    readonly label: "Consultant or coach";
+    readonly description: "One-to-one calls, workshops, courses, and retreats.";
+}, {
+    readonly id: "training_provider";
+    readonly label: "Training provider";
+    readonly description: "Courses, workshops, classes, appointments, and residential training.";
+}, {
+    readonly id: "retreat_centre";
+    readonly label: "Retreat centre";
+    readonly description: "Residential retreats, workshops, classes, courses, and private sessions.";
+}, {
+    readonly id: "music_school";
+    readonly label: "Music teacher or school";
+    readonly description: "Lessons, classes, terms, workshops, and performances.";
+}, {
+    readonly id: "voice_singing";
+    readonly label: "Voice & Singing";
+    readonly description: "Singing lessons, choirs, voice circles, workshops, and performances.";
+}, {
+    readonly id: "performing_arts_school";
+    readonly label: "Theatre or performing arts school";
+    readonly description: "Classes, terms, workshops, performances, and lessons.";
+}, {
+    readonly id: "community_wellbeing";
+    readonly label: "Community or wellbeing centre";
+    readonly description: "Groups, workshops, courses, appointments, and retreats.";
+}, {
+    readonly id: "venue_event_space";
+    readonly label: "Venue or event space";
+    readonly description: "Room, resource, or access bookings. Depends on the future capacity-booking domain.";
+}];
+export type VerticalId = (typeof VERTICAL_DEFINITIONS)[number]['id'];
+export declare const VERTICAL_IDS: readonly VerticalId[];

package/dist/_dts/{api/src/bookingVerticalPreset.d.ts → core/src/booking-vertical-preset.d.ts}

@@ -1,4 +1,4 @@
-import type { CanonicalBookingBehaviour, VerticalBookingPreset, VerticalId, VerticalPresetAvailability } from './bookingVerticals';
+import type { CanonicalBookingBehaviour, VerticalBookingPreset, VerticalId, VerticalPresetAvailability } from './booking-verticals';
 export declare const BOOKING_ENGINE_BY_BEHAVIOUR: {
     readonly class: "event_series";
     readonly workshop: "event_series";

package/dist/_dts/core/src/booking-verticals.d.ts

@@ -0,0 +1,98 @@
+import { type EventPresetOverride } from './event-series-behaviour';
+import { BOOKING_DEFAULTS_BY_BEHAVIOUR, BOOKING_ENGINE_BY_BEHAVIOUR, VERTICAL_BOOKING_PRESETS } from './booking-vertical-catalog';
+import { VERTICAL_DEFINITIONS, VERTICAL_IDS } from './booking-vertical-definitions';
+import type { VerticalId } from './booking-vertical-definitions';
+import { DEFAULT_SITE_VERTICAL_BOOKING_CONFIG, createSiteVerticalBookingConfig, getDefaultOnboardingPresetForVertical, getVerticalDefinition, getVerticalPresetDefinition, parseVerticalId, parseVerticalPresetId, resolveSiteVerticalBookingConfig } from './booking-vertical-config';
+import type { ConfiguredSiteVerticalBookingConfig, NonEmptyVerticalPresetIds, ParsedSiteVerticalBookingConfig, RawSiteVerticalBookingConfig, ResolvedSiteVerticalBookingConfig, SiteVerticalBookingConfig, SiteVerticalConfigIssue, UnconfiguredSiteVerticalBookingConfig } from './booking-vertical-config';
+export type { VerticalId } from './booking-vertical-definitions';
+export { BOOKING_DEFAULTS_BY_BEHAVIOUR, BOOKING_ENGINE_BY_BEHAVIOUR, DEFAULT_SITE_VERTICAL_BOOKING_CONFIG, createSiteVerticalBookingConfig, getDefaultOnboardingPresetForVertical, getVerticalDefinition, getVerticalPresetDefinition, parseVerticalId, parseVerticalPresetId, resolveSiteVerticalBookingConfig, VERTICAL_BOOKING_PRESETS, VERTICAL_DEFINITIONS, VERTICAL_IDS, };
+export type { ConfiguredSiteVerticalBookingConfig, NonEmptyVerticalPresetIds, ParsedSiteVerticalBookingConfig, RawSiteVerticalBookingConfig, ResolvedSiteVerticalBookingConfig, SiteVerticalBookingConfig, SiteVerticalConfigIssue, UnconfiguredSiteVerticalBookingConfig, };
+export type VerticalBookingPresetDefinition = (typeof VERTICAL_BOOKING_PRESETS)[number];
+export type VerticalPresetId = VerticalBookingPresetDefinition['id'];
+export declare const CANONICAL_BOOKING_BEHAVIOURS: readonly ["class", "workshop", "course", "retreat", "performance", "appointment"];
+export type CanonicalBookingBehaviour = (typeof CANONICAL_BOOKING_BEHAVIOURS)[number];
+export declare const BOOKING_ENGINES: readonly ["event_series", "appointment_service"];
+export type BookingEngine = (typeof BOOKING_ENGINES)[number];
+export declare const VERTICAL_PRESET_AVAILABILITIES: readonly ["onboarding", "settings", "future"];
+export type VerticalPresetAvailability = (typeof VERTICAL_PRESET_AVAILABILITIES)[number];
+export type EventSeriesCanonicalBehaviour = Extract<CanonicalBookingBehaviour, 'class' | 'course' | 'workshop' | 'retreat' | 'performance'>;
+export type EventSeriesVerticalPresetId = Extract<VerticalPresetId, `${string}.${string}`>;
+export type EventSeriesVerticalPresetDefinition = VerticalBookingPresetDefinition & {
+    canonicalBehaviour: EventSeriesCanonicalBehaviour;
+};
+type BookingPassMembershipDefault = 'on' | 'off' | 'strict';
+export type BookingBehaviourDefaults = Readonly<{
+    passes: BookingPassMembershipDefault;
+    memberships: BookingPassMembershipDefault;
+}>;
+export type VerticalBookingPreset = Readonly<{
+    id: string;
+    verticalId: VerticalId;
+    canonicalBehaviour: CanonicalBookingBehaviour;
+    eventPresetOverride?: EventPresetOverride;
+    engine: BookingEngine;
+    availability: VerticalPresetAvailability;
+    label: string;
+    pluralLabel: string;
+    description: string;
+}>;
+export type VerticalDefinition = (typeof VERTICAL_DEFINITIONS)[number];
+export type EventSeriesVerticalPresetValidationError = 'unknown_vertical_preset' | 'non_event_series_preset' | 'canonical_behaviour_mismatch';
+export type EventSeriesVerticalPresetValidationResult = Readonly<{
+    ok: true;
+    preset: EventSeriesVerticalPresetDefinition;
+}> | Readonly<{
+    ok: false;
+    error: EventSeriesVerticalPresetValidationError;
+}>;
+export type VerticalPresetSelectionDisabledReason = 'last_selected_preset';
+export type VerticalPresetSelectionOption = Readonly<{
+    preset: VerticalBookingPresetDefinition;
+    checked: boolean;
+    disabledReason: VerticalPresetSelectionDisabledReason | null;
+}>;
+export type VerticalPresetSelectionUpdateError = 'unconfigured' | 'cross_vertical_preset' | 'future_preset' | 'last_selected_preset';
+export type VerticalPresetSelectionUpdateResult = Readonly<{
+    ok: true;
+    config: SiteVerticalBookingConfig;
+}> | Readonly<{
+    ok: false;
+    error: VerticalPresetSelectionUpdateError;
+    config: SiteVerticalBookingConfig;
+}>;
+export type CanonicalConfiguredSiteVerticalBookingConfigResult = Readonly<{
+    ok: true;
+    config: ConfiguredSiteVerticalBookingConfig;
+}> | Readonly<{
+    ok: false;
+    issues: readonly SiteVerticalConfigIssue[];
+}>;
+export declare function getVerticalPresetsForVertical(verticalId: VerticalId, options?: Readonly<{
+    availability?: VerticalPresetAvailability | 'selectable';
+}>): readonly VerticalBookingPresetDefinition[];
+export declare function getOnboardingPresetsForVertical(verticalId: VerticalId): readonly VerticalBookingPresetDefinition[];
+export declare function isEventSeriesCanonicalBehaviour(behaviour: CanonicalBookingBehaviour): behaviour is EventSeriesCanonicalBehaviour;
+export declare function isEventSeriesVerticalPresetDefinition(presetDefinition: VerticalBookingPresetDefinition): presetDefinition is EventSeriesVerticalPresetDefinition;
+export declare function validateEventSeriesVerticalPreset(input: Readonly<{
+    canonicalPreset: EventSeriesCanonicalBehaviour | 'term';
+    verticalPresetId: string | null | undefined;
+}>): EventSeriesVerticalPresetValidationResult;
+export declare function getSelectedCanonicalBehaviours(presetIds: readonly VerticalPresetId[]): readonly CanonicalBookingBehaviour[];
+export declare function getSelectedPresetForBehaviour(input: Readonly<{
+    presetIds: readonly VerticalPresetId[];
+    canonicalBehaviour: CanonicalBookingBehaviour;
+}>): VerticalBookingPresetDefinition | null;
+export declare function getVerticalPresetSelectionOptions(config: SiteVerticalBookingConfig | null | undefined): readonly VerticalPresetSelectionOption[];
+export declare function setVerticalPresetSelected(config: SiteVerticalBookingConfig | null | undefined, presetId: VerticalPresetId, selected: boolean): VerticalPresetSelectionUpdateResult;
+export declare function setVerticalPresetsSelected(config: SiteVerticalBookingConfig | null | undefined, presetIds: readonly VerticalPresetId[]): VerticalPresetSelectionUpdateResult;
+/**
+ * Return a configured selection in the catalog's canonical order.
+ *
+ * This deliberately delegates ordering and selection semantics to the core
+ * authority instead of making dashboard planners maintain a second catalog
+ * ordering implementation.  Runtime-invalid values are reported as a closed
+ * result so this pure helper never throws while planning.
+ */
+export declare function canonicalizeConfiguredBookingVerticalConfig(config: ConfiguredSiteVerticalBookingConfig): CanonicalConfiguredSiteVerticalBookingConfigResult;
+/** Compare configured booking selections by catalog order, not authored array order. */
+export declare function areConfiguredBookingVerticalConfigsEqual(left: ConfiguredSiteVerticalBookingConfig, right: ConfiguredSiteVerticalBookingConfig): boolean;

package/dist/_dts/core/src/event-page-selection.d.ts

@@ -0,0 +1,22 @@
+/** Render-time selection beneath a canonical Event page. */
+export type EventOccurrenceContextData = Readonly<{
+    id: string;
+    seriesId: string;
+    startsAt: string;
+    endsAt: string;
+    timeZone: string;
+    capacityOverride?: number | null;
+    overrides?: Record<string, unknown> | null;
+}>;
+export type EventRunContextData = Readonly<{
+    seriesId: string;
+    identifier: string;
+    name: string | null;
+}>;
+export type EventPageSubrouteContext = Readonly<{
+    kind: 'event-occurrence';
+    occurrence: EventOccurrenceContextData;
+}> | Readonly<{
+    kind: 'event-run';
+    run: EventRunContextData;
+}>;

package/dist/_dts/core/src/event-pricing.d.ts

@@ -18,6 +18,11 @@ export type PublicCoursePriceDisplay = Readonly<{
     minAmount: number;
     maxAmount: number;
     currency: string;
+}> | Readonly<{
+    kind: "mixed";
+    paidFromAmount: number;
+    paidToAmount: number;
+    currency: string;
 }> | Readonly<{
     kind: "unavailable";
     currency: string;

package/dist/_dts/core/src/event-series-behaviour.d.ts

@@ -0,0 +1,16 @@
+export declare const EVENT_PRESET_VALUES: readonly ["event", "class", "course", "term", "workshop", "retreat", "performance"];
+export type EventPreset = (typeof EVENT_PRESET_VALUES)[number];
+export type EventPresetOverride = Extract<EventPreset, 'term'>;
+export type WholeSeriesEventPreset = Extract<EventPreset, 'course' | 'term'>;
+export type OrdinaryEventPreset = Exclude<EventPreset, WholeSeriesEventPreset>;
+export declare const ORDINARY_EVENT_PRESET_VALUES: readonly ["event", "class", "workshop", "retreat", "performance"];
+export declare const WHOLE_SERIES_EVENT_PRESET_VALUES: readonly ["course", "term"];
+export declare const SURFACE_EVENT_PRESET_VALUES: readonly ["class", "course", "term", "workshop", "retreat", "performance"];
+export declare const DEFAULT_EVENT_TYPE_PRESETS: readonly ["event", "class", "course", "term", "workshop", "retreat"];
+export declare const EVENT_SERIES_BEHAVIOURS: readonly ["class", "course", "workshop", "retreat", "performance"];
+/** Keeps Term as Event vocabulary without introducing a second booking engine. */
+export declare function eventPresetForVerticalPreset<TCanonical extends string>(preset: Readonly<{
+    id: string;
+    canonicalBehaviour: TCanonical;
+    eventPresetOverride?: EventPresetOverride;
+}>): TCanonical | EventPresetOverride;

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

@@ -8,6 +8,7 @@ export * from './demo-runtime';
 export * from './collections';
 export * from './event-pricing';
 export * from './event-page-surface-subject';
+export * from './event-page-selection';
 export * from './public-event-booking-availability';
 export * from './money-input';
 export * from './booking-flexible-balance';
@@ -58,3 +59,5 @@ export * from './site-route-target';
 export { disabledSelection, enabledSelection, plannerNoChange, plannerPatch, plannerUpdate, resolvePlanningDateInput, resolvePlanningNow, resolvePlanningNowDate, systemPlanningClock, } from './planner';
 export type { DisabledSelection, EnabledSelection, OptionalSelection, PlannerNoChange, PlannerPatch, PlannerUpdate, PlanningClock, PlanningDateInput, PlanningTimeOptions, } from './planner';
 export { isValidBookingTimeZone, parseBookingTimeZone, type BookingTimeZone, type BookingTimeZoneParseError, } from './booking-time-zone';
+export * from './booking-verticals';
+export * from './event-series-behaviour';

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

@@ -8894,6 +8894,7 @@ export type Database = {
                     created_at: string;
                     created_by: string | null;
                     deleted_at: string | null;
+                    event_category_id: string | null;
                     id: string;
                     metadata_json: Json;
                     page_surface_id: string | null;
@@ -8913,6 +8914,7 @@ export type Database = {
                     created_at?: string;
                     created_by?: string | null;
                     deleted_at?: string | null;
+                    event_category_id?: string | null;
                     id?: string;
                     metadata_json?: Json;
                     page_surface_id?: string | null;
@@ -8932,6 +8934,7 @@ export type Database = {
                     created_at?: string;
                     created_by?: string | null;
                     deleted_at?: string | null;
+                    event_category_id?: string | null;
                     id?: string;
                     metadata_json?: Json;
                     page_surface_id?: string | null;
@@ -8946,6 +8949,13 @@ export type Database = {
                     updated_by?: string | null;
                 };
                 Relationships: [
+                    {
+                        foreignKeyName: "event_offerings_event_category_id_fkey";
+                        columns: ["event_category_id"];
+                        isOneToOne: false;
+                        referencedRelation: "booking_event_categories";
+                        referencedColumns: ["id"];
+                    },
                     {
                         foreignKeyName: "event_offerings_page_surface_id_fkey";
                         columns: ["page_surface_id"];
@@ -19078,6 +19088,13 @@ export type Database = {
                 };
                 Returns: boolean;
             };
+            cancel_appointment_reminder_jobs: {
+                Args: {
+                    p_appointment_id: string;
+                    p_site_id: string;
+                };
+                Returns: undefined;
+            };
             cancel_booking_with_pass_credit_restoration: {
                 Args: {
                     p_actor_kind?: string;
@@ -19712,6 +19729,24 @@ export type Database = {
                     window_started_at: string;
                 }[];
             };
+            count_gifting_instrument_references_by_offer: {
+                Args: {
+                    p_site_id: string;
+                };
+                Returns: {
+                    instrument_count: number;
+                    offer_id: string;
+                }[];
+            };
+            count_gifting_instruments_by_offer: {
+                Args: {
+                    p_site_id: string;
+                };
+                Returns: {
+                    instrument_count: number;
+                    offer_id: string;
+                }[];
+            };
             create_appointment_reservation_run_atomic: {
                 Args: {
                     p_actor_user_id: string;
@@ -20389,6 +20424,21 @@ export type Database = {
                     total_count: number;
                 }[];
             };
+            get_gifting_dashboard_stats: {
+                Args: {
+                    p_expiring_soon_days: number;
+                    p_now: string;
+                    p_site_id: string;
+                    p_time_zone: string;
+                };
+                Returns: {
+                    attention_count: number;
+                    expiring_soon_count: number;
+                    sold_this_month_cents: number;
+                    sold_this_month_count: number;
+                    unclaimed_cents: number;
+                }[];
+            };
             get_public_event_attendee_counts: {
                 Args: {
                     instance_ids: string[];
@@ -21299,6 +21349,14 @@ export type Database = {
                 };
                 Returns: Json;
             };
+            reinstate_event_occurrences_atomic_v1: {
+                Args: {
+                    p_event_series_id: string;
+                    p_occurrence_ids: string[];
+                    p_site_id: string;
+                };
+                Returns: string;
+            };
             release_dated_offering_whole_series_hold_v1_atomic: {
                 Args: {
                     p_hold_id: string;
@@ -21433,6 +21491,20 @@ export type Database = {
                 };
                 Returns: boolean;
             };
+            reschedule_customer_appointment: {
+                Args: {
+                    p_appointment_id: string;
+                    p_customer_id: string;
+                    p_end_at: string;
+                    p_expected_updated_at: string;
+                    p_google_event_id?: string;
+                    p_metadata: Json;
+                    p_resource_id: string;
+                    p_site_id: string;
+                    p_start_at: string;
+                };
+                Returns: boolean;
+            };
             reserve_booking_customer_credit: {
                 Args: {
                     p_amount_requested_cents: number;

package/dist/_dts/db/src/schemas/forms.d.ts

@@ -147,8 +147,8 @@ export declare const bookingQuestionsFormSettingsSchema: z.ZodObject<{
     }, z.core.$strict>>;
     audienceHint: z.ZodOptional<z.ZodEnum<{
         mixed: "mixed";
-        appointments: "appointments";
         courses: "courses";
+        appointments: "appointments";
         events: "events";
     }>>;
     customerTitle: z.ZodOptional<z.ZodString>;
@@ -256,8 +256,8 @@ export declare const formSettingsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strict>>;
     audienceHint: z.ZodOptional<z.ZodEnum<{
         mixed: "mixed";
-        appointments: "appointments";
         courses: "courses";
+        appointments: "appointments";
         events: "events";
     }>>;
     customerTitle: z.ZodOptional<z.ZodString>;
@@ -372,8 +372,8 @@ export declare const formSettingsInputSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     }, z.core.$strict>>;
     audienceHint: z.ZodOptional<z.ZodEnum<{
         mixed: "mixed";
-        appointments: "appointments";
         courses: "courses";
+        appointments: "appointments";
         events: "events";
     }>>;
     customerTitle: z.ZodOptional<z.ZodString>;
@@ -1086,8 +1086,8 @@ export declare const createFormPayloadSchema: z.ZodObject<{
         }, z.core.$strict>>;
         audienceHint: z.ZodOptional<z.ZodEnum<{
             mixed: "mixed";
-            appointments: "appointments";
             courses: "courses";
+            appointments: "appointments";
             events: "events";
         }>>;
         customerTitle: z.ZodOptional<z.ZodString>;

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

@@ -1,5 +1,6 @@
 import { type Result, type SiteScopedStoragePath, type StorageBucketName, type StoragePath, type UploadSessionId, type UtcIsoDateTimeString } from '../../core/src/index';
 import { type ActiveValidatedDurableFileAsset, type FileAssetId, type UploadSessionState, type UploadSessionTransitionError } from './fileDomain';
+import type { MediaIdentifier } from './identifiers';
 import { type DurableFinalizeUploadAssetPlan, type DurableUploadStoragePathError } from './fileUploadAssetBuilder';
 import type { FileUploadFinalizationPlan } from './fileUploadFinalization';
 type UploadedUploadSessionState = Extract<UploadSessionState, {
@@ -26,6 +27,7 @@ export type FileUploadCompletionStep = {
 } | {
     readonly tag: 'insert-file-asset';
     readonly asset: ActiveValidatedDurableFileAsset;
+    readonly identifier: MediaIdentifier;
 } | {
     readonly tag: 'delete-staged-object';
     readonly storageObject: FileUploadCompletionStorageObject;
@@ -69,6 +71,7 @@ export type DurableFileUploadCompletionPlan = {
 export type DurableFileUploadCompletionInput = {
     readonly finalizationPlan: DurableFinalizeUploadAssetPlan;
     readonly asset: ActiveValidatedDurableFileAsset;
+    readonly identifier: MediaIdentifier;
     readonly now: UtcIsoDateTimeString;
 };
 export type DurableFileUploadCompletionError = {

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

@@ -1,10 +1,12 @@
 import { type MediaAssetId, type Result } from '../../core/src/index';
 import type { FileAssetMetadata } from './fileDomain';
+import type { MediaIdentifier } from './identifiers';
 import { type BuildFinalizedUploadAssetError } from './fileUploadAssetBuilder';
 import { type DurableFileUploadCompletionError, type DurableFileUploadCompletionPlan } from './fileUploadCompletion';
 import { type FileUploadFinalizationError, type FileUploadFinalizationInput } from './fileUploadFinalization';
 export type DurableFileUploadFinalizationInput = FileUploadFinalizationInput & {
     readonly assetId: MediaAssetId;
+    readonly identifier: MediaIdentifier;
     readonly metadata?: FileAssetMetadata;
 };
 export type DurableFileUploadFinalizationError = {

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

@@ -8,10 +8,20 @@ export type MediaIdentifierParseError = Readonly<{
     kind: 'empty_after_normalization';
     value: string;
 }>;
+export type CanonicalMediaIdentifierParseError = MediaIdentifierParseError | Readonly<{
+    kind: 'non_canonical_identifier';
+    value: string;
+    canonical: MediaIdentifier;
+}>;
 export declare function stripFileExtension(filename: string): string;
 export declare function slugifyMediaIdentifier(value: string): string;
 export declare function buildMediaIdentifierFromFilename(filename: string): string;
 export declare function parseMediaIdentifier(value: unknown): Result<MediaIdentifier, MediaIdentifierParseError>;
+/**
+ * Admits identifiers read from trusted persistence without repairing dirty data in memory.
+ * User input should use parseMediaIdentifier, which intentionally canonicalizes it.
+ */
+export declare function parseCanonicalMediaIdentifier(value: unknown): Result<MediaIdentifier, CanonicalMediaIdentifierParseError>;
 export declare function parseOptionalMediaIdentifier(value: unknown): Result<MediaIdentifier | undefined, MediaIdentifierParseError>;
 export declare function unsafeAsMediaIdentifier(value: string): MediaIdentifier;
 export declare function resolveMediaIdentifier(base: string, existing: Set<string>): MediaIdentifier;

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

@@ -1,16 +1,12 @@
+import { type MediaIdentifier } from './identifiers';
 export type MediaIdentifierResolutionRecord = Readonly<{
     id: string;
-    identifier: string | null;
+    identifier: MediaIdentifier;
     filename: string;
 }>;
-export type MediaIdentifierAssignmentRequest = Readonly<{
-    assetId: string;
-    filenameBase: string;
-}>;
 export type NormalizeMediaReferencesForWriteCoreOptions = Readonly<{
     value: unknown;
     resolveMediaAssetsById: (assetIds: readonly string[]) => Promise<readonly MediaIdentifierResolutionRecord[]>;
-    assignIdentifier: (request: MediaIdentifierAssignmentRequest) => Promise<string | null>;
 }>;
 /**
  * Normalizes CMS media objects to identifier-only persistence. Infrastructure

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

@@ -1,4 +1,5 @@
 import type { MediaAssetId, SiteScopedStoragePath } from '../../core/src/index';
+import type { MediaIdentifier } from './identifiers';
 export type { MediaAssetId } from '../../core/src/index';
 export type MediaSource = 'upload' | 'instagram';
 export type MediaAsset = {
@@ -7,7 +8,7 @@ export type MediaAsset = {
     storageBucket: string;
     storagePath: SiteScopedStoragePath;
     filename: string;
-    identifier?: string;
+    identifier: MediaIdentifier;
     mimeType: string;
     title?: string;
     width?: number;

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

@@ -16,5 +16,5 @@ export { createMediaEditorProvider } from './createMediaEditorProvider';
 export { withRepeaterStackMediaFieldUi, withRepeaterThumbnailMediaFieldUi, withRepeaterThumbnailPickerOnlyMediaFieldUi, } from './fieldUi';
 export type { MediaValue, PersistableMediaValue, MediaTransform, MediaHotspot } from './types';
 export { DEFAULT_HOTSPOT } from './utils';
-export { buildPersistableMediaValue, mediaSelectionFailureMessage, prepareMediaAssetForSelection, } from './mediaSelection';
-export type { BuildPersistableMediaValueOptions, IdentifierReadyMediaAsset, PrepareMediaSelectionResult, } from './mediaSelection';
+export { buildPersistableMediaValue, } from './mediaSelection';
+export type { BuildPersistableMediaValueOptions, IdentifierReadyMediaAsset, } from './mediaSelection';

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

@@ -1,25 +1,6 @@
-import type { ApiClient } from '../../api/src/request';
-import { type MediaIdentifier } from '../../blocks/src/index';
 import type { MediaAssetWithLabels } from '@riverbankcms/media-storage-supabase';
 import type { MediaValue, PersistableMediaValue } from './types';
-export type IdentifierReadyMediaAsset = Omit<MediaAssetWithLabels, 'identifier'> & Readonly<{
-    identifier: MediaIdentifier;
-}>;
-export type PrepareMediaSelectionResult = Readonly<{
-    tag: 'ready';
-    asset: IdentifierReadyMediaAsset;
-}> | Readonly<{
-    tag: 'failed';
-    reason: 'identifier-assignment-failed';
-    error: unknown;
-}> | Readonly<{
-    tag: 'failed';
-    reason: 'identifier-missing-after-assignment';
-}>;
-type PrepareMediaSelectionFailure = Extract<PrepareMediaSelectionResult, {
-    tag: 'failed';
-}>;
-export declare function mediaSelectionFailureMessage(failure: PrepareMediaSelectionFailure): string;
+export type IdentifierReadyMediaAsset = MediaAssetWithLabels;
 export type BuildPersistableMediaValueOptions = Readonly<{
     asset: IdentifierReadyMediaAsset;
     mediaKind: PersistableMediaValue['type'];
@@ -28,5 +9,3 @@ export type BuildPersistableMediaValueOptions = Readonly<{
     publicUrl?: string;
 }>;
 export declare function buildPersistableMediaValue({ asset, mediaKind, previousValue, poster, publicUrl, }: BuildPersistableMediaValueOptions): PersistableMediaValue;
-export declare function prepareMediaAssetForSelection(apiClient: ApiClient, asset: MediaAssetWithLabels): Promise<PrepareMediaSelectionResult>;
-export {};

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

@@ -2,14 +2,6 @@ import type { MediaAssetWithLabels, MediaKind } from '@riverbankcms/media-storag
 import type { MediaEditorContextValue } from './context';
 import type { MediaPickerAssetSelection } from './MediaPickerDialog';
 import type { MediaValue, PersistableMediaValue } from './types';
-export type MediaSelectionState = Readonly<{
-    tag: 'idle';
-}> | Readonly<{
-    tag: 'preparing';
-}> | Readonly<{
-    tag: 'failed';
-    message: string;
-}>;
 type UseMediaSelectionOptions = Readonly<{
     context: MediaEditorContextValue;
     value: MediaValue | undefined;
@@ -21,6 +13,5 @@ type UseMediaSelectionOptions = Readonly<{
 export declare function useMediaSelection(options: UseMediaSelectionOptions): {
     readonly cancelSelection: () => void;
     readonly handleSelect: (picked: MediaAssetWithLabels) => Promise<void>;
-    readonly selectionState: MediaSelectionState;
 };
 export {};

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

@@ -0,0 +1,10 @@
+import React from 'react';
+import { type Theme } from '../../../../blocks/src/index';
+import { type ButtonHoverRoleControl, type ButtonStyleSelection } from '../../../../theme-core/src/buttons/index';
+export declare function ButtonHoverRoleControls({ control, current, previewTheme, onPreview, disabled, }: Readonly<{
+    control: ButtonHoverRoleControl<string>;
+    current: ButtonStyleSelection;
+    previewTheme: Theme;
+    onPreview: (selection: ButtonStyleSelection) => void;
+    disabled?: boolean;
+}>): React.JSX.Element | null;