@riverbankcms/sdk 0.88.0 → 0.89.1

package/dist/_dts/blocks/src/system/runtime/hooks/useEventFilters.state.d.ts

@@ -0,0 +1,31 @@
+import type { EventFiltersResponse } from '../api/types';
+export declare const EMPTY_EVENT_FILTERS: EventFiltersResponse;
+export type EventFiltersLoadState = Readonly<{
+    kind: 'idle';
+    filters: EventFiltersResponse;
+}> | Readonly<{
+    kind: 'loading';
+    filters: EventFiltersResponse;
+}> | Readonly<{
+    kind: 'loaded';
+    filters: EventFiltersResponse;
+}> | Readonly<{
+    kind: 'error';
+    filters: EventFiltersResponse;
+    error: Error;
+}>;
+export type EventFiltersLoadAction = Readonly<{
+    type: 'started';
+}> | Readonly<{
+    type: 'succeeded';
+    filters: EventFiltersResponse;
+}> | Readonly<{
+    type: 'failed';
+    error: Error;
+}>;
+export declare function createInitialEventFiltersLoadState(): EventFiltersLoadState;
+export declare function eventFiltersLoadReducer(state: EventFiltersLoadState, action: EventFiltersLoadAction): EventFiltersLoadState;
+export declare function toEventFiltersLoadError(error: unknown): Error;
+export declare function getEventFiltersData(state: EventFiltersLoadState): EventFiltersResponse;
+export declare function isEventFiltersLoading(state: EventFiltersLoadState): boolean;
+export declare function getEventFiltersError(state: EventFiltersLoadState): Error | null;

package/dist/_dts/blocks/src/system/runtime/hooks/useEventPagination.d.ts

@@ -21,9 +21,9 @@ type UseEventPaginationOptions = {
     /** Fetch stage (preview vs published) */
     stage?: 'preview' | 'published';
 };
