@riverbankcms/sdk 0.136.0 → 0.138.0

package/dist/_dts/api/src/schemas/sdk-entries.d.ts

@@ -0,0 +1,128 @@
+import { z } from 'zod';
+import type { RequestOutput } from './support';
+/**
+ * Request schemas for the SDK entry read endpoints.
+ *
+ * This module is the single authority for what those endpoints accept. See
+ * `.project/plans/tier2-step5-schema-entrypoint/design.md` for why both sides of
+ * a schema are named rather than left to `z.infer`.
+ *
+ * Covered endpoints: `sdkListEntries`, `sdkPullEntries`, `sdkPullEntriesByType`,
+ * `sdkPullEntriesAll`.
+ *
+ * This is the second family to use the *defaulted* half of the modelled-input
+ * rule, after newsletter list memberships. Its pagination both coerces and
+ * defaults, so neither side of the schema is the caller's type: `z.input` is
+ * `unknown` (coercion accepts anything) and `z.output` makes `page`/`limit`
+ * required, which would force every caller to send values the endpoints
+ * deliberately fill in. So the client type is modelled below and checked against
+ * the schemas instead, exactly as `newsletter-memberships.ts` does.
+ *
+ * `sdkUpsertEntry` shares this route tree but is deliberately left inline: its
+ * body composes `createSdkEntrySlotBlocksInputSchema` from
+ * `@riverbankcms/content-model` with the dashboard's own `jsonObjectSchema`, so
+ * moving it is a dependency decision rather than a mechanical migration.
+ */
+/**
+ * `sdkPullEntries` and `sdkPullEntriesAll`.
+ *
+ * Both routes declared this same object; the site id is handed to the services
+ * as a raw string, so nothing is branded and `brandedUuidParam` is not used.
+ */
+export declare const sdkSiteScopeParamsSchema: z.ZodObject<{
+    siteId: z.ZodString;
+}, z.core.$strip>;
+export type SdkSiteScopeParamsOutput = RequestOutput<typeof sdkSiteScopeParamsSchema>;
+/** `sdkPullEntriesByType`. The content type arrives as the `{type}` path segment. */
+export declare const sdkPullEntriesByTypeParamsSchema: z.ZodObject<{
+    siteId: z.ZodString;
+    type: z.ZodString;
+}, z.core.$strip>;
+export type SdkPullEntriesByTypeParamsOutput = RequestOutput<typeof sdkPullEntriesByTypeParamsSchema>;
+/**
+ * `sdkListEntries`. The same shape as the pull-by-type params under a different
+ * segment name (`{contentType}`), which is why the two are not shared.
+ */
+export declare const sdkListEntriesParamsSchema: z.ZodObject<{
+    siteId: z.ZodString;
+    contentType: z.ZodString;
+}, z.core.$strip>;
+export type SdkListEntriesParamsOutput = RequestOutput<typeof sdkListEntriesParamsSchema>;
+/**
+ * The client-facing pagination contract shared by all three listing endpoints —
+ * **modelled, not derived**, for the reasons in this module's header and the
+ * design doc's "Which side each consumer gets".
+ *
+ * One model backs three endpoints because the accepted shape is identical; only
+ * the *default* differs (`sdkListEntries` pages at 20, the two pull endpoints at
+ * 100), and a default is a runtime fact that never reaches the wire type. The
+ * per-endpoint schemas below are the authority for those numbers.
+ */
+export type SdkEntryPaginationQueryInput = {
+    page?: number;
+    limit?: number;
+};
+/**
+ * `sdkPullEntries`.
+ *
+ * The route parses the search params merged with its already-parsed path params
+ * (`includeParamsInInput` defaults to true), which is why `siteId` is repeated
+ * in the query schemas here: the schema sees it, and the endpoint's client
+ * contract carries it alongside the pagination fields.
+ */
+export declare const sdkPullEntriesQuerySchema: z.ZodObject<{
+    siteId: z.ZodString;
+    page: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+/** What the route receives: pagination is always resolved to a number. */
+export type SdkPullEntriesQueryOutput = RequestOutput<typeof sdkPullEntriesQuerySchema>;
+/**
+ * What the client machinery actually puts on the URL for `sdkPullEntries`.
+ *
+ * There is no hand-rolled encoder for any of these endpoints the way `admin.ts`
+ * has one for `adminDeleteUser`; the encoding is `apiCallParams`' generic
+ * `PathParams & QueryToStringParams`, driven by the published contract. So this
+ * is the shape a caller of `apiCall({ endpoint: 'sdkPullEntries' })` must
+ * supply, the typetest pins it against that machinery, and a golden test parses
+ * exactly this shape. Together they are the link a derivation would otherwise
+ * have made: contract → encoded params → accepted by the schema.
+ */
+export type SdkPullEntriesQueryWire = {
+    siteId: string;
+    page?: string;
+    limit?: string;
+};
+/** `sdkPullEntriesByType`. Same pagination, plus the `{type}` path segment. */
+export declare const sdkPullEntriesByTypeQuerySchema: z.ZodObject<{
+    siteId: z.ZodString;
+    type: z.ZodString;
+    page: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+export type SdkPullEntriesByTypeQueryOutput = RequestOutput<typeof sdkPullEntriesByTypeQuerySchema>;
+export type SdkPullEntriesByTypeQueryWire = {
+    siteId: string;
+    type: string;
+    page?: string;
+    limit?: string;
+};
+/**
+ * `sdkListEntries`.
+ *
+ * The management listing endpoint rather than a pull, so its page size defaults
+ * to 20 instead of 100. The cap is the same 100.
+ */
+export declare const sdkListEntriesQuerySchema: z.ZodObject<{
+    siteId: z.ZodString;
+    contentType: z.ZodString;
+    page: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+export type SdkListEntriesQueryOutput = RequestOutput<typeof sdkListEntriesQuerySchema>;
+export type SdkListEntriesQueryWire = {
+    siteId: string;
+    contentType: string;
+    page?: string;
+    limit?: string;
+};

package/dist/_dts/api/src/schemas/site-api-keys.d.ts

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import { type RequestInput, type RequestOutput } from './support';
+/**
+ * Request schemas for the site API-key endpoints.
+ *
+ * This module is the single authority for what those endpoints accept. The
+ * client-facing contract in `APIEndpoints` is derived from `z.input`; the route
+ * handler and its service receive `z.output`. Keeping both sides named here is
+ * the whole point of the subpath — a `.default()` or a branded transform makes
+ * them genuinely different types, and a plain `z.infer` (or a
+ * `z.ZodType<Body>` annotation on the schema) silently reports only one of them.
+ *
+ * Covered endpoints: `listSiteApiKeys`, `createSiteApiKey`, `revokeSiteApiKey`,
+ * `getSiteApiKeyAccessLogs`, `listSitePreviewKeys`, `createSitePreviewKey`,
+ * `listManagementKeys`, `createManagementKey`, `revokeManagementKey` — the whole
+ * domain. The management trio arrived in step 6's fourth batch, after the pilot
+ * had shipped the family half-migrated on purpose; see
+ * `.project/plans/tier2-step5-schema-entrypoint/design.md`.
+ */
+/**
+ * Site-scoped routes that pass the raw `siteId` through to their service.
+ *
+ * Shared by `listSiteApiKeys`, `createSiteApiKey`, `getSiteApiKeyAccessLogs` and
+ * the three management-key endpoints.
+ *
+ * The management route declared this same object separately and annotated it
+ * `z.ZodType<APIEndpoints['listManagementKeys']['query']>`, which read as if
+ * `siteId` were a query contract. It is not: `/sites/{siteId}/api-keys/management`
+ * carries it in the path, `apiCallParams`' `PathParams` owns it on the client
+ * side, and those endpoints declare no query at all. It is a path parameter that
+ * happened to be typed through the query slot, so it lives here with the other
+ * params.
+ */
+export declare const siteApiKeyScopeParamsSchema: z.ZodObject<{
+    siteId: z.ZodString;
+}, z.core.$strip>;
+/** `revokeSiteApiKey` — both ids are branded before the service sees them. */
+export declare const revokeSiteApiKeyParamsSchema: z.ZodObject<{
+    siteId: z.ZodType<import("../../../core/src/index").SiteId, string, z.core.$ZodTypeInternals<import("../../../core/src/index").SiteId, string>>;
+    keyId: z.ZodType<import("../../../core/src/index").ApiKeyId, string, z.core.$ZodTypeInternals<import("../../../core/src/index").ApiKeyId, string>>;
+}, z.core.$strip>;
+/** `listSitePreviewKeys` / `createSitePreviewKey`. */
+export declare const sitePreviewKeyParamsSchema: z.ZodObject<{
+    siteId: z.ZodType<import("../../../core/src/index").SiteId, string, z.core.$ZodTypeInternals<import("../../../core/src/index").SiteId, string>>;
+}, z.core.$strip>;
+/**
+ * `createSiteApiKey`.
+ *
+ * `environment` is the divergence this pilot exists to demonstrate: senders may
+ * omit it, so the wire contract has it optional, while the route always gets a
+ * concrete `'live' | 'test'`.
+ */
+export declare const createSiteApiKeyBodySchema: z.ZodObject<{
+    name: z.ZodString;
+    environment: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        test: "test";
+        live: "live";
+    }>>>;
+}, z.core.$strip>;
+/** What a client sends: `environment` may be omitted. */
+export type CreateSiteApiKeyBodyInput = RequestInput<typeof createSiteApiKeyBodySchema>;
+/** What the route receives: `environment` is always present. */
+export type CreateSiteApiKeyBodyOutput = RequestOutput<typeof createSiteApiKeyBodySchema>;
+/** `createSitePreviewKey`. Input and output agree here; `.trim()` only changes the value. */
+export declare const createSitePreviewKeyBodySchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+export type CreateSitePreviewKeyBodyInput = RequestInput<typeof createSitePreviewKeyBodySchema>;
+export type CreateSitePreviewKeyBodyOutput = RequestOutput<typeof createSitePreviewKeyBodySchema>;
+/**
+ * `createManagementKey`.
+ *
+ * Every field is optional and nothing defaults or transforms, so both sides of
+ * this schema are the same type. It is here for the same reason the rest of the
+ * domain is: the route annotated it `z.ZodType<CreateManagementKeyRequest>`,
+ * which pins the output only and would have hidden a divergence had one been
+ * introduced later.
+ *
+ * The normalisation the endpoint documents happens in the service, not here:
+ * an omitted `accessMode` becomes `'write'` (preserving the prior all-access
+ * behaviour) and an omitted or null `expiresAt` means the key never expires.
+ * Neither is a schema default, so neither shows up in the parsed value.
+ */
+export declare const createManagementKeyBodySchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    accessMode: z.ZodOptional<z.ZodEnum<{
+        write: "write";
+        read: "read";
+    }>>;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type CreateManagementKeyBodyInput = RequestInput<typeof createManagementKeyBodySchema>;
+export type CreateManagementKeyBodyOutput = RequestOutput<typeof createManagementKeyBodySchema>;
+/** `revokeManagementKey`. The key to revoke travels in the body, not the path. */
+export declare const revokeManagementKeyBodySchema: z.ZodObject<{
+    keyId: z.ZodString;
+}, z.core.$strip>;
+export type RevokeManagementKeyBodyInput = RequestInput<typeof revokeManagementKeyBodySchema>;
+export type RevokeManagementKeyBodyOutput = RequestOutput<typeof revokeManagementKeyBodySchema>;
+/**
+ * `getSiteApiKeyAccessLogs`.
+ *
+ * Query values always reach the server as strings, so these fields coerce. That
+ * makes `z.input` here `unknown`-ish and useless as a contract, which is why the
+ * client-facing query type stays `z.output`-shaped: `apiCallParams` owns the
+ * string encoding on the way out. Only the parsed side is exported.
+ */
+export declare const siteApiKeyAccessLogsQuerySchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type SiteApiKeyAccessLogsQueryOutput = RequestOutput<typeof siteApiKeyAccessLogsQuerySchema>;

package/dist/_dts/api/src/schemas/support.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+/**
+ * Shared primitives for the schema-bearing request entrypoints under
+ * `@riverbankcms/api/schemas/*`.
+ *
+ * This module is deliberately tiny and deliberately isolated: nothing under
+ * `src/schemas/` may be reachable from `request.ts`, `common/index.ts`, or any
+ * other lightweight/browser entrypoint, so that attaching Zod schemas to
+ * endpoints never grows the shared client bundle. `scripts/check-entrypoint-graph.cjs`
+ * enforces that boundary.
+ */
+/**
+ * The shape a caller must put on the wire.
+ *
+ * Use this — never `z.infer` — when deriving the client-facing body contract in
+ * `APIEndpoints`. Defaults, coercion and transforms all make `z.input` wider
+ * (or more optional) than the parsed value the route receives.
+ */
+export type RequestInput<TSchema extends z.ZodType> = z.input<TSchema>;
+/**
+ * The parsed value a route handler and its service receive.
+ *
+ * This is what `z.infer` already means; the alias exists so a schema module can
+ * name both sides symmetrically and make the divergence visible at a glance.
+ */
+export type RequestOutput<TSchema extends z.ZodType> = z.output<TSchema>;
+/**
+ * A path parameter that arrives as a UUID string and is handed to the route as
+ * a branded id.
+ *
+ * The checks and messages match what the dashboard routes already declared
+ * inline (`z.string().uuid().transform(brand)`), so moving a route onto this
+ * helper cannot change a 400 body.
+ */
+export declare function brandedUuidParam<TBrand extends string>(brand: (value: string) => TBrand): z.ZodType<TBrand, string>;

package/dist/_dts/api/src/sdk-event-booking-offer.d.ts

@@ -0,0 +1,14 @@
+import type { SdkEventBookingOffer } from './sdkContracts';
+export type SdkEventBookingOfferIssue = Readonly<{
+    kind: 'invalid_booking_offer';
+    path: readonly string[];
+    message: string;
+}>;
+export type SdkEventBookingOfferClassification = Readonly<{
+    ok: true;
+    bookingOffer: SdkEventBookingOffer | undefined;
+}> | Readonly<{
+    ok: false;
+    issues: readonly SdkEventBookingOfferIssue[];
+}>;
+export declare function classifySdkEventBookingOffer(input: unknown): SdkEventBookingOfferClassification;

package/dist/_dts/api/src/sdk-event-payment-terms.d.ts

@@ -1,16 +1,4 @@
-import type { BookingCollectionOptionKind, BookingPaymentTermsConfig } from './bookingConfig';
-export type SdkEventPaymentTerms = BookingPaymentTermsConfig;
-export type SdkEventPaymentTermsInput = BookingPaymentTermsConfig;
-export type SdkEventSupportedPaymentOptionKind = BookingCollectionOptionKind;
-export type SdkEventPaymentTermsIssue = Readonly<{
-    path: readonly string[];
-    message: string;
-}>;
-export type SdkEventPaymentTermsClassification = Readonly<{
-    ok: true;
-    paymentTerms?: SdkEventPaymentTerms;
-}> | Readonly<{
-    ok: false;
-    issues: readonly SdkEventPaymentTermsIssue[];
-}>;
-export declare function classifySdkEventPaymentTerms(rawInput: unknown): SdkEventPaymentTermsClassification;
+import type { EventBookingOfferIntent } from '@riverbankcms/site-commands';
+export type SdkEventPaymentTerms = EventBookingOfferIntent['paymentTerms'];
+export type SdkEventPaymentTermsInput = SdkEventPaymentTerms;
+export type SdkEventSupportedPaymentOptionKind = SdkEventPaymentTerms['allowedOptions'][number]['kind'];

package/dist/_dts/api/src/sdk-event-upsert.d.ts

@@ -1,7 +1,8 @@
-import type { SdkEntryUpsertSlotBlock, SdkEventContentInput, SdkPullEvent, SdkPullEventRun, SdkEventUpsertPaymentTermsInput, SdkEventUpsertPricingInput, SdkEventUpsertScheduleInput } from './sdkContracts';
+import type { SdkEntryUpsertSlotBlock, SdkEventBookingOffer, SdkEventContentInput, SdkPullEvent, SdkPullEventRun, SdkEventUpsertScheduleInput } from './sdkContracts';
 import { type BookingTimeZone, type UtcIsoDateTimeString } from '../../core/src/index';
-import { type SdkEventPaymentTerms, type SdkEventPaymentTermsIssue } from './sdk-event-payment-terms';
-import { type SdkEventPricing, type SdkEventPricingIssue } from './sdk-event-pricing';
+export { classifySdkEventBookingOffer } from './sdk-event-booking-offer';
+export type { SdkEventBookingOfferClassification, SdkEventBookingOfferIssue, } from './sdk-event-booking-offer';
+import type { SdkEventBookingOfferIssue } from './sdk-event-booking-offer';
 import { type ClassifySdkEventScheduleOptions, type SdkEventCanonicalSchedule } from './sdk-event-schedule';
 import { z } from 'zod';
 export declare const sdkEventOccurrenceInputSchema: z.ZodObject<{
@@ -33,8 +34,8 @@ export declare const sdkEventUpsertOptionalFieldSchemas: {
         performance: "performance";
     }>>;
     readonly bookingScope: z.ZodOptional<z.ZodEnum<{
-        whole_series: "whole_series";
         single_occurrence: "single_occurrence";
+        whole_series: "whole_series";
     }>>;
     readonly occurrences: z.ZodOptional<z.ZodArray<z.ZodObject<{
         startsAt: z.ZodString;
@@ -86,8 +87,7 @@ type SdkEventRunUpsertCommon = Readonly<{
     status?: SdkPullEventRun['status'];
     visibility?: SdkPullEventRun['visibility'];
     capacity?: number | null;
-    pricing?: SdkEventUpsertPricingInput;
-    paymentTerms?: SdkEventUpsertPaymentTermsInput;
+    bookingOffer?: SdkEventBookingOffer;
     venueRef?: string | null;
     categoryRef?: string | null;
     formRef?: string | null;
@@ -118,17 +118,14 @@ export type SdkEventUpsertBody = Readonly<{
     blocks?: Record<string, SdkEntryUpsertSlotBlock[]>;
     runs: readonly [SdkEventRunUpsertBody, ...SdkEventRunUpsertBody[]];
 }>;
-export type ValidatedSdkEventRunUpsertInput = Omit<SdkEventRunUpsertCommon, 'pricing' | 'paymentTerms'> & Readonly<{
+export type ValidatedSdkEventRunUpsertInput = SdkEventRunUpsertBody & Readonly<{
     timingAuthority: SdkEventTimingAuthority;
-    pricing?: SdkEventPricing;
-    paymentTerms?: SdkEventPaymentTerms;
 }>;
-export type SdkEventRunUpsertParseInput = Omit<SdkEventRunUpsertCommon, 'pricing' | 'paymentTerms'> & Readonly<{
+export type SdkEventRunUpsertParseInput = Omit<SdkEventRunUpsertCommon, 'bookingOffer'> & Readonly<{
     schedule?: unknown;
     occurrences?: readonly SdkEventOccurrenceInput[];
     bookingScope?: SdkEventBookingScope;
-    pricing?: unknown;
-    paymentTerms?: unknown;
+    bookingOffer?: unknown;
 }>;
 /** Legacy flat-series parser input retained for internal command adapters. */
 export type SdkEventUpsertParseInput = Omit<SdkEventRunUpsertParseInput, 'identifier' | 'eventRef'> & Readonly<{
@@ -155,16 +152,10 @@ export type SdkEventUpsertValidationIssue = Readonly<{
     issue: SdkEventTimingIssue;
 }> | Readonly<{
     runIndex: number;
-    source: 'pricing';
-    path: readonly string[];
-    message: string;
-    issue: SdkEventPricingIssue;
-}> | Readonly<{
-    runIndex: number;
-    source: 'paymentTerms';
+    source: 'bookingOffer';
     path: readonly string[];
     message: string;
-    issue: SdkEventPaymentTermsIssue;
+    issue: SdkEventBookingOfferIssue;
 }>;
 export type ValidatedSdkEventUpsertInput = Omit<SdkEventUpsertBody, 'runs'> & Readonly<{
     runs: readonly [
@@ -194,4 +185,3 @@ export declare function parseSdkEventUpsertInput(input: Omit<SdkEventUpsertBody,
     ];
 }>, options?: ParseSdkEventUpsertInputOptions): SdkEventUpsertValidationResult;
 export declare function toSdkEventUpsertBody(input: ValidatedSdkEventUpsertInput): SdkEventUpsertBody;
-export {};

package/dist/_dts/api/src/sdkContracts.d.ts

@@ -1,11 +1,12 @@
 import type { BlockContentSource, BlockContentSourceKind, FieldDefinition, FieldDefinitionInput, SdkCustomBlock, SdkCustomBlockInput, Theme } from '../../blocks/src/index';
 import type { ContentTypeSchema } from '../../content-model/src/index';
 import type { FooterCompositionV1, RichTextDoc } from '../../core/src/index';
-export type { SdkBlockAppearanceChoice, SdkBlockAppearanceOutcome } from './sdkBlockUpsertContracts';
+export type { SdkBlockAppearanceChoice, SdkBlockAppearanceOutcome, } from './sdkBlockUpsertContracts';
 import type { LinkPayload } from './navigation/types';
 import type { JsonValue } from './shared-contracts';
-import type { SdkEventPricing, SdkEventPricingInput } from './sdk-event-pricing';
-import type { SdkEventPaymentTerms, SdkEventPaymentTermsInput } from './sdk-event-payment-terms';
+import type { EventBookingOfferIntent } from '@riverbankcms/site-commands';
+import type { ManagementMediaAsset } from './sdkMediaContracts';
+export type { ManagementMediaAsset, SdkMediaDeleteApplyResponse, SdkMediaDeletePreviewResponse, SdkMediaDownloadResponse, SdkMediaListResponse, } from './sdkMediaContracts';
 import type { SdkPullEventOccurrence } from './sdk-event-schedule';
 import type { SiteCommandApplicationResult } from '@riverbankcms/site-commands';
 import type { EventPreset } from '../../core/src/index';
@@ -15,7 +16,7 @@ export type { SdkCatalogButtonRole, SdkCatalogButtonStyleControl, } from './sdkT
 import type { SdkPullEventCategory } from './sdkEventCategoryContracts';
 import type { SdkPullSettings } from './sdkSettingsContracts';
 export type { SdkConfigureBookingVerticalRequest, SdkConfigureBookingVerticalResponse, SdkPullSettingsWarning, } from './sdkBookingVerticalContracts';
-export type { SdkPullSettings, SdkPullSettingsResponse } from './sdkSettingsContracts';
+export type { SdkPullSettings, SdkPullSettingsResponse, } from './sdkSettingsContracts';
 export type { SdkPullEventCategory } from './sdkEventCategoryContracts';
 import type { SdkManagementEvent, SdkManagementEventOccurrence, SdkManagementEventRun } from './sdkManagedEventContracts';
 export type { SdkEventOccurrenceDeletionEligibility, SdkEventOccurrenceProvenance, SdkManagementEvent, SdkManagementEventOccurrence, SdkManagementEventRun, } from './sdkManagedEventContracts';
@@ -277,21 +278,6 @@ export interface SdkBackfillIdentifiersResult {
     };
     entries: SdkBackfillEntryResult;
 }
-export interface ManagementMediaAsset {
-    id: string;
-    siteId: string;
-    identifier: string;
-    storageBucket: string;
-    storagePath: string;
-    filename: string;
-    mimeType: string;
-    width: number | null;
-    height: number | null;
-    bytes: number | null;
-    checksumSha256: string | null;
-    createdAt: string;
-    updatedAt: string;
-}
 export interface MediaResolveResponse {
     assets: ManagementMediaAsset[];
     missingIdentifiers: string[];
@@ -842,8 +828,7 @@ export interface SdkPullEventRun {
     bookingScope: 'single_occurrence' | 'whole_series';
     occurrences: readonly SdkPullEventOccurrence[];
     capacity: number | null;
-    pricing: SdkEventPricing;
-    paymentTerms?: SdkEventPaymentTerms;
+    bookingOffer: SdkEventBookingOffer;
     venueRef: string | null;
     categoryRef: string | null;
     formRef: string | null;
@@ -888,8 +873,8 @@ export type SdkEventStartDurationScheduleInput = {
     endsAt?: never;
 };
 export type SdkEventUpsertScheduleInput = SdkEventCanonicalScheduleInput | SdkEventStartEndScheduleInput | SdkEventStartDurationScheduleInput;
-export type SdkEventUpsertPricingInput = SdkEventPricingInput;
-export type SdkEventUpsertPaymentTermsInput = SdkEventPaymentTermsInput;
+export type SdkEventBookingOffer = EventBookingOfferIntent;
+export type SdkEventBookingOfferInput = SdkEventBookingOffer;
 export interface SdkPullEventsResponse {
     events: SdkPullEvent[];
     eventRuns: SdkPullEventRun[];

package/dist/_dts/api/src/sdkManagedEventContracts.d.ts

@@ -20,6 +20,22 @@ export type SdkEventOccurrenceDeletionEligibility = {
 } | {
     kind: 'blocked_completed_occurrence';
 };
+/**
+ * One event date as the management API reports it.
+ *
+ * Two different place counts live here on purpose, because two different
+ * questions get asked about the same roster (see `attendanceCounts.ts` in
+ * `@riverbankcms/bookings/events`, which defines both):
+ *
+ * - `confirmedPlaces` is what a room holds and what `capacity` is compared
+ *   against. Only a confirmed booking holds a place.
+ * - `registrations` is the wider figure the delete gate needs, because a
+ *   waitlisted or pending row is still someone you would strand by deleting
+ *   the date underneath them.
+ *
+ * They are usually equal, and they diverge exactly when a date has waitlisted
+ * or pending rows on it.
+ */
 export interface SdkManagementEventOccurrence {
     id: OccurrenceId;
     seriesId: EventSeriesId;
@@ -30,6 +46,27 @@ export interface SdkManagementEventOccurrence {
     provenance: SdkEventOccurrenceProvenance;
     capacityOverride: number | null;
     capacity: number | null;
+    /**
+     * Places held by confirmed bookings: the sum of the confirmed rows'
+     * ticket-line quantities. The figure to compare against `capacity`, and the
+     * same number the dashboard's date list shows.
+     *
+     * Optional only for the length of one release. A published CLI can be
+     * pointed at a dashboard that predates this field, and a required field
+     * would fail the whole response parse rather than one column, so clients
+     * fall back to `registrations` when it is absent. Make it required — here
+     * and in `sdkOccurrenceResponseSchemas.ts` — once every dashboard carrying
+     * commit e22c7700f5 is live, and drop the fallbacks with it.
+     */
+    confirmedPlaces?: number;
+    /**
+     * Places held by every row that is not cancelled, so waitlisted and pending
+     * rows are counted too. This is the figure `deletionEligibility` is decided
+     * on: a date with anyone still attached to it cannot be deleted.
+     *
+     * The name is kept for compatibility with published CLI output. For
+     * "how full is this date", read `confirmedPlaces`.
+     */
     registrations: number;
     deletionEligibility: SdkEventOccurrenceDeletionEligibility;
 }

package/dist/_dts/api/src/sdkMediaContracts.d.ts

@@ -0,0 +1,40 @@
+import type { MediaDeleteResponse } from './media';
+import type { MediaUsageCheckItem } from './shared-contracts';
+export interface ManagementMediaAsset {
+    id: string;
+    siteId: string;
+    identifier: string;
+    storageBucket: string;
+    storagePath: string;
+    filename: string;
+    mimeType: string;
+    width: number | null;
+    height: number | null;
+    bytes: number | null;
+    checksumSha256: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SdkMediaListResponse {
+    items: ManagementMediaAsset[];
+    total: number;
+    limit: number;
+    offset: number;
+    nextOffset?: number;
+}
+export interface SdkMediaDownloadResponse {
+    transferUrl: string;
+    asset: ManagementMediaAsset;
+}
+export type SdkMediaDeletePreviewResponse = {
+    kind: 'missing';
+} | {
+    kind: 'in_use';
+    usage: MediaUsageCheckItem;
+} | {
+    kind: 'deletable';
+    assetId: string;
+};
+export type SdkMediaDeleteApplyResponse = Exclude<SdkMediaDeletePreviewResponse, {
+    kind: 'deletable';
+}> | MediaDeleteResponse;

package/dist/_dts/api/src/sdkMediaEndpointDefinitions.d.ts

@@ -0,0 +1,66 @@
+/** SDK media lookup, listing, deletion and upload endpoints (management-key authenticated). */
+export declare const SDK_MEDIA_ENDPOINT_DEFINITIONS: {
+    sdkMediaExists: {
+        path: "/sdk/{siteId}/media/exists";
+        method: "POST";
+        errors: "validation:invalid_input"[];
+        auth: "service";
+        responseKind: "json";
+    };
+    sdkMediaFindByChecksum: {
+        path: "/sdk/{siteId}/media/find-by-checksum";
+        method: "POST";
+        errors: "server:internal_error"[];
+        auth: "service";
+        responseKind: "json";
+    };
+    sdkMediaResolve: {
+        path: "/sdk/{siteId}/media/resolve";
+        method: "POST";
+        errors: "server:internal_error"[];
+        auth: "service";
+        responseKind: "json";
+    };
+    sdkMediaList: {
+        path: "/sdk/{siteId}/media";
+        method: "GET";
+        auth: "service";
+        errors: never[];
+        responseKind: "json";
+    };
+    sdkMediaDownload: {
+        path: "/sdk/{siteId}/media/{identifier}/download";
+        method: "GET";
+        auth: "service";
+        errors: never[];
+        responseKind: "json";
+    };
+    sdkMediaDeletePreview: {
+        path: "/sdk/{siteId}/media/{identifier}/delete-preview";
+        method: "POST";
+        auth: "service";
+        errors: never[];
+        responseKind: "json";
+    };
+    sdkMediaDeleteApply: {
+        path: "/sdk/{siteId}/media/{identifier}";
+        method: "DELETE";
+        auth: "service";
+        errors: never[];
+        responseKind: "json";
+    };
+    sdkMediaUploadUrl: {
+        path: "/sdk/{siteId}/media/upload-url";
+        method: "POST";
+        errors: ("validation:invalid_input" | "validation:payload_too_large" | "resource:not_found" | "resource:conflict" | "billing:plan_limit_exceeded" | "server:internal_error")[];
+        auth: "service";
+        responseKind: "json";
+    };
+    sdkMediaUploadFinalize: {
+        path: "/sdk/{siteId}/media/upload";
+        method: "POST";
+        errors: ("validation:invalid_input" | "validation:payload_too_large" | "resource:not_found" | "resource:conflict" | "billing:plan_limit_exceeded" | "server:internal_error")[];
+        auth: "service";
+        responseKind: "json";
+    };
+};