@riverbankcms/sdk 0.136.0 → 0.138.0

package/dist/_dts/api/src/publicExperience/eventEndpoints.d.ts

@@ -5,13 +5,23 @@
  */
 import type { APIEndpoint } from '../apiEndpointTypes';
 import type { EventRegistrationOptionsRequest, EventRegistrationOptionsResponse } from '../../../blocks/src/system/blocks/event-registration';
-import type { BookingConsent, PublicEventBookingAvailability, PublicEventPricing } from '../../../core/src/index';
-import type { PublicEventDestination } from '../event-listing-destination';
-import type { BookingPaymentTermsConfig, BookingPricing, DirectCheckoutCollectionOptionKind, EventAttendanceMode, EventDeliveryMode, EventPricingMode, PublicEventEligibilityTicketTypeRecord, PublicEventTicketTypeRecord } from '../bookingConfig';
-import type { EventPreset } from '../../../core/src/index';
-import type { PublicTeamMemberSummary } from '../teamMembers';
-import type { EventTicketLineSummaryResponse, EventTicketSelectionRequest, PublicEventLoaderParams, PublicEventRecurrence, PublicEventScheduleScope } from './sharedTypes';
+import type { PublicWaitlistClaimResponse } from '../../../commerce/src/index';
+import type { DirectCheckoutCollectionOptionKind, EventAttendanceMode } from '../bookingConfig';
+import type { EventTicketLineSummaryResponse, EventTicketSelectionRequest, PublicEventLoaderParams } from './sharedTypes';
+/**
+ * The canonical public Event record.
+ *
+ * Declared once in `@riverbankcms/blocks` (the lowest package that owns every
+ * constituent shape) and surfaced here as the wire contract. Nothing restates
+ * it: the dashboard projection and every block consumer import these names.
+ */
+export type { PublicEvent, PublicEventBase, PublicWholeSeriesRun, PublicWholeSeriesRunLifecycle, PublicWholeSeriesRunVisibility, PublicRunSession, } from '../../../blocks/src/system/blocks/events/shared/types';
+import type { PublicEvent } from '../../../blocks/src/system/blocks/events/shared/types';
+import type { CalendarWindowRequest, CalendarWindowPage } from '../../../blocks/src/contracts/index';
 export type PublicEventAPIEndpoints = {
+    listPublicEventCalendarWindow: APIEndpoint<never, {
+        siteId: string;
+    } & CalendarWindowRequest, CalendarWindowPage>;
     getPublicBookingCalendarFeedIcs: APIEndpoint<never, {
         siteId: string;
         token: string;
@@ -19,92 +29,7 @@ export type PublicEventAPIEndpoints = {
     listPublicEvents: APIEndpoint<never, {
         siteId: string;
         stage?: string;
-    } & PublicEventLoaderParams, Array<{
-        bookingScope: 'single_occurrence' | 'whole_series';
-        eventPreset?: EventPreset;
-        eventDestinationMode?: import('../event-destination-policy').EventDestinationMode;
-        destination: PublicEventDestination;
-        scheduleScope?: Exclude<PublicEventScheduleScope, 'any'>;
-        recurrence?: PublicEventRecurrence;
-        id: string;
-        occurrenceId: string;
-        seriesId: string;
-        title: string;
-        description: string | null;
-        presentation?: {
-            title?: string | null;
-            summary?: string | null;
-            image?: {
-                type: 'image' | 'video' | 'audio';
-                purpose?: string;
-                placeholder?: boolean;
-                assetId?: string;
-                src?: string;
-                alt?: string;
-                width?: number;
-                height?: number;
-                storageBucket?: string;
-                storagePath?: string;
-                transform?: {
-                    rect?: [number, number, number, number];
-                    hotspot?: {
-                        x: number;
-                        y: number;
-                        radius?: number;
-                    };
-                };
-            } | null;
-        };
-        slug: string;
-        path: string | null;
-        requiresRegistration: boolean;
-        bookingAvailability: PublicEventBookingAvailability;
-        deliveryMode: EventDeliveryMode;
-        attendanceModes: Array<{
-            mode: EventAttendanceMode;
-            capacity: number | null;
-            registeredCount: number;
-            availableSpots: number | null;
-            waitlistEnabled: boolean;
-        }>;
-        startsAt: string;
-        endsAt: string;
-        capacity: number | null;
-        registeredCount: number;
-        availableSpots: number | null;
-        waitlistEnabled: boolean;
-        venue: {
-            id: string;
-            name: string;
-            address: string | null;
-            location: {
-                lat: number;
-                lng: number;
-            } | null;
-        } | null;
-        eventCategory: {
-            id: string;
-            name: string;
-            color: string | null;
-        } | null;
-        teamMembers?: PublicTeamMemberSummary[];
-        status?: 'active' | 'draft' | 'cancelled' | 'completed' | 'archived';
-        pricing: PublicEventPricing<PublicEventTicketTypeRecord>;
-        paymentTerms: BookingPaymentTermsConfig;
-        consent: BookingConsent | null;
-        accessRestriction: 'none' | 'category';
-        allowedCategoryIds: string[];
-        requireGuestDetails?: boolean;
-        timeZone: string;
-        acceptsPasses?: boolean;
-        acceptsMemberships?: boolean;
-        wholeSeries?: {
-            eventSeriesId: string;
-            pricing: BookingPricing;
-            currency: string;
-            enrollmentOpen: boolean;
-        } | null;
-    }>>;
+    } & PublicEventLoaderParams, PublicEvent[]>;
     getPublicEventFilters: APIEndpoint<never, {
         siteId: string;
         stage?: string;
@@ -162,6 +87,14 @@ export type PublicEventAPIEndpoints = {
         } | null;
     }>;
     registerForEvent: APIEndpoint<{
+        /**
+         * Client-generated command identity for this submission (UUID).
+         *
+         * Generated once when the customer submits and retained across transport
+         * retries, so a lost response can be replayed rather than double-booked.
+         * The single-occurrence commit is keyed on it; see #1273.
+         */
+        registrationCommandId: string;
         subject: {
             kind: 'occurrence';
             occurrenceId: string;
@@ -288,62 +221,6 @@ export type PublicEventAPIEndpoints = {
         waitlistPosition: number | null;
         alreadyRegistered?: boolean;
     }>;
-    checkPublicEventEligibility: APIEndpoint<{
-        occurrenceId: string;
-        attendanceMode?: EventAttendanceMode;
-        email: string;
-        ticketSelections: EventTicketSelectionRequest[];
-        selectedSlidingAmount?: number;
-    }, {
-        siteId: string;
-    }, {
-        customerExists: boolean;
-        eligibility: {
-            isFull: boolean;
-            waitlistEnabled: boolean;
-            canJoinWaitlist: boolean;
-            membership: {
-                customerMembershipId: string;
-                membershipName: string;
-            } | null;
-            passes: Array<{
-                customerPassId: string;
-                passName: string;
-                creditsRemaining: number;
-            }>;
-            requiresPayment: boolean;
-            pricingMode?: EventPricingMode;
-            selectedTicketTypeId?: string | null;
-            ticketLines: EventTicketLineSummaryResponse[];
-            ticketTypes?: PublicEventEligibilityTicketTypeRecord[];
-            eventPrice: number | null;
-            eventPriceCurrency: string | null;
-            eventAcceptsPasses: boolean;
-            eventAcceptsMemberships: boolean;
-            requiresAuthForPasses: boolean;
-            requiresAuthForMemberships: boolean;
-            availableForPurchase: {
-                passes: Array<{
-                    id: string;
-                    name: string;
-                    description: string | null;
-                    price: number;
-                    currency: string;
-                    creditsTotal: number;
-                    pricePerCredit: number;
-                    validDays: number | null;
-                }>;
-                memberships: Array<{
-                    id: string;
-                    name: string;
-                    description: string | null;
-                    price: number;
-                    currency: string;
-                    interval: 'month' | 'year';
-                }>;
-            };
-        };
-    }>;
     getPublicEventRegistrationOptions: APIEndpoint<PublicEventRegistrationOptionsRequest, {
         siteId: string;
     }, PublicEventRegistrationOptionsResponse>;
@@ -390,6 +267,11 @@ export type PublicEventAPIEndpoints = {
         siteId: string;
         token: string;
     }, string>;
+    resolveWaitlistClaim: APIEndpoint<{
+        claimToken: string;
+    }, {
+        siteId: string;
+    }, PublicWaitlistClaimResponse>;
 };
 export type PublicEventRegistrationOptionsRequest = EventRegistrationOptionsRequest;
 export type PublicEventRegistrationOptionsResponse = EventRegistrationOptionsResponse;

package/dist/_dts/api/src/publicExperience/sharedTypes.d.ts

@@ -6,11 +6,11 @@
 import type { AutoAppliedDiscountPreview } from '../bookingRecords';
 export declare const PUBLIC_EVENT_TICKET_SELECTION_CONTRACT_VERSION: "public-event-ticket-selection.v2";
 export type EventTicketSelectionRequest = {
-    ticketTypeId?: string | null;
+    pricingOptionId?: string | null;
     quantity: number;
 };
 export type EventTicketLineSummaryResponse = {
-    ticketTypeId: string | null;
+    pricingOptionId: string | null;
     label: string;
     description: string | null;
     quantity: number;
@@ -18,7 +18,7 @@ export type EventTicketLineSummaryResponse = {
     subtotalCents: number;
     currency: string;
 };
-export type { PublicWholeSeriesPriceDisplay, PublicEventPriceDisplay, PublicEventPricing, } from '../../../core/src/index';
+export type { PublicEventPriceDisplay, PublicEventPricing, } from '../../../core/src/index';
 /** Query parameters accepted by the public event list loaders. */
 export type PublicEventLoaderParams = {
     limit?: string;
@@ -37,6 +37,11 @@ export type PublicEventLoaderParams = {
     runSeriesId?: string;
     seriesSlug?: string;
     includeOccurrenceId?: string;
+    /**
+     * What the read is asking for: `'occurrences'` (default) for a page of dates,
+     * or `'runs'` for one row per whole-series run regardless of date.
+     */
+    readIntent?: string;
     detailLevel?: string;
     readProfile?: string;
 };
@@ -115,29 +120,6 @@ export type PublicDiscountContext = PublicEventDiscountContext | {
     type: 'membership';
     membershipId: string;
 } | PublicProductDiscountContext;
-export type WholeSeriesEligibilityResponse = {
-    eventSeriesId: string;
-    canEnroll: boolean;
-    canJoinWaitlist: boolean;
-    reason?: string;
-    availableSpots: number | null;
-    isFull: boolean;
-    isOnWaitlist: boolean;
-    waitlistEnabled: boolean;
-    price: {
-        cents: number | null;
-        currency: string;
-    };
-    paymentOptions: {
-        free: boolean;
-        membership: boolean;
-        stripe: boolean;
-    };
-    eligibleMemberships?: Array<{
-        customerMembershipId: string;
-        membershipName: string;
-    }>;
-};
 export type DiscountsAvailableResponse = Readonly<{
     type: 'none';
 }> | Readonly<{

package/dist/_dts/api/src/publicExperience/siteEndpoints.d.ts

@@ -4,6 +4,7 @@
  * Merged into `PublicExperienceAPIEndpoints` by `../publicExperienceEndpoints`.
  */
 import type { APIEndpoint } from '../apiEndpointTypes';
+import type { CalendarWindowRequest } from '../../../blocks/src/contracts/index';
 import type { PublicTeamMemberBlockItem } from '../teamMembers';
 import type { GeneratedIconRenderAssetsRequest, GeneratedIconRenderAssetsResponse } from '../siteIcons';
 import type { PublicEventDetailsLoaderParams, PublicEventLoaderParams } from './sharedTypes';
@@ -16,6 +17,10 @@ export type PublicSiteAPIEndpoints = {
     }>;
     batchBlockLoaders: APIEndpoint<{
         requests: Array<{
+            id: string;
+            endpoint: 'listPublicEventCalendarWindow';
+            params?: CalendarWindowRequest;
+        } | {
             id: string;
             endpoint: 'listPublicEvents';
             params?: PublicEventLoaderParams;
@@ -23,19 +28,6 @@ export type PublicSiteAPIEndpoints = {
             id: string;
             endpoint: 'getPublicEventDetails';
             params?: PublicEventDetailsLoaderParams;
-        } | {
-            id: string;
-            endpoint: 'listPublicWholeSeriesOfferings';
-            params?: {
-                limit?: string;
-            };
-        } | {
-            id: string;
-            endpoint: 'getPublicWholeSeriesOffering';
-            params?: {
-                eventSeriesId?: string;
-                stage?: string;
-            };
         } | {
             id: string;
             endpoint: 'listPublicTeamMembers';

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

@@ -6,10 +6,9 @@
  * merged here. This module stays the single import site for consumers.
  */
 import type { PublicCommerceAPIEndpoints } from './publicExperience/commerceEndpoints';
-import type { PublicWholeSeriesAPIEndpoints } from './publicExperience/wholeSeriesEndpoints';
 import type { PublicEventAPIEndpoints } from './publicExperience/eventEndpoints';
 import type { PublicNewsletterAPIEndpoints } from './publicExperience/newsletterEndpoints';
 import type { PublicSiteAPIEndpoints } from './publicExperience/siteEndpoints';
 export * from './publicExperience/sharedTypes';
-export type { PublicEventRegistrationOptionsRequest, PublicEventRegistrationOptionsResponse, } from './publicExperience/eventEndpoints';
-export type PublicExperienceAPIEndpoints = PublicEventAPIEndpoints & PublicWholeSeriesAPIEndpoints & PublicCommerceAPIEndpoints & PublicSiteAPIEndpoints & PublicNewsletterAPIEndpoints;
+export type { PublicEvent, PublicEventBase, PublicEventRegistrationOptionsRequest, PublicEventRegistrationOptionsResponse, PublicRunSession, PublicWholeSeriesRun, PublicWholeSeriesRunLifecycle, PublicWholeSeriesRunVisibility, } from './publicExperience/eventEndpoints';
+export type PublicExperienceAPIEndpoints = PublicEventAPIEndpoints & PublicCommerceAPIEndpoints & PublicSiteAPIEndpoints & PublicNewsletterAPIEndpoints;

package/dist/_dts/api/src/schemas/admin-allowed-domains.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import type { RequestInput, RequestOutput } from './support';
+/**
+ * Request schemas for the admin allowed-email-domain endpoints.
+ *
+ * This module is the single authority for what those endpoints accept. The
+ * client-facing body contract in `APIEndpoints` is derived from `z.input`; the
+ * route handler and its service receive `z.output`. See
+ * `.project/plans/tier2-step5-schema-entrypoint/design.md` for why both sides
+ * are named here rather than left to `z.infer`.
+ *
+ * Covered endpoints: `adminListAllowedDomains`, `adminAddAllowedDomain`,
+ * `adminDeleteAllowedDomain`.
+ *
+ * Allowed domains get their own module rather than joining `admin-users.ts`:
+ * the layout is per-family, and this family has its own routes, its own service
+ * and its own response types in `accessAdmin.ts`. Sharing a module would also
+ * put two unrelated schema trees behind one entrypoint, which is the thing the
+ * per-domain split exists to avoid.
+ */
+/**
+ * `adminDeleteAllowedDomain`.
+ *
+ * The service takes the raw uuid string, so nothing is branded on the way
+ * through and `brandedUuidParam` is deliberately not used.
+ *
+ * Note this is a *path* parameter — `/admin/allowed-domains/{domainId}` — even
+ * though the endpoint declares `{ domainId: string }` in its query slot. That
+ * is the same confusion batch 4 untangled on `listManagementKeys`: `APIEndpoint`'s
+ * second parameter carries both path params and query, and `apiCallParams`'
+ * `PathParams` is what actually puts `domainId` in the client's `params`. The
+ * contract is left exactly as it was (removing the query declaration would be a
+ * contract edit, not a schema migration) and `admin-allowed-domains.typetest.ts`
+ * pins that the encoded params are the same either way.
+ */
+export declare const adminDeleteAllowedDomainParamsSchema: z.ZodObject<{
+    domainId: z.ZodString;
+}, z.core.$strip>;
+export type AdminDeleteAllowedDomainParamsOutput = RequestOutput<typeof adminDeleteAllowedDomainParamsSchema>;
+/**
+ * `adminListAllowedDomains`.
+ *
+ * The clean case: `tenantId` neither defaults, coerces nor transforms, so
+ * `z.output` is exactly the shape a sender may put on the wire and the client
+ * contract derives from it.
+ *
+ * `.nullable()` is carried over verbatim from the route. A URL cannot express
+ * `null`, so the null arm is unreachable through the client machinery — which
+ * stringifies query values — and only the body schema below can actually
+ * receive one. It stays because dropping it would narrow a published optional
+ * field, which is a contract decision rather than part of a schema migration.
+ */
+export declare const adminListAllowedDomainsQuerySchema: z.ZodObject<{
+    tenantId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/** What the route receives, and what the client contract is derived from. */
+export type AdminListAllowedDomainsQueryOutput = RequestOutput<typeof adminListAllowedDomainsQuerySchema>;
+/**
+ * `adminAddAllowedDomain`.
+ *
+ * Nothing defaults, coerces or transforms, so `z.input` and `z.output` are the
+ * same type and the contract derives from the input side with no divergence.
+ * `.trim()` changes the value but not the type.
+ *
+ * The schema is stricter than the published type in ways the type cannot say —
+ * `domain` is capped at 255 characters and `tenantId` must be a uuid — which was
+ * already true when the schema lived in the route file.
+ */
+export declare const adminAddAllowedDomainBodySchema: z.ZodObject<{
+    domain: z.ZodString;
+    tenantId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/** What a client sends: `tenantId` may be omitted or explicitly null. */
+export type AdminAddAllowedDomainBodyInput = RequestInput<typeof adminAddAllowedDomainBodySchema>;
+/** What the route receives. Same shape — this body has no divergence. */
+export type AdminAddAllowedDomainBodyOutput = RequestOutput<typeof adminAddAllowedDomainBodySchema>;

package/dist/_dts/api/src/schemas/admin-observability-logs.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import type { RequestOutput } from './support';
+/** `adminListAxiomLogs`. `dataset` picks which Axiom dataset to tail. */
+export declare const adminListAxiomLogsQuerySchema: z.ZodObject<{
+    dataset: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    tail: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        errors: "errors";
+        all: "all";
+        warnings: "warnings";
+    }>>;
+}, z.core.$strip>;
+export type AdminListAxiomLogsQueryOutput = RequestOutput<typeof adminListAxiomLogsQuerySchema>;
+/**
+ * `adminListErrorLogs`.
+ *
+ * The aggregated error feed has no `'all'` mode — it is already only errors and
+ * warnings — and its `source` filter takes a list rather than a single value.
+ */
+export declare const adminListErrorLogsQuerySchema: z.ZodObject<{
+    source: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    tail: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        errors: "errors";
+        warnings: "warnings";
+    }>>;
+}, z.core.$strip>;
+export type AdminListErrorLogsQueryOutput = RequestOutput<typeof adminListErrorLogsQuerySchema>;
+/** `adminListSupabaseLogs`. `source` names a single Supabase log source. */
+export declare const adminListSupabaseLogsQuerySchema: z.ZodObject<{
+    source: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    tail: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        errors: "errors";
+        all: "all";
+        warnings: "warnings";
+    }>>;
+}, z.core.$strip>;
+export type AdminListSupabaseLogsQueryOutput = RequestOutput<typeof adminListSupabaseLogsQuerySchema>;
+/** `adminListVercelLogs`. No source or dataset selector. */
+export declare const adminListVercelLogsQuerySchema: z.ZodObject<{
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    tail: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        errors: "errors";
+        all: "all";
+        warnings: "warnings";
+    }>>;
+}, z.core.$strip>;
+export type AdminListVercelLogsQueryOutput = RequestOutput<typeof adminListVercelLogsQuerySchema>;

package/dist/_dts/api/src/schemas/admin-users.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import type { RequestInput, RequestOutput } from './support';
+/**
+ * Request schemas for the admin user-management endpoints.
+ *
+ * This module is the single authority for what those endpoints accept. The
+ * client-facing body contract in `APIEndpoints` is derived from `z.input`; the
+ * route handler and its service receive `z.output`. See
+ * `.project/plans/tier2-step5-schema-entrypoint/design.md` for why both sides
+ * are named here rather than left to `z.infer`.
+ *
+ * Covered endpoints: `adminCreateUser`, `adminDeleteUser`.
+ */
+/**
+ * `adminDeleteUser`.
+ *
+ * The service takes the raw uuid string (it is handed to Supabase auth admin
+ * calls, not to a branded-id helper), so nothing is branded on the way through.
+ */
+export declare const adminDeleteUserParamsSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;
+export type AdminDeleteUserParamsOutput = RequestOutput<typeof adminDeleteUserParamsSchema>;
+/**
+ * `adminCreateUser`.
+ *
+ * `sendInvite` is the divergence: senders may omit it, so the wire contract has
+ * it optional, while the route always receives a concrete boolean. The route
+ * file previously annotated this schema `z.ZodType<CreateAdminUserRequest>`,
+ * which pinned only the output and hid that difference.
+ */
+export declare const adminCreateUserBodySchema: z.ZodObject<{
+    email: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    sendInvite: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/** What a client sends: `sendInvite` and `displayName` may both be omitted. */
+export type AdminCreateUserBodyInput = RequestInput<typeof adminCreateUserBodySchema>;
+/** What the route receives: `sendInvite` is always present. */
+export type AdminCreateUserBodyOutput = RequestOutput<typeof adminCreateUserBodySchema>;
+/**
+ * `adminDeleteUser`.
+ *
+ * This is the first migrated query with a value-changing `.transform()`, so
+ * neither side of the schema can be handed straight to the client contract:
+ * `z.input` is the four literal spellings the URL may carry, and `z.output` is
+ * the decoded boolean. See `AdminDeleteUserQueryInput`.
+ */
+export declare const adminDeleteUserQuerySchema: z.ZodObject<{
+    force: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"1">, z.ZodLiteral<"0">, z.ZodLiteral<"true">, z.ZodLiteral<"false">]>>, z.ZodTransform<boolean | undefined, "0" | "1" | "true" | "false" | undefined>>;
+}, z.core.$strip>;
+/**
+ * The client-facing query contract for `adminDeleteUser` — **modelled, not
+ * derived**, and the worked example of the rule in the design doc's "Which side
+ * each consumer gets".
+ *
+ * Callers have always expressed this as a boolean (`adminDeleteUser(client, id,
+ * { force: true })`), and the `adminDeleteUser` wrapper in `admin.ts` encodes
+ * it onto the URL — sending `force=true` or omitting the parameter entirely.
+ * Deriving from `z.input` would replace `boolean` with the literal union
+ * `'1' | '0' | 'true' | 'false'` and break every existing caller; deriving from
+ * `z.output` would be a coincidence, since the transform is what makes the two
+ * sides agree in shape at all. So the type stays hand-written and the schema is
+ * checked against it instead: the wrapper's params expression is annotated with
+ * `AdminDeleteUserQueryWire` below, so its actual encoding must be something
+ * this schema accepts, and `admin-users.typetest.ts` asserts the parsed value
+ * matches the model.
+ */
+export type AdminDeleteUserQueryInput = {
+    force?: boolean;
+};
+/**
+ * The wire spellings the query schema accepts, as a type the `adminDeleteUser`
+ * client wrapper annotates its params with (type-only — no zod reaches the
+ * client bundle). If the wrapper's hand-rolled encoding and this schema ever
+ * disagree, that annotation is where the compiler says so.
+ */
+export type AdminDeleteUserQueryWire = RequestInput<typeof adminDeleteUserQuerySchema>;
+/** What the route receives after the transform has decoded the wire spelling. */
+export type AdminDeleteUserQueryOutput = RequestOutput<typeof adminDeleteUserQuerySchema>;

package/dist/_dts/api/src/schemas/newsletter-memberships.d.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import type { RequestInput, RequestOutput } from './support';
+/**
+ * Request schemas for the newsletter list-membership endpoints.
+ *
+ * This module is the single authority for what those endpoints accept. The
+ * client-facing body contract in `APIEndpoints` is derived from `z.input`; the
+ * route handler and its service receive `z.output`. See
+ * `.project/plans/tier2-step5-schema-entrypoint/design.md` for why both sides
+ * are named here rather than left to `z.infer`.
+ *
+ * Covered endpoints: `listNewsletterListMembers`, `updateNewsletterListMemberships`.
+ *
+ * This is the family that exercises the *defaulted* half of the modelled-input
+ * rule. Its query 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 `limit`/`offset` required, which would force
+ * every caller to send a value the endpoint deliberately fills in. So the client
+ * type is modelled below and checked against the schema instead.
+ */
+/**
+ * `listNewsletterListMembers` / `updateNewsletterListMemberships`.
+ *
+ * Neither id is branded — the newsletter services take the raw strings — so
+ * `brandedUuidParam` is deliberately not used here and the 400 messages are the
+ * ones the route already authored.
+ */
+export declare const newsletterListMembershipParamsSchema: z.ZodObject<{
+    siteId: z.ZodString;
+    listId: z.ZodString;
+}, z.core.$strip>;
+export type NewsletterListMembershipParamsOutput = RequestOutput<typeof newsletterListMembershipParamsSchema>;
+/**
+ * `listNewsletterListMembers`.
+ *
+ * The route parses the search params merged with its already-parsed path params
+ * (`includeParamsInInput` defaults to true), which is why `siteId` and `listId`
+ * are repeated here: the schema sees them, and the endpoint's client contract
+ * carries them alongside the pagination fields.
+ */
+export declare const listNewsletterListMembersQuerySchema: z.ZodObject<{
+    siteId: z.ZodString;
+    listId: z.ZodString;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/**
+ * The client-facing pagination contract — **modelled, not derived**, and the
+ * worked example of the defaulted half of the rule in the design doc's "Which
+ * side each consumer gets".
+ *
+ * Deriving from `z.output` would publish `limit: number; offset: number`, making
+ * both required and breaking every caller that omits them (the dashboard's
+ * member picker sends both, but nothing in the contract says it has to).
+ * Deriving from `z.input` would publish `unknown`, which is not a contract at
+ * all. So the model stays wider on optionality than the parsed value on purpose,
+ * and `newsletter-memberships.typetest.ts` holds the schema to it.
+ */
+export type ListNewsletterListMembersQueryInput = {
+    limit?: number;
+    offset?: number;
+};
+/**
+ * What the client machinery actually puts on the URL.
+ *
+ * There is no hand-rolled encoder for this endpoint 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: 'listNewsletterListMembers' })`
+ * must supply, and the typetest pins it against that machinery while a golden
+ * test parses exactly this shape. Together they are the link a derivation would
+ * otherwise have made: contract → encoded params → something the schema accepts.
+ */
+export type ListNewsletterListMembersQueryWire = {
+    siteId: string;
+    listId: string;
+    limit?: string;
+    offset?: string;
+};
+/** What the route receives: pagination is always resolved to a number. */
+export type ListNewsletterListMembersQueryOutput = RequestOutput<typeof listNewsletterListMembersQuerySchema>;
+/**
+ * `updateNewsletterListMemberships`.
+ *
+ * The `.default([])` pair is the body-side twin of `adminCreateUser`'s
+ * `sendInvite`: both arrays may be omitted on the wire and are always present
+ * once the route has parsed them. The route file annotated this schema
+ * `z.ZodType<UpdateNewsletterListMembershipsRequest>`, which pinned the output
+ * only and hid that difference.
+ */
+export declare const updateNewsletterListMembershipsBodySchema: z.ZodObject<{
+    addSubscriberIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    removeSubscriberIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** What a client sends: either array may be omitted. */
+export type UpdateNewsletterListMembershipsBodyInput = RequestInput<typeof updateNewsletterListMembershipsBodySchema>;
+/** What the route receives: both arrays are always present. */
+export type UpdateNewsletterListMembershipsBodyOutput = RequestOutput<typeof updateNewsletterListMembershipsBodySchema>;