-type EventPaginationState = {
+type EventPaginationResult = {
     /** All loaded events */
-    events: PublicEvent[];
+    events: readonly PublicEvent[];
     /** Whether a load operation is in progress */
     loading: boolean;
     /** Error from last load attempt */
@@ -49,5 +49,5 @@ type EventPaginationState = {
  * ```
  */
 export declare function useEventPagination({ siteId: _siteId, // Deprecated: siteId now comes from BlockApiProvider context
-initialEvents, fetchInitialOnMount, initialFilters, filters, pageSize, stage, }: UseEventPaginationOptions): EventPaginationState;
+initialEvents, fetchInitialOnMount, initialFilters, filters, pageSize, stage, }: UseEventPaginationOptions): EventPaginationResult;
 export default useEventPagination;

package/dist/_dts/blocks/src/system/runtime/hooks/useEventPagination.state.d.ts

@@ -0,0 +1,39 @@
+import type { PublicEvent } from '../../blocks/events/shared/types';
+export type EventPaginationLoadState = Readonly<{
+    kind: 'ready';
+    events: readonly PublicEvent[];
+    hasMore: boolean;
+}> | Readonly<{
+    kind: 'loading';
+    events: readonly PublicEvent[];
+    hasMore: boolean;
+}> | Readonly<{
+    kind: 'error';
+    events: readonly PublicEvent[];
+    hasMore: boolean;
+    error: Error;
+}>;
+export type EventPaginationLoadAction = Readonly<{
+    type: 'started';
+    reset: boolean;
+}> | Readonly<{
+    type: 'succeeded';
+    events: readonly PublicEvent[];
+    hasMore: boolean;
+}> | Readonly<{
+    type: 'failed';
+    error: Error;
+}> | Readonly<{
+    type: 'synced';
+    events: readonly PublicEvent[];
+    pageSize: number;
+}>;
+export declare function createInitialEventPaginationLoadState(events: readonly PublicEvent[], pageSize: number): EventPaginationLoadState;
+export declare function eventPaginationLoadReducer(state: EventPaginationLoadState, action: EventPaginationLoadAction): EventPaginationLoadState;
+export declare function getEventIdentity(event: PublicEvent): string;
+export declare function mergeEventPaginationEvents(existingEvents: readonly PublicEvent[], newEvents: readonly PublicEvent[]): readonly PublicEvent[];
+export declare function toEventPaginationLoadError(error: unknown): Error;
+export declare function getEventPaginationEvents(state: EventPaginationLoadState): readonly PublicEvent[];
+export declare function isEventPaginationLoading(state: EventPaginationLoadState): boolean;
+export declare function getEventPaginationError(state: EventPaginationLoadState): Error | null;
+export declare function hasMoreEventPages(events: readonly PublicEvent[], pageSize: number): boolean;

package/dist/_dts/blocks/src/system/runtime/nodes/events/shared/EventPaginatedListView.client.d.ts

@@ -5,7 +5,7 @@ import type { EventListPaginationAction } from './listOptions';
 type EventPaginatedListViewProps = {
     filters?: React.ReactNode;
     display: EventListingDisplay;
-    events: PublicEvent[];
+    events: readonly PublicEvent[];
     loading: boolean;
     error: Error | null;
     hasMore: boolean;

package/dist/_dts/blocks/src/system/runtime/nodes/newsletter-form.client.state.d.ts

@@ -6,7 +6,29 @@ export type NewsletterFormError = Readonly<{
     kind: 'form';
     message: string;
 }>;
+export type NewsletterFormSubmissionState = Readonly<{
+    tag: 'idle';
+}> | Readonly<{
+    tag: 'submitting';
+}> | Readonly<{
+    tag: 'error';
+    error: NewsletterFormError;
+}> | Readonly<{
+    tag: 'success';
+}>;
+export type NewsletterFormSubmissionAction = Readonly<{
+    type: 'submitted';
+}> | Readonly<{
+    type: 'failed';
+    error: NewsletterFormError;
+}> | Readonly<{
+    type: 'succeeded';
+}>;
+export declare const initialNewsletterFormSubmissionState: NewsletterFormSubmissionState;
+export declare function newsletterFormSubmissionReducer(state: NewsletterFormSubmissionState, action: NewsletterFormSubmissionAction): NewsletterFormSubmissionState;
 export declare function newsletterFieldError(fieldId: string, message: string): NewsletterFormError;
 export declare function newsletterFormError(message: string): NewsletterFormError;
-export declare function getNewsletterFieldError(error: NewsletterFormError | null, fieldId: string): string | null;
-export declare function getNewsletterFormError(error: NewsletterFormError | null): string | null;
+export declare function isNewsletterFormSubmitting(state: NewsletterFormSubmissionState): boolean;
+export declare function isNewsletterFormSuccess(state: NewsletterFormSubmissionState): boolean;
+export declare function getNewsletterSubmissionFieldError(state: NewsletterFormSubmissionState, fieldId: string): string | null;
+export declare function getNewsletterSubmissionFormError(state: NewsletterFormSubmissionState): string | null;

package/dist/_dts/blocks/src/system/runtime/nodes/shared/MagicLinkForm.state.d.ts

@@ -0,0 +1,24 @@
+export type MagicLinkSubmissionState = Readonly<{
+    tag: 'idle';
+}> | Readonly<{
+    tag: 'submitting';
+}> | Readonly<{
+    tag: 'success';
+}> | Readonly<{
+    tag: 'error';
+    message: string;
+}>;
+export type MagicLinkSubmissionAction = Readonly<{
+    type: 'submit-started';
+}> | Readonly<{
+    type: 'submit-succeeded';
+}> | Readonly<{
+    type: 'submit-failed';
+    message: string;
+}> | Readonly<{
+    type: 'reset';
+}>;
+export declare const initialMagicLinkSubmissionState: MagicLinkSubmissionState;
+export declare function magicLinkSubmissionReducer(state: MagicLinkSubmissionState, action: MagicLinkSubmissionAction): MagicLinkSubmissionState;
+export declare function isMagicLinkSubmitting(state: MagicLinkSubmissionState): boolean;
+export declare function getMagicLinkError(state: MagicLinkSubmissionState): string | null;

package/dist/_dts/blocks/src/system/runtime/shared/useWaitlistClaim.state.d.ts

@@ -0,0 +1,35 @@
+import type { ResolveWaitlistClaimResponse } from "../api/types";
+export type WaitlistClaimResolveFailure = Readonly<{
+    kind: "portal-login-required";
+    message: string;
+}> | Readonly<{
+    kind: "error";
+    message: string;
+}>;
+export type WaitlistClaimState = Readonly<{
+    kind: "idle";
+}> | Readonly<{
+    kind: "resolving";
+}> | Readonly<{
+    kind: "resolved";
+    claim: ResolveWaitlistClaimResponse;
+}> | WaitlistClaimResolveFailure;
+export type WaitlistClaimAction = Readonly<{
+    type: "cleared";
+}> | Readonly<{
+    type: "started";
+}> | Readonly<{
+    type: "resolved";
+    claim: ResolveWaitlistClaimResponse;
+}> | Readonly<{
+    type: "failed";
+    failure: WaitlistClaimResolveFailure;
+}>;
+export declare function createInitialWaitlistClaimState(hasToken: boolean): WaitlistClaimState;
+export declare function waitlistClaimReducer(_state: WaitlistClaimState, action: WaitlistClaimAction): WaitlistClaimState;
+export declare function toWaitlistClaimResolveFailure(error: unknown): WaitlistClaimResolveFailure;
+export declare function getWaitlistClaim(state: WaitlistClaimState): ResolveWaitlistClaimResponse | null;
+export declare function getWaitlistClaimError(state: WaitlistClaimState): string | null;
+export declare function getWaitlistClaimLoginMessage(state: WaitlistClaimState): string | null;
+export declare function requiresWaitlistClaimPortalLogin(state: WaitlistClaimState): boolean;
+export declare function isWaitlistClaimLoading(state: WaitlistClaimState): boolean;

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

@@ -320,6 +320,60 @@ export type SdkEntryBlocksPatchParseError = Readonly<{
     blockKind: string;
 }>;
 export declare function parseSdkEntryBlocksPatch(blocks: unknown): EntrySlotResult<SdkEntryBlocksPatch, SdkEntryBlocksPatchParseError>;
+export type SlotContainerOwner = Readonly<{
+    kind: 'contentEntry';
+    contentEntryId: EntrySlotContentEntryId;
+}>;
+export type SlotContainerOwnerParseError = Readonly<{
+    kind: 'not-object';
+}> | Readonly<{
+    kind: 'unsupported-owner-kind';
+    ownerKind: unknown;
+}> | Readonly<{
+    kind: 'invalid-content-entry-id';
+    error: NonEmptyStringParseError;
+}>;
+export declare function parseSlotContainerOwner(input: unknown): EntrySlotResult<SlotContainerOwner, SlotContainerOwnerParseError>;
+export declare function slotContainerOwnerToContentVersionOwner(owner: SlotContainerOwner): ContentVersionOwner;
+export declare function slotContainerOwnerToEntrySlotLookup(owner: SlotContainerOwner): Readonly<{
+    contentEntryId: EntrySlotContentEntryId;
+}>;
+export type PlannedSlotCompositionBlockWrite = Readonly<{
+    identifier: string | null;
+    blockKind: string;
+    purpose: string;
+    content: Record<string, unknown>;
+    orderIndex: EntrySlotBlockOrderIndex;
+}>;
+export type SlotCompositionMutationInput = Readonly<{
+    kind: 'leaveUnchanged';
+}> | Readonly<{
+    kind: 'replaceDraftComposition';
+    blocks: readonly PlannedSlotCompositionBlockWrite[];
+}> | Readonly<{
+    kind: 'publishDraftComposition';
+    draftVersionId: EntrySlotContentVersionId;
+}>;
+export type SlotCompositionMutationPlan = Readonly<{
+    kind: 'noChange';
+    owner: SlotContainerOwner;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'replaceDraftComposition';
+    owner: SlotContainerOwner;
+    slotKey: SlotKey;
+    blocks: readonly PlannedSlotCompositionBlockWrite[];
+}> | Readonly<{
+    kind: 'publishDraftComposition';
+    owner: SlotContainerOwner;
+    slotKey: SlotKey;
+    draftVersionId: EntrySlotContentVersionId;
+}>;
+export declare function planSlotCompositionMutation(input: Readonly<{
+    owner: SlotContainerOwner;
+    slotKey: SlotKey;
+    mutation: SlotCompositionMutationInput;
+}>): SlotCompositionMutationPlan;
 export type ContentVersionOwner = Readonly<{
     kind: 'block';
     blockId: EntrySlotBlockId;

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

@@ -24,7 +24,9 @@ export type BrandedIdParseError = {
 export declare function expectParsedBrandedId<TBrand>(result: Result<TBrand, BrandedIdParseError>): TBrand;
 export type EventInstanceId = Brand<string, 'EventInstanceId'>;
 export type SiteId = Brand<string, 'SiteId'>;
+export type SiteRouteId = Brand<string, 'SiteRouteId'>;
 export type PageId = Brand<string, 'PageId'>;
+export type PageSurfaceId = Brand<string, 'PageSurfaceId'>;
 export type OccurrenceId = Brand<string, 'OccurrenceId'>;
 export type EventSeriesId = Brand<string, 'EventSeriesId'>;
 export type TicketTypeId = Brand<string, 'TicketTypeId'>;
@@ -137,7 +139,9 @@ export declare const unsafeAsEntryId: (id: string) => EntryId;
 export declare const unsafeAsPreviewEntryId: (id: string) => PreviewEntryId;
 export declare const unsafeAsEventInstanceId: (id: string) => EventInstanceId;
 export declare const unsafeAsSiteId: (id: string) => SiteId;
+export declare const unsafeAsSiteRouteId: (id: string) => SiteRouteId;
 export declare const unsafeAsPageId: (id: string) => PageId;
+export declare const unsafeAsPageSurfaceId: (id: string) => PageSurfaceId;
 export declare const unsafeAsOccurrenceId: (id: string) => OccurrenceId;
 export declare const unsafeAsEventSeriesId: (id: string) => EventSeriesId;
 export declare const unsafeAsTicketTypeId: (id: string) => TicketTypeId;
@@ -224,6 +228,9 @@ export declare const unsafeAsEncounterRecordId: (id: string) => EncounterRecordI
 export declare const unsafeAsRecordEntryId: (id: string) => RecordEntryId;
 export declare const unsafeAsProtectedPayloadKeyVersion: (id: string) => ProtectedPayloadKeyVersion;
 export declare const parseSiteId: (value: unknown) => Result<SiteId, BrandedIdParseError>;
+export declare const parseSiteRouteId: (value: unknown) => Result<SiteRouteId, BrandedIdParseError>;
+export declare const parsePageId: (value: unknown) => Result<PageId, BrandedIdParseError>;
+export declare const parsePageSurfaceId: (value: unknown) => Result<PageSurfaceId, BrandedIdParseError>;
 export declare const parseOccurrenceId: (value: unknown) => Result<OccurrenceId, BrandedIdParseError>;
 export declare const parseTicketTypeId: (value: unknown) => Result<TicketTypeId, BrandedIdParseError>;
 export declare const parsePricingOptionId: (value: unknown) => Result<PricingOptionId, BrandedIdParseError>;

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

@@ -42,5 +42,6 @@ export * from "./slug";
 export * from "./string";
 export * from "./uuid";
 export * from "./stable-json";
+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";

package/dist/_dts/core/src/site-route-target.d.ts

@@ -0,0 +1,40 @@
+import { type BrandedIdParseError, type ContentEntryId, type PageId, type PageSurfaceId } from './branded';
+import { type Result } from './result';
+export declare const SITE_ROUTE_NODE_TYPES: readonly ["page", "content_entry", "page_surface"];
+export type SiteRouteNodeType = (typeof SITE_ROUTE_NODE_TYPES)[number];
+export type SiteRouteTarget = Readonly<{
+    kind: 'page';
+    pageId: PageId;
+}> | Readonly<{
+    kind: 'contentEntry';
+    entryId: ContentEntryId;
+}> | Readonly<{
+    kind: 'pageSurface';
+    surfaceId: PageSurfaceId;
+}>;
+export type SiteRouteTargetParseError = Readonly<{
+    kind: 'invalid-node-type';
+    nodeType: unknown;
+}> | Readonly<{
+    kind: 'unsupported-node-type';
+    nodeType: string;
+}> | Readonly<{
+    kind: 'invalid-page-id';
+    error: BrandedIdParseError;
+}> | Readonly<{
+    kind: 'invalid-content-entry-id';
+    error: BrandedIdParseError;
+}> | Readonly<{
+    kind: 'invalid-page-surface-id';
+    error: BrandedIdParseError;
+}>;
+export declare function parseSiteRouteTarget(input: Readonly<{
+    nodeType: unknown;
+    nodeId: unknown;
+}>): Result<SiteRouteTarget, SiteRouteTargetParseError>;
+export declare function siteRouteTargetNodeType(target: SiteRouteTarget): SiteRouteNodeType;
+export declare function foldSiteRouteTarget<TValue>(target: SiteRouteTarget, cases: Readonly<{
+    page: (pageId: PageId) => TValue;
+    contentEntry: (entryId: ContentEntryId) => TValue;
+    pageSurface: (surfaceId: PageSurfaceId) => TValue;
+}>): TValue;

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

@@ -11529,6 +11529,78 @@ export type Database = {
                     }
                 ];
             };
+            page_surfaces: {
+                Row: {
+                    created_at: string;
+                    created_by: string | null;
+                    deleted_at: string | null;
+                    id: string;
+                    metadata_json: Json;
+                    migration_source: Json;
+                    readiness_state: string;
+                    route_id: string | null;
+                    site_id: string;
+                    slug: string;
+                    subject_id: string;
+                    subject_type: string;
+                    template_key: string | null;
+                    title: string;
+                    updated_at: string;
+                    updated_by: string | null;
+                };
+                Insert: {
+                    created_at?: string;
+                    created_by?: string | null;
+                    deleted_at?: string | null;
+                    id?: string;
+                    metadata_json?: Json;
+                    migration_source?: Json;
+                    readiness_state?: string;
+                    route_id?: string | null;
+                    site_id: string;
+                    slug?: string;
+                    subject_id: string;
+                    subject_type: string;
+                    template_key?: string | null;
+                    title?: string;
+                    updated_at?: string;
+                    updated_by?: string | null;
+                };
+                Update: {
+                    created_at?: string;
+                    created_by?: string | null;
+                    deleted_at?: string | null;
+                    id?: string;
+                    metadata_json?: Json;
+                    migration_source?: Json;
+                    readiness_state?: string;
+                    route_id?: string | null;
+                    site_id?: string;
+                    slug?: string;
+                    subject_id?: string;
+                    subject_type?: string;
+                    template_key?: string | null;
+                    title?: string;
+                    updated_at?: string;
+                    updated_by?: string | null;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "page_surfaces_route_site_fk";
+                        columns: ["route_id", "site_id"];
+                        isOneToOne: false;
+                        referencedRelation: "site_routes";
+                        referencedColumns: ["id", "site_id"];
+                    },
+                    {
+                        foreignKeyName: "page_surfaces_site_id_fkey";
+                        columns: ["site_id"];
+                        isOneToOne: false;
+                        referencedRelation: "sites";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
             pages: {
                 Row: {
                     created_at: string;
@@ -12341,6 +12413,74 @@ export type Database = {
                 };
                 Relationships: [];
             };
+            published_runtime_cache_entries: {
+                Row: {
+                    cache_key: string;
+                    cached_at: string;
+                    created_at: string;
+                    endpoint: string;
+                    fresh_until: string;
+                    last_live_at: string;
+                    normalized_params: Json;
+                    payload: Json;
+                    payload_hash: string;
+                    payload_schema_version: number;
+                    site_id: string | null;
+                    source_deployment: string | null;
+                    stage: string;
+                    stale_until: string;
+                    tags: string[];
+                    updated_at: string;
+                    write_reason: string | null;
+                };
+                Insert: {
+                    cache_key: string;
+                    cached_at?: string;
+                    created_at?: string;
+                    endpoint: string;
+                    fresh_until: string;
+                    last_live_at?: string;
+                    normalized_params: Json;
+                    payload: Json;
+                    payload_hash: string;
+                    payload_schema_version?: number;
+                    site_id?: string | null;
+                    source_deployment?: string | null;
+                    stage?: string;
+                    stale_until: string;
+                    tags?: string[];
+                    updated_at?: string;
+                    write_reason?: string | null;
+                };
+                Update: {
+                    cache_key?: string;
+                    cached_at?: string;
+                    created_at?: string;
+                    endpoint?: string;
+                    fresh_until?: string;
+                    last_live_at?: string;
+                    normalized_params?: Json;
+                    payload?: Json;
+                    payload_hash?: string;
+                    payload_schema_version?: number;
+                    site_id?: string | null;
+                    source_deployment?: string | null;
+                    stage?: string;
+                    stale_until?: string;
+                    tags?: string[];
+                    updated_at?: string;
+                    write_reason?: string | null;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "published_runtime_cache_entries_site_id_fkey";
+                        columns: ["site_id"];
+                        isOneToOne: false;
+                        referencedRelation: "sites";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
             redirect_exchange_codes: {
                 Row: {
                     code_hash: string;
@@ -16780,6 +16920,23 @@ export type Database = {
                     order_id: string;
                 }[];
             };
+            read_published_runtime_cache_entry: {
+                Args: {
+                    p_cache_key: string;
+                    p_payload_schema_version?: number;
+                };
+                Returns: {
+                    cache_key: string;
+                    cached_at: string;
+                    endpoint: string;
+                    fresh_until: string;
+                    payload: Json;
+                    payload_hash: string;
+                    payload_schema_version: number;
+                    site_id: string;
+                    stale_until: string;
+                }[];
+            };
             redeem_pass_credits: {
                 Args: {
                     credits_amount?: number;
@@ -17184,7 +17341,7 @@ export type Database = {
             newsletter_sender_entity_type: "individual" | "company" | "llp" | "charity" | "other";
             newsletter_subscriber_status: "pending_confirmation" | "active" | "unsubscribed";
             plan_price_interval: "month" | "year";
-            route_node_type: "page" | "content_entry";
+            route_node_type: "page" | "content_entry" | "page_surface";
             route_status: "draft" | "published" | "scheduled" | "archived";
             site_deployment_mode: "managed" | "headless_cms" | "headless_full";
             site_purpose: "GENERATE_LEADS" | "SHOWCASE_PORTFOLIO" | "SELL_PRODUCTS" | "SELL_TICKETS" | "EVENT_INFO" | "BLOGGING" | "COMMUNITY" | "OTHER";
@@ -17926,7 +18083,7 @@ export declare const Constants: {
             readonly newsletter_sender_entity_type: readonly ["individual", "company", "llp", "charity", "other"];
             readonly newsletter_subscriber_status: readonly ["pending_confirmation", "active", "unsubscribed"];
             readonly plan_price_interval: readonly ["month", "year"];
-            readonly route_node_type: readonly ["page", "content_entry"];
+            readonly route_node_type: readonly ["page", "content_entry", "page_surface"];
             readonly route_status: readonly ["draft", "published", "scheduled", "archived"];
             readonly site_deployment_mode: readonly ["managed", "headless_cms", "headless_full"];
             readonly site_purpose: readonly ["GENERATE_LEADS", "SHOWCASE_PORTFOLIO", "SELL_PRODUCTS", "SELL_TICKETS", "EVENT_INFO", "BLOGGING", "COMMUNITY", "OTHER"];

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

@@ -429,9 +429,13 @@ export declare const FILE_SIZE_LIMITS: {
 export declare const DEFAULT_PRIVATE_FILE_SIGNED_URL_EXPIRY_SECONDS: PositiveSeconds;
 export declare const MAX_SAFE_DOWNLOAD_FILENAME_LENGTH = 180;
 export declare function asPositiveByteCount(value: number): Result<PositiveByteCount, 'not-positive-byte-count'>;
+export declare const parsePositiveByteCount: typeof asPositiveByteCount;
 export declare function asPositiveSeconds(value: number): Result<PositiveSeconds, 'not-positive-seconds'>;
+export declare const parsePositiveSeconds: typeof asPositiveSeconds;
 export declare function asFileChecksumSha256(value: string): Result<FileChecksumSha256, FileChecksumSha256Error>;
+export declare const parseFileChecksumSha256: typeof asFileChecksumSha256;
 export declare function asSafeDownloadFilename(value: string): Result<SafeDownloadFilename, SafeDownloadFilenameError>;
+export declare const parseSafeDownloadFilename: typeof asSafeDownloadFilename;
 export declare function deriveUploadPolicy(actor: FileActor, intent: UploadIntent): Result<UploadPolicy, UploadPolicyError>;
 export declare function classifyKnownMimeType(mimeType: string | DeclaredMimeType | DetectedMimeType | undefined | null): Result<FileKind, MimeTypeClassificationError>;
 export declare function isMimeTypeAllowedForPolicy(mimeType: string | DeclaredMimeType | DetectedMimeType | undefined | null, policy: UploadPolicy): boolean;