@riverbankcms/sdk 0.129.1 → 0.130.2

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/appointmentSetup.d.ts

@@ -105,9 +105,13 @@ export declare const appointmentSetupVenueChoiceSchema: z.ZodDiscriminatedUnion<
     }, z.core.$strip>>;
 }, z.core.$strip>], "kind">;
 export type AppointmentSetupVenueChoice = z.infer<typeof appointmentSetupVenueChoiceSchema>;
-export declare const appointmentSetupPaymentDraftSchema: z.ZodObject<{
-    priceType: z.ZodUnion<readonly [z.ZodLiteral<"free">, z.ZodLiteral<"paid">]>;
-}, z.core.$strip>;
+export declare const appointmentSetupPaymentDraftSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"free">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"paid_online">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"paid_offline">;
+}, z.core.$strip>], "kind">;
 export type AppointmentSetupPaymentDraft = z.infer<typeof appointmentSetupPaymentDraftSchema>;
 export declare const appointmentSetupServiceAssignmentDraftSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"all_practitioners">;
@@ -156,9 +160,13 @@ export declare const appointmentSetupServiceDraftSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>], "kind">;
     timezone: z.ZodNullable<z.ZodString>;
-    payment: z.ZodObject<{
-        priceType: z.ZodUnion<readonly [z.ZodLiteral<"free">, z.ZodLiteral<"paid">]>;
-    }, z.core.$strip>;
+    payment: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"free">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"paid_online">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"paid_offline">;
+    }, z.core.$strip>], "kind">;
     assignment: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"all_practitioners">;
     }, z.core.$strip>, z.ZodObject<{
@@ -283,9 +291,13 @@ export declare const applyAppointmentSetupRequestSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strip>], "kind">;
         timezone: z.ZodNullable<z.ZodString>;
-        payment: z.ZodObject<{
-            priceType: z.ZodUnion<readonly [z.ZodLiteral<"free">, z.ZodLiteral<"paid">]>;
-        }, z.core.$strip>;
+        payment: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"free">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"paid_online">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"paid_offline">;
+        }, z.core.$strip>], "kind">;
         assignment: z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"all_practitioners">;
         }, z.core.$strip>, z.ZodObject<{