@riverbankcms/sdk 0.130.0 → 0.132.0

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

@@ -0,0 +1,213 @@
+import { z } from 'zod';
+import { type ApiKeyId, type Secret, type SiteId, type UserId } from '../../core/src/index';
+import { ApiEnvelopeError } from './common/envelope';
+import { type ApiClient, type ApiRequestError } from './request';
+import { type AccountCreateSiteRequest, type AccountCreateSiteResponse, type AccountProjectCredentialRecoveryFailureTag, type AccountProvisionProjectCredentialsRequest, type AccountIdentityResponse, type AccountListSitesQuery, type AccountListSitesResponse, type AccountSite } from './accountEndpoints';
+declare const identityResponseSchema: z.ZodObject<{
+    userId: z.ZodPipe<z.ZodString, z.ZodTransform<UserId, string>>;
+    email: z.ZodNullable<z.ZodString>;
+    displayName: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const listSitesResponseSchema: z.ZodObject<{
+    sites: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<SiteId, string>>;
+        title: z.ZodString;
+        slug: z.ZodString;
+        createdAt: z.ZodNullable<z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+        role: z.ZodEnum<{
+            editor: "editor";
+            owner: "owner";
+            administrator: "administrator";
+            team_member: "team_member";
+        }>;
+        deploymentMode: z.ZodLiteral<"managed">;
+        linkCapability: z.ZodObject<{
+            tag: z.ZodLiteral<"ineligible_deployment_mode">;
+            deploymentMode: z.ZodLiteral<"managed">;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<SiteId, string>>;
+        title: z.ZodString;
+        slug: z.ZodString;
+        createdAt: z.ZodNullable<z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+        role: z.ZodEnum<{
+            editor: "editor";
+            owner: "owner";
+            administrator: "administrator";
+            team_member: "team_member";
+        }>;
+        deploymentMode: z.ZodLiteral<"headless_cms">;
+        linkCapability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            tag: z.ZodLiteral<"linkable">;
+        }, z.core.$strip>, z.ZodObject<{
+            tag: z.ZodLiteral<"insufficient_role">;
+            requiredRole: z.ZodEnum<{
+                editor: "editor";
+                owner: "owner";
+                administrator: "administrator";
+                team_member: "team_member";
+            }>;
+        }, z.core.$strip>], "tag">;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<SiteId, string>>;
+        title: z.ZodString;
+        slug: z.ZodString;
+        createdAt: z.ZodNullable<z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
+        role: z.ZodEnum<{
+            editor: "editor";
+            owner: "owner";
+            administrator: "administrator";
+            team_member: "team_member";
+        }>;
+        deploymentMode: z.ZodLiteral<"headless_full">;
+        linkCapability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            tag: z.ZodLiteral<"linkable">;
+        }, z.core.$strip>, z.ZodObject<{
+            tag: z.ZodLiteral<"insufficient_role">;
+            requiredRole: z.ZodEnum<{
+                editor: "editor";
+                owner: "owner";
+                administrator: "administrator";
+                team_member: "team_member";
+            }>;
+        }, z.core.$strip>], "tag">;
+    }, z.core.$strip>], "deploymentMode">>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const createSiteResponseSchema: z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<SiteId, string>>;
+    title: z.ZodString;
+    slug: z.ZodString;
+}, z.core.$strip>;
+type AccountApiStandardKeyIds = Readonly<{
+    live?: ApiKeyId;
+    management?: ApiKeyId;
+}>;
+type AccountApiPreviewKeyIds = Readonly<{
+    live?: ApiKeyId;
+    management?: ApiKeyId;
+    preview?: ApiKeyId;
+}>;
+type AccountApiStandardChecks = Readonly<{
+    live: Readonly<{
+        keyId: ApiKeyId;
+        status: 'active';
+    }>;
+    management: Readonly<{
+        keyId: ApiKeyId;
+        status: 'active';
+    }>;
+}>;
+type AccountApiPreviewChecks = AccountApiStandardChecks & Readonly<{
+    preview: Readonly<{
+        keyId: ApiKeyId;
+        status: 'active';
+    }>;
+}>;
+export type AccountApiProvisionedProjectCredentials = Readonly<{
+    operation: 'issue_standard';
+    siteId: SiteId;
+    operationId: string;
+    revokedAbandonedKeyIds: AccountApiStandardKeyIds;
+    credentials: Readonly<{
+        live: Readonly<{
+            key: Secret<'content-key'>;
+            keyId: ApiKeyId;
+        }>;
+        management: Readonly<{
+            key: Secret<'management-key'>;
+            keyId: ApiKeyId;
+        }>;
+    }>;
+}> | Readonly<{
+    operation: 'issue_with_preview';
+    siteId: SiteId;
+    operationId: string;
+    revokedAbandonedKeyIds: AccountApiPreviewKeyIds;
+    credentials: Readonly<{
+        live: Readonly<{
+            key: Secret<'content-key'>;
+            keyId: ApiKeyId;
+        }>;
+        management: Readonly<{
+            key: Secret<'management-key'>;
+            keyId: ApiKeyId;
+        }>;
+        preview: Readonly<{
+            key: Secret<'preview-key'>;
+            keyId: ApiKeyId;
+        }>;
+    }>;
+}> | Readonly<{
+    operation: 'recovery_standard';
+    siteId: SiteId;
+    operationId: string;
+    issuedKeyIds: AccountApiStandardKeyIds;
+    revokedAbandonedKeyIds: AccountApiStandardKeyIds;
+    remainingAbandonedKeyIds: AccountApiStandardKeyIds;
+    failureTag: AccountProjectCredentialRecoveryFailureTag;
+}> | Readonly<{
+    operation: 'recovery_with_preview';
+    siteId: SiteId;
+    operationId: string;
+    issuedKeyIds: AccountApiPreviewKeyIds;
+    revokedAbandonedKeyIds: AccountApiPreviewKeyIds;
+    remainingAbandonedKeyIds: AccountApiPreviewKeyIds;
+    failureTag: AccountProjectCredentialRecoveryFailureTag;
+}> | Readonly<{
+    operation: 'revalidate_standard';
+    siteId: SiteId;
+    operationId: string;
+    checks: AccountApiStandardChecks;
+}> | Readonly<{
+    operation: 'revalidate_with_preview';
+    siteId: SiteId;
+    operationId: string;
+    checks: AccountApiPreviewChecks;
+}>;
+declare const provisionedProjectCredentialsResponseSchema: z.ZodType<AccountApiProvisionedProjectCredentials>;
+export type AccountApiIdentity = Omit<AccountIdentityResponse, 'userId'> & Readonly<{
+    userId: UserId;
+}>;
+type AccountApiSiteWithBrandedId<Site> = Site extends Readonly<{
+    id: string;
+}> ? Omit<Site, 'id'> & Readonly<{
+    id: SiteId;
+}> : never;
+export type AccountApiSite = AccountApiSiteWithBrandedId<AccountSite>;
+export type AccountApiSites = Omit<AccountListSitesResponse, 'sites'> & Readonly<{
+    sites: readonly AccountApiSite[];
+}>;
+export type AccountApiCreatedSite = Omit<AccountCreateSiteResponse, 'id'> & Readonly<{
+    id: SiteId;
+}>;
+export type AccountApiResponseError = Readonly<{
+    tag: 'malformed_success';
+    endpoint: 'accountGetIdentity' | 'accountListSites' | 'accountCreateSite' | 'accountProvisionProjectCredentials';
+    issues: readonly z.ZodIssue[];
+}>;
+export declare class AccountApiMalformedResponseError extends Error {
+    readonly tag = "malformed_success";
+    readonly endpoint: AccountApiResponseError['endpoint'];
+    readonly issues: readonly z.ZodIssue[];
+    constructor(endpoint: AccountApiResponseError['endpoint'], issues: readonly z.ZodIssue[]);
+}
+export type AccountApiError = ApiRequestError | ApiEnvelopeError | AccountApiMalformedResponseError;
+export type AccountApi = Readonly<{
+    getIdentity(options?: RequestInit): Promise<AccountApiIdentity>;
+    listSites(input?: Readonly<{
+        query?: AccountListSitesQuery;
+        options?: RequestInit;
+    }>): Promise<AccountApiSites>;
+    createSite(input: Readonly<{
+        body: AccountCreateSiteRequest;
+        options?: RequestInit;
+    }>): Promise<AccountApiCreatedSite>;
+    provisionProjectCredentials(input: Readonly<{
+        body: AccountProvisionProjectCredentialsRequest;
+        options?: RequestInit;
+    }>): Promise<AccountApiProvisionedProjectCredentials>;
+}>;
+export declare function createAccountApi(apiClient: ApiClient): AccountApi;
+export declare function createBearerAccountApi(token: Secret<'oauth-access-token'>, baseUrl?: string): AccountApi;
+export { identityResponseSchema as accountIdentityResponseSchema, listSitesResponseSchema as accountListSitesResponseSchema, createSiteResponseSchema as accountCreateSiteResponseSchema, provisionedProjectCredentialsResponseSchema as accountProvisionProjectCredentialsResponseSchema, };

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

@@ -0,0 +1,30 @@
+export declare const ACCOUNT_ENDPOINT_DEFINITIONS: {
+    accountGetIdentity: {
+        path: "/account/identity";
+        method: "GET";
+        auth: "user";
+        errors: ("auth:unauthenticated" | "server:internal_error")[];
+        responseKind: "json";
+    };
+    accountListSites: {
+        path: "/account/sites";
+        method: "GET";
+        auth: "user";
+        errors: ("auth:unauthenticated" | "validation:invalid_format" | "server:internal_error")[];
+        responseKind: "json";
+    };
+    accountCreateSite: {
+        path: "/account/sites";
+        method: "POST";
+        auth: "user";
+        errors: ("auth:unauthenticated" | "validation:invalid_input" | "server:internal_error")[];
+        responseKind: "json";
+    };
+    accountProvisionProjectCredentials: {
+        path: "/account/project-credentials";
+        method: "POST";
+        auth: "user";
+        errors: ("auth:unauthenticated" | "auth:forbidden" | "validation:invalid_input" | "resource:not_found" | "server:internal_error")[];
+        responseKind: "json";
+    };
+};

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

@@ -0,0 +1,254 @@
+import { z } from 'zod';
+import type { APIEndpoint } from './apiEndpointTypes';
+import type { SiteRole } from './siteMembers';
+export declare const ACCOUNT_SITE_TITLE_MAX_LENGTH = 120;
+export declare const ACCOUNT_SITE_LIST_LIMIT_MIN = 1;
+export declare const ACCOUNT_SITE_LIST_LIMIT_MAX = 100;
+export declare const ACCOUNT_SITE_LIST_LIMIT_DEFAULT = 50;
+export declare const ACCOUNT_SITE_CURSOR_MAX_LENGTH = 2048;
+export declare const ACCOUNT_SITE_SEARCH_MAX_LENGTH = 120;
+/** Strict, injection-safe PostgreSQL/RFC3339 timestamp text used in cursors. */
+export declare function isAccountSiteTimestamp(value: unknown): value is string;
+export declare const accountSiteTimestampSchema: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+export declare const accountSiteDeploymentModeSchema: z.ZodEnum<{
+    managed: "managed";
+    headless_cms: "headless_cms";
+    headless_full: "headless_full";
+}>;
+export type AccountSiteDeploymentMode = z.infer<typeof accountSiteDeploymentModeSchema>;
+export declare const accountCreateSiteRequestSchema: z.ZodObject<{
+    title: z.ZodString;
+}, z.core.$strip>;
+export declare const ACCOUNT_PROJECT_CREDENTIAL_PROJECT_NAME_MAX_LENGTH = 120;
+export declare const accountProvisionProjectCredentialsRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"issue_standard">;
+    siteId: z.ZodString;
+    operationId: z.ZodString;
+    projectName: z.ZodString;
+    abandonedKeyIds: z.ZodDefault<z.ZodObject<{
+        live: z.ZodOptional<z.ZodString>;
+        management: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"issue_with_preview">;
+    siteId: z.ZodString;
+    operationId: z.ZodString;
+    projectName: z.ZodString;
+    abandonedKeyIds: z.ZodDefault<z.ZodObject<{
+        live: z.ZodOptional<z.ZodString>;
+        management: z.ZodOptional<z.ZodString>;
+        preview: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"revalidate_standard">;
+    siteId: z.ZodString;
+    operationId: z.ZodString;
+    projectName: z.ZodString;
+    keyIds: z.ZodObject<{
+        live: z.ZodString;
+        management: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"revalidate_with_preview">;
+    siteId: z.ZodString;
+    operationId: z.ZodString;
+    projectName: z.ZodString;
+    keyIds: z.ZodObject<{
+        live: z.ZodString;
+        management: z.ZodString;
+        preview: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>], "operation">;
+export declare const accountListSitesQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    search: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Account-scoped contracts used by the CLI and other authenticated clients.
+ *
+ * These intentionally keep account identity/site discovery separate from the
+ * credential capability, whose request and response are explicitly typed
+ * below so one-time secrets cannot be confused with ordinary site data.
+ */
+export type AccountIdentityResponse = Readonly<{
+    userId: string;
+    email: string | null;
+    displayName: string | null;
+}>;
+export type AccountSiteLinkCapability = Readonly<{
+    tag: 'linkable';
+}> | Readonly<{
+    tag: 'insufficient_role';
+    requiredRole: SiteRole;
+}> | Readonly<{
+    tag: 'ineligible_deployment_mode';
+    deploymentMode: 'managed';
+}>;
+type AccountSiteSharedFields = Readonly<{
+    id: string;
+    title: string;
+    slug: string;
+    createdAt: string | null;
+    role: SiteRole;
+}>;
+type AccountSiteHeadlessLinkCapability = Exclude<AccountSiteLinkCapability, {
+    tag: 'ineligible_deployment_mode';
+}>;
+type AccountSiteManagedLinkCapability = Extract<AccountSiteLinkCapability, {
+    tag: 'ineligible_deployment_mode';
+}>;
+export type AccountSite = (AccountSiteSharedFields & Readonly<{
+    deploymentMode: 'managed';
+    linkCapability: AccountSiteManagedLinkCapability;
+}>) | (AccountSiteSharedFields & Readonly<{
+    deploymentMode: Exclude<AccountSiteDeploymentMode, 'managed'>;
+    linkCapability: AccountSiteHeadlessLinkCapability;
+}>);
+export type AccountListSitesQuery = Readonly<{
+    cursor?: string;
+    limit?: number;
+    search?: string;
+}>;
+export type AccountListSitesResponse = Readonly<{
+    sites: readonly AccountSite[];
+    nextCursor: string | null;
+}>;
+export type AccountCreateSiteRequest = Readonly<{
+    title: string;
+}>;
+export type AccountCreateSiteResponse = Readonly<{
+    id: string;
+    title: string;
+    slug: string;
+}>;
+export type AccountProjectCredentialKeyIds = Readonly<{
+    live?: string;
+    management?: string;
+    preview?: string;
+}>;
+export type AccountProvisionProjectCredentialsRequest = Readonly<{
+    operation: 'issue_standard';
+    siteId: string;
+    operationId: string;
+    projectName: string;
+    abandonedKeyIds?: Readonly<{
+        live?: string;
+        management?: string;
+    }>;
+} | {
+    operation: 'issue_with_preview';
+    siteId: string;
+    operationId: string;
+    projectName: string;
+    abandonedKeyIds?: AccountProjectCredentialKeyIds;
+} | {
+    operation: 'revalidate_standard';
+    siteId: string;
+    operationId: string;
+    projectName: string;
+    keyIds: Readonly<{
+        live: string;
+        management: string;
+    }>;
+} | {
+    operation: 'revalidate_with_preview';
+    siteId: string;
+    operationId: string;
+    projectName: string;
+    keyIds: Readonly<{
+        live: string;
+        management: string;
+        preview: string;
+    }>;
+}>;
+export type AccountProjectCredential = Readonly<{
+    key: string;
+    keyId: string;
+}>;
+export type AccountProjectCredentialRecoveryFailureTag = 'ACCOUNT_CREDENTIALS_ISSUANCE_FAILED' | 'ACCOUNT_CREDENTIALS_RECOVERY_REVOKE_FAILED';
+type AccountProvisionProjectCredentialsIssueShared = Readonly<{
+    siteId: string;
+    operationId: string;
+}>;
+export type AccountProvisionProjectCredentialsResponse = (AccountProvisionProjectCredentialsIssueShared & Readonly<{
+    operation: 'issue_standard';
+    revokedAbandonedKeyIds: Readonly<{
+        live?: string;
+        management?: string;
+    }>;
+    credentials: Readonly<{
+        live: AccountProjectCredential;
+        management: AccountProjectCredential;
+    }>;
+}>) | (AccountProvisionProjectCredentialsIssueShared & Readonly<{
+    operation: 'issue_with_preview';
+    revokedAbandonedKeyIds: AccountProjectCredentialKeyIds;
+    credentials: Readonly<{
+        live: AccountProjectCredential;
+        management: AccountProjectCredential;
+        preview: AccountProjectCredential;
+    }>;
+}>) | (AccountProvisionProjectCredentialsIssueShared & Readonly<{
+    operation: 'recovery_standard';
+    siteId: string;
+    operationId: string;
+    issuedKeyIds: Readonly<{
+        live?: string;
+        management?: string;
+    }>;
+    revokedAbandonedKeyIds: Readonly<{
+        live?: string;
+        management?: string;
+    }>;
+    remainingAbandonedKeyIds: Readonly<{
+        live?: string;
+        management?: string;
+    }>;
+    failureTag: AccountProjectCredentialRecoveryFailureTag;
+}>) | (AccountProvisionProjectCredentialsIssueShared & Readonly<{
+    operation: 'recovery_with_preview';
+    issuedKeyIds: AccountProjectCredentialKeyIds;
+    revokedAbandonedKeyIds: AccountProjectCredentialKeyIds;
+    remainingAbandonedKeyIds: AccountProjectCredentialKeyIds;
+    failureTag: AccountProjectCredentialRecoveryFailureTag;
+}>) | Readonly<{
+    operation: 'revalidate_standard';
+    siteId: string;
+    operationId: string;
+    checks: Readonly<{
+        live: Readonly<{
+            keyId: string;
+            status: 'active';
+        }>;
+        management: Readonly<{
+            keyId: string;
+            status: 'active';
+        }>;
+    }>;
+}> | Readonly<{
+    operation: 'revalidate_with_preview';
+    siteId: string;
+    operationId: string;
+    checks: Readonly<{
+        live: Readonly<{
+            keyId: string;
+            status: 'active';
+        }>;
+        management: Readonly<{
+            keyId: string;
+            status: 'active';
+        }>;
+        preview: Readonly<{
+            keyId: string;
+            status: 'active';
+        }>;
+    }>;
+}>;
+export type AccountAPIEndpoints = {
+    accountGetIdentity: APIEndpoint<never, never, AccountIdentityResponse>;
+    accountListSites: APIEndpoint<never, AccountListSitesQuery, AccountListSitesResponse>;
+    accountCreateSite: APIEndpoint<AccountCreateSiteRequest, never, AccountCreateSiteResponse>;
+    accountProvisionProjectCredentials: APIEndpoint<AccountProvisionProjectCredentialsRequest, never, AccountProvisionProjectCredentialsResponse>;
+};
+export {};

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

@@ -0,0 +1,60 @@
+import type { API_ENDPOINTS } from './endpoints';
+import type { APIEndpoint } from './apiEndpointTypes';
+import type { HTTPMethod } from './common/types';
+import type { APIEndpoints } from './types';
+export type GetEndpoint<T extends keyof APIEndpoints> = APIEndpoints[T];
+export type GetMethodEndpoint<T extends keyof APIEndpoints> = APIEndpoints[T] extends {
+    method: "GET";
+} ? APIEndpoints[T] : never;
+export type PostMethodEndpoint<T extends keyof APIEndpoints> = APIEndpoints[T] extends {
+    method: "POST";
+} ? APIEndpoints[T] : never;
+export type PutMethodEndpoint<T extends keyof APIEndpoints> = APIEndpoints[T] extends {
+    method: "PUT";
+} ? APIEndpoints[T] : never;
+type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+type HasRequiredKeys<T> = RequiredKeys<T> extends never ? false : true;
+type IsNonEmptyQuery<T> = [T] extends [never] ? false : T extends undefined ? false : keyof T extends never ? false : true;
+type QueryValueToStringParam<T> = Exclude<T, undefined> extends readonly (infer TValue)[] ? QueryValueToStringParam<TValue>[] : Exclude<T, undefined> extends (infer TValue)[] ? QueryValueToStringParam<TValue>[] : string;
+type QueryToStringParams<T> = {
+    [K in keyof T]: QueryValueToStringParam<T[K]>;
+};
+type ExtractPathParamNames<TPath extends string> = TPath extends `${string}{${infer Param}}${infer Rest}` ? Param | ExtractPathParamNames<Rest> : never;
+type EndpointPath<E extends keyof APIEndpoints> = E extends keyof typeof API_ENDPOINTS ? (typeof API_ENDPOINTS)[E]["path"] : never;
+type PathParams<E extends keyof APIEndpoints> = ExtractPathParamNames<EndpointPath<E>> extends infer TParam ? [TParam] extends [never] ? {} : {
+    [K in Extract<TParam, string>]: string;
+} : {};
+type EndpointQuery<E extends keyof APIEndpoints> = APIEndpoints[E] extends APIEndpoint<unknown, infer TQuery, unknown> ? TQuery : never;
+type QueryParams<E extends keyof APIEndpoints> = IsNonEmptyQuery<EndpointQuery<E>> extends false ? {} : QueryToStringParams<EndpointQuery<E>>;
+type HasPathParams<E extends keyof APIEndpoints> = keyof PathParams<E> extends never ? false : true;
+type ParamsPart<E extends keyof APIEndpoints> = HasPathParams<E> extends true ? {
+    params: PathParams<E> & QueryParams<E>;
+} : IsNonEmptyQuery<EndpointQuery<E>> extends false ? {
+    params?: Record<string, string>;
+} : HasRequiredKeys<EndpointQuery<E>> extends true ? {
+    params: QueryParams<E>;
+} : {
+    params?: QueryParams<E>;
+};
+type EndpointMethod<E extends keyof APIEndpoints> = E extends keyof typeof API_ENDPOINTS ? (typeof API_ENDPOINTS)[E]["method"] : HTTPMethod;
+type EndpointBody<E extends keyof APIEndpoints> = APIEndpoints[E] extends APIEndpoint<infer TBody, unknown, unknown> ? TBody : never;
+type StrictBodyPart<E extends keyof APIEndpoints> = EndpointMethod<E> extends "GET" ? {
+    body?: never;
+} : [EndpointBody<E>] extends [undefined] ? {
+    body?: never;
+} : undefined extends EndpointBody<E> ? {
+    body?: Exclude<EndpointBody<E>, undefined>;
+} : {
+    body: EndpointBody<E>;
+};
+/**
+ * API call parameters derived from endpoint metadata.
+ * Enforces whether `body` is required, optional, or forbidden for each endpoint.
+ */
+export type APICallParamsStrict<E extends keyof APIEndpoints> = {
+    endpoint: E;
+    options?: RequestInit;
+} & ParamsPart<E> & StrictBodyPart<E>;
+export {};

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

@@ -1,7 +1,9 @@
 import type { EventOnlineDetails } from './bookingRecords';
-import type { SiteVerticalBookingConfig } from './bookingVerticals';
 import type { CreateEventRequest } from './eventManagementContracts';
-import type { EventPricingMode, StaffMemberId, UserId } from '../../core/src/index';
+import { BOOKING_SETTINGS_SECTION_KEYS } from './bookingSettingsSections';
+import { type EventPreset } from '../../core/src/index';
+export { BOOKING_SETTINGS_SECTION_KEYS, BOOKING_SETTINGS_SECTION_LABELS, } from './bookingSettingsSections';
+import type { EventPricingMode, SiteVerticalBookingConfig, StaffMemberId, UserId } from '../../core/src/index';
 export type { EventPricingMode } from '../../core/src/index';
 /**
  * Booking Configuration Contracts
@@ -122,8 +124,6 @@ export type BookingPricingInput = {
     paymentTerms?: BookingPaymentTermsConfig;
     options?: readonly BookingPricingOptionInput[];
 };
-export type EventPreset = 'event' | 'class' | 'course' | 'workshop' | 'retreat' | 'performance';
-export type GenericEventPreset = Exclude<EventPreset, 'course'>;
 export type EventTicketTypeCapacityMode = 'limited' | 'unlimited';
 export type EventDeliveryMode = 'in_person' | 'online' | 'hybrid';
 export type EventAttendanceMode = 'in_person' | 'online';
@@ -227,18 +227,19 @@ export type EventSeriesRecord = {
     createdAt: string;
     updatedAt: string;
 };
-export type { CreateEventRecord, CreateEventRequest, EventPageAuthorityRecord, EventRecord } from './eventManagementContracts';
-export type UpdateEventSeriesRequest = Partial<Omit<CreateEventRequest, 'status' | 'preset'>> & {
-    status?: 'active' | 'draft' | 'archived' | 'cancelled' | 'completed';
-    migrationTicketTypeId?: string | null;
-    migrationTicketTypeIndex?: number | null;
+export type { CreateEventRecord, CreateEventRequest, EventCreationIntent, EventPageAuthorityRecord, EventRecord, ExplicitEventOccurrenceInput, } from './eventManagementContracts';
+export type UpdateEventSeriesRequest = Partial<Omit<CreateEventRequest, 'creationIntent' | 'initializationCommandId' | 'title'>> & {
     /**
-     * Explicitly cancel future sessions as part of archiving.
-     *
-     * Archiving does not silently auto-cancel active/future schedules. Set this
-     * flag when the caller intends a "cancel and archive" action.
+     * An empty string clears the name. A whole-series run's name is optional —
+     * an unnamed run is presented by its parent Event's title and its first
+     * session's date — so blanking it is a real edit, not an omission. Empty is
+     * the stored representation because `event_series.title` is NOT NULL and the
+     * creation path already writes `''` for an unnamed run; only a run may be
+     * unnamed, which the update service enforces by booking scope.
      */
-    cancelAndArchive?: boolean;
+    title?: string;
+    migrationTicketTypeId?: string | null;
+    migrationTicketTypeIndex?: number | null;
     /** If true, regenerate future occurrences based on updated schedule */
     regenerateSchedule?: boolean;
 };
@@ -373,7 +374,6 @@ export type AppointmentStaffNotificationSetupHealth = {
     }>;
 };
 export type PersonRecordMode = 'disabled' | 'general' | 'protected';
-export type BookingVerticalConfig = SiteVerticalBookingConfig;
 export type TeamMemberProfilePagePolicyMode = 'disabled' | 'selected' | 'all';
 export type TeamMemberProfilePageSettings = {
     policy: TeamMemberProfilePagePolicyMode;
@@ -383,7 +383,9 @@ export type { EventListingDestination, EventListingDestinationInput, PublicEvent
 export { DEFAULT_EVENT_DESTINATION_POLICY, eventDestinationModeValues, eventDestinationPresetValues, isEventDestinationMode, macadamiaDefaultEventDestinationPolicy, resolveEventDestinationMode, } from './event-destination-policy';
 export type BookingSettings = {
     modules: BookingModuleToggles;
-    verticalConfig?: BookingVerticalConfig;
+    verticalConfig?: SiteVerticalBookingConfig;
+    /** Event types available when a site has no vertical-specific catalogue. */
+    eventTypePresets?: readonly EventPreset[];
     paymentDefaults: BookingPaymentDefaults;
     /** Site-wide mode for person and encounter records. */
     personRecordMode: PersonRecordMode;
@@ -441,14 +443,6 @@ export type BookingSettings = {
 };
 export type BookingSettingsSection = 'basics' | 'payments' | 'events' | 'appointments' | 'messages';
 export declare const BOOKING_SETTINGS_SECTIONS: readonly ["basics", "payments", "events", "appointments", "messages"];
-export declare const BOOKING_SETTINGS_SECTION_LABELS: Record<BookingSettingsSection, string>;
-export declare const BOOKING_SETTINGS_SECTION_KEYS: {
-    readonly basics: readonly ["modules", "verticalConfig", "personRecordMode", "defaultTimezone", "calendarDisplay", "icsFeedsEnabled", "waitlists", "teamMemberProfilePages"];
-    readonly payments: readonly ["paymentDefaults", "currency", "refundsIssueCredit"];
-    readonly events: readonly ["defaultVenueId", "eventReminderHours", "eventReminderOverrides", "eventScheduleWindowMonths", "eventOrganizerNotifications", "eventOrganizerEmail", "eventTicketingDefaultEnabled", "collectAllAttendeeDetails", "eventBookingPolicies", "defaultEventImage", "eventDestinationPolicy"];
-    readonly appointments: readonly ["appointmentReminderHours", "appointmentReminderOverrides", "appointmentRescheduleHours", "appointmentDefaultMinLeadMinutes", "appointmentDefaultMaxBookingNoticeMinutes", "appointmentBookingPolicies"];
-    readonly messages: readonly ["remindersEnabled", "notificationSettings", "appointmentStaffReminder", "appointmentStaffChangeNotifications", "eventFeedback", "appointmentFollowUp"];
-};
 type BookingSettingsSectionValues = {
     [Section in BookingSettingsSection]: Pick<BookingSettings, (typeof BOOKING_SETTINGS_SECTION_KEYS)[Section][number]>;
 };