@checkcourt/sdk 0.4.0 → 0.6.0

package/README.md

@@ -52,6 +52,25 @@ renews it shortly before it expires. Use `apiKeyAuth(key)` for your own club's A
 `unwrap()` returns `data` or throws a `CheckCourtApiError`. Requests are retried once
 after a `401` with a fresh token and with backoff after a `429`.
 
+### Notify a member
+
+```ts
+import { sendNotification } from "@checkcourt/sdk";
+
+// Needs notifications:send. recipient: a psn_… pseudonym from an extension context,
+// the pairwise usr_… id from getMe(), or the user id if you hold members:read.
+const { id } = await sendNotification(client, {
+  recipient: claims.viewer.user_id!,
+  title: "Deine Ballmaschine ist bereit",
+  body: "Platz 3 ab 17:30 Uhr.",
+  url: "/booking?date=2026-05-01",
+  idempotencyKey: "reservation-8812-ready",
+});
+```
+
+CheckCourt delivers the message in the member's inbox and by email if they allow it. Your
+app never learns contact data or whether the member muted it.
+
 ### Verify a webhook
 
 ```ts
@@ -74,6 +93,28 @@ export async function POST(request: Request) {
 `verifyWebhook` throws a `WebhookSignatureError` when the signature or timestamp does not
 check out. Deduplicate on `event.id`: retries carry the same id.
 
+### Share data and events with other apps (club apps)
+
+Apps never call each other. They declare in the manifest what they share (`shares`, `emits`) and
+what they want from other apps (`reads`, `subscribes`); CheckCourt passes the data on once the club
+approves the connection.
+
+```ts
+import { getObjectMetadata, isAppEvent, publishAppEvent, putObjectMetadata } from "@checkcourt/sdk";
+
+// Producer: attach a value to a booking (key declared under shares.metadata).
+await putObjectMetadata(client, "booking", bookingId, "video_url", "https://video.example/abc");
+// Producer: publish an event declared under emits.
+await publishAppEvent(client, { name: "door_opened", data: { court_id: 3 } });
+
+// Consumer: read your own and approved values of other apps, grouped by app slug.
+const { metadata } = await getObjectMetadata(client, "booking", bookingId);
+const videoUrl = metadata["wingfield"]?.["video_url"]?.value;
+
+// Consumer webhook: events of other apps arrive as `app.<slug>.<name>`.
+if (isAppEvent<{ court_id: number }>(event, "door-co", "door_opened")) console.log(event.data.court_id);
+```
+
 ### Declarative extensions and the `ui` builder
 
 ```ts
@@ -126,10 +167,66 @@ return Response.json(ui.doc([ui.stat("Battery", `${level} %`)], { maxAge: 0 }));
 A `Cache-Control` response header (`no-store`, `max-age=N`) works too; `maxAge` wins when
 both are set. In your sandbox club nothing is cached.
 
+Forms collect input for an action. A text field becomes a multi-line box with `multiline`
+(and an optional `rows`, 1 to 12); the submitted value stays a string:
+
+```ts
+ui.form({
+  actionId: "report",
+  submitLabel: "Meldung senden",
+  fields: [ui.field.text("message", "Platzproblem melden", { multiline: true, rows: 4, max_length: 500 })],
+});
+```
+
+`ui.field.date` and `ui.field.time` render native date and time pickers. `default`, `min` and
+`max` are `YYYY-MM-DD` strings for dates and `HH:MM` (24-hour) strings for times; `time` takes an
+optional `step` in minutes. Both submit their value as a string:
+
+```ts
+ui.form({
+  actionId: "block",
+  submitLabel: "Sperren",
+  fields: [
+    ui.field.date("day", "Tag", { min: "2026-01-01", required: true }),
+    ui.field.time("from", "Von", { min: "07:00", max: "22:00", step: 30, required: true }),
+  ],
+});
+```
+
 Compare `context.installation_id` and `context.tenant_id` with what you stored from
 `app.installed` before you act on a request. For the context token alone (for example in
 the backend of an iframe extension), use `verifyExtensionContext(token, secret)`.
 
+### Host surfaces
+
+Some points are drawn by CheckCourt itself and only ask your app for a few words. Answer them
+with the matching builder; each throws when the answer would break CheckCourt's limits.
+
+| Point | Request carries | Answer with |
+|---|---|---|
+| `court.annotation` | `ext.date`, `ext.courts` | `ui.annotations([{ court_id, label, variant? }])`, label up to 24 characters, one per court |
+| `member.list.column` | `ext.members` | `ui.column({ title, values: [{ member_id, text, variant? }] })`, title up to 20, text up to 24 characters |
+| `booking.hint` | `ext.draft` | `ui.hint([...])` with up to 6 text, badge, key_value or link blocks; answer within 1 second |
+| `booking_plan.action` | `ext.date`, `ext.courts` (and the day as subject) | `ui.doc([...])`, shown in a dialog after a click; `ui.hidden()` closes it |
+| `sidebar.action` | nothing extra | `ui.doc([...])`, shown in a dialog after a click; `ui.hidden()` closes it |
+| `member.settings.section` | nothing extra | `ui.doc([...])`, a card on the member's own settings page |
+
+```ts
+if (ext.kind === "render" && ext.point === "court.annotation" && ext.date && ext.courts) {
+  const wet = await wetCourts(ext.date);
+  return Response.json(
+    ui.annotations(
+      ext.courts.filter((c) => wet.has(c.id)).map((c) => ({ court_id: c.id, label: "Nass", variant: "secondary" })),
+      { maxAge: 300 },
+    ),
+  );
+}
+```
+
+`booking_plan.action` and `sidebar.action` need a `label` (at most 24 characters) in the
+manifest and may set an `icon` from `APP_ACTION_ICONS`. In every declarative document,
+CheckCourt places content first, then the buttons, then the links of each level.
+
 ### OAuth with PKCE (member apps)
 
 ```ts
@@ -183,7 +280,7 @@ Import the browser entry point `@checkcourt/sdk/iframe` only; it needs no secret
 | `@checkcourt/sdk` | Server | Everything except the iframe part |
 | `@checkcourt/sdk/oauth` | Server | OAuth and installation tokens |
 | `@checkcourt/sdk/webhooks` | Server, edge | Webhook verification and event types |
-| `@checkcourt/sdk/extensions` | Server, edge | Context tokens, request verification, UI builder |
+| `@checkcourt/sdk/extensions` | Server, edge | Context tokens, request verification, UI builder, host surface builders |
 | `@checkcourt/sdk/manifest` | Anywhere | `defineManifest` and constants |
 | `@checkcourt/sdk/iframe` | Browser | `connectExtensionFrame` and messages |
 

package/dist/connections.d.ts

@@ -0,0 +1,28 @@
+import { type CheckCourtClient } from "./client.js";
+import type { components } from "./generated/schema.js";
+import type { SharedObjectType } from "./manifest.js";
+export type ObjectMetadata = components["schemas"]["ObjectMetadata"];
+export type ObjectMetadataEntry = components["schemas"]["ObjectMetadataEntry"];
+export type ObjectMetadataWritten = components["schemas"]["ObjectMetadataWritten"];
+export type PublishAppEventRequest = components["schemas"]["PublishAppEventRequest"];
+export type PublishedAppEvent = components["schemas"]["PublishedAppEvent"];
+/**
+ * `GET /api/v1/{bookings|courts|members}/{id}/metadata`: your app's own values on the object plus
+ * those of other apps you declare under `reads.metadata` and the club connected to yours, grouped
+ * by app slug. Club installation tokens (`cca_`) only.
+ */
+export declare function getObjectMetadata(client: CheckCourtClient, objectType: SharedObjectType, id: string | number): Promise<ObjectMetadata>;
+/**
+ * `PUT …/{id}/metadata/{key}`: writes one of your keys declared under `shares.metadata`. Any JSON
+ * value except `null`, at most 4096 bytes serialized. Connected readers get `app.metadata_changed`.
+ */
+export declare function putObjectMetadata(client: CheckCourtClient, objectType: SharedObjectType, id: string | number, key: string, value: unknown): Promise<ObjectMetadataWritten>;
+/** `DELETE …/{id}/metadata/{key}`: removes your own value; `deleted: false` when there was none. */
+export declare function deleteObjectMetadata(client: CheckCourtClient, objectType: SharedObjectType, id: string | number, key: string): Promise<{
+    deleted: boolean;
+}>;
+/**
+ * `POST /api/v1/app/events`: publishes an event declared under `emits`. Subscribed apps the club
+ * connected to yours receive it as `app.<your slug>.<name>`. At most 60 per minute per installation.
+ */
+export declare function publishAppEvent(client: CheckCourtClient, event: PublishAppEventRequest): Promise<PublishedAppEvent>;

package/dist/connections.js

@@ -0,0 +1,55 @@
+import { unwrap } from "./client.js";
+function courtId(id) {
+    const n = typeof id === "number" ? id : Number(id);
+    if (!Number.isSafeInteger(n))
+        throw new TypeError(`Court ids are integers, got ${String(id)}`);
+    return n;
+}
+/**
+ * `GET /api/v1/{bookings|courts|members}/{id}/metadata`: your app's own values on the object plus
+ * those of other apps you declare under `reads.metadata` and the club connected to yours, grouped
+ * by app slug. Club installation tokens (`cca_`) only.
+ */
+export async function getObjectMetadata(client, objectType, id) {
+    switch (objectType) {
+        case "booking":
+            return unwrap(client.GET("/bookings/{id}/metadata", { params: { path: { id: String(id) } } }));
+        case "court":
+            return unwrap(client.GET("/courts/{id}/metadata", { params: { path: { id: courtId(id) } } }));
+        case "member":
+            return unwrap(client.GET("/members/{id}/metadata", { params: { path: { id: String(id) } } }));
+    }
+}
+/**
+ * `PUT …/{id}/metadata/{key}`: writes one of your keys declared under `shares.metadata`. Any JSON
+ * value except `null`, at most 4096 bytes serialized. Connected readers get `app.metadata_changed`.
+ */
+export async function putObjectMetadata(client, objectType, id, key, value) {
+    const body = { value };
+    switch (objectType) {
+        case "booking":
+            return unwrap(client.PUT("/bookings/{id}/metadata/{key}", { params: { path: { id: String(id), key } }, body }));
+        case "court":
+            return unwrap(client.PUT("/courts/{id}/metadata/{key}", { params: { path: { id: courtId(id), key } }, body }));
+        case "member":
+            return unwrap(client.PUT("/members/{id}/metadata/{key}", { params: { path: { id: String(id), key } }, body }));
+    }
+}
+/** `DELETE …/{id}/metadata/{key}`: removes your own value; `deleted: false` when there was none. */
+export async function deleteObjectMetadata(client, objectType, id, key) {
+    switch (objectType) {
+        case "booking":
+            return unwrap(client.DELETE("/bookings/{id}/metadata/{key}", { params: { path: { id: String(id), key } } }));
+        case "court":
+            return unwrap(client.DELETE("/courts/{id}/metadata/{key}", { params: { path: { id: courtId(id), key } } }));
+        case "member":
+            return unwrap(client.DELETE("/members/{id}/metadata/{key}", { params: { path: { id: String(id), key } } }));
+    }
+}
+/**
+ * `POST /api/v1/app/events`: publishes an event declared under `emits`. Subscribed apps the club
+ * connected to yours receive it as `app.<your slug>.<name>`. At most 60 per minute per installation.
+ */
+export async function publishAppEvent(client, event) {
+    return unwrap(client.POST("/app/events", { body: event }));
+}

package/dist/events.d.ts

@@ -67,6 +67,46 @@ export interface WebhookEventOf<T extends EventType> {
     };
     data: EventDataMap[T];
 }
+/** `data` of `app.metadata_changed`: another app changed or removed a value your app reads. */
+export interface AppMetadataChangedEventData {
+    object_type: "booking" | "court" | "member";
+    object_id: string;
+    /** Slug of the app that wrote the value. */
+    app: string;
+    key: string;
+    /** True when the value was removed. */
+    deleted: boolean;
+}
+export declare const METADATA_CHANGED_EVENT_TYPE = "app.metadata_changed";
+/** Type of an event one app publishes to others: `app.<publishing app slug>.<name>`. */
+export type AppEventType = `app.${string}.${string}`;
+interface ConnectionEventEnvelope<T extends string, D> {
+    id: string;
+    type: T;
+    created_at: string;
+    tenant_id: string;
+    installation_id?: string;
+    /** The `subject` the publisher gave, otherwise its own installation (`app_installation`). */
+    object: {
+        type: EventObjectType | (string & {});
+        id: string;
+    };
+    data: D;
+}
+/** Sent to apps the club connected to the writer, for keys they declare under `reads.metadata`. Read the value with `getObjectMetadata`. */
+export type AppMetadataChangedEvent = ConnectionEventEnvelope<typeof METADATA_CHANGED_EVENT_TYPE, AppMetadataChangedEventData>;
+/** An event of another app, delivered when you declare it under `subscribes` and the club approved the connection. */
+export type AppEvent<D extends Record<string, unknown> = Record<string, unknown>> = ConnectionEventEnvelope<AppEventType, D>;
+/** Events between apps; CheckCourt delivers them only along connections the club approved. */
+export type ConnectionEvent = AppMetadataChangedEvent | AppEvent;
 export type WebhookEvent = {
     [T in EventType]: WebhookEventOf<T>;
-}[EventType];
+}[EventType] | ConnectionEvent;
+export declare function appEventType(appSlug: string, name: string): AppEventType;
+/**
+ * Narrows to an event published by another app, optionally a specific one:
+ * `if (isAppEvent<DoorOpened>(event, "door-co", "door_opened")) event.data.court_id`.
+ */
+export declare function isAppEvent<D extends Record<string, unknown> = Record<string, unknown>>(event: WebhookEvent, appSlug?: string, name?: string): event is AppEvent<D>;
+export declare function isMetadataChangedEvent(event: WebhookEvent): event is AppMetadataChangedEvent;
+export {};

package/dist/events.js

@@ -22,3 +22,20 @@ export const EVENT_TYPES = [
     "webhook.test",
     ...APP_LIFECYCLE_EVENT_TYPES,
 ];
+export const METADATA_CHANGED_EVENT_TYPE = "app.metadata_changed";
+export function appEventType(appSlug, name) {
+    return `app.${appSlug}.${name}`;
+}
+/**
+ * Narrows to an event published by another app, optionally a specific one:
+ * `if (isAppEvent<DoorOpened>(event, "door-co", "door_opened")) event.data.court_id`.
+ */
+export function isAppEvent(event, appSlug, name) {
+    const match = /^app\.([a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\.([a-z][a-z0-9_]*)$/.exec(event.type);
+    if (!match)
+        return false;
+    return (appSlug === undefined || match[1] === appSlug) && (name === undefined || match[2] === name);
+}
+export function isMetadataChangedEvent(event) {
+    return event.type === METADATA_CHANGED_EVENT_TYPE;
+}

package/dist/extensions.d.ts

@@ -3,14 +3,15 @@ import type { UiFormValues } from "./ui.js";
 import { type RawBody } from "./webhooks.js";
 export * from "./ui.js";
 export { ExtensionVerificationError, type ExtensionVerificationFailure } from "./errors.js";
-export { EXTENSION_POINTS, type ExtensionKind, type ExtensionPoint } from "./manifest.js";
+export { EXTENSION_POINTS, STATIC_ACTION_POINTS, type ExtensionKind, type ExtensionPoint, type StaticActionPoint, } from "./manifest.js";
 export declare const CONTEXT_HEADER = "CheckCourt-Context";
 export declare const CONTEXT_ISSUER = "checkcourt";
 export declare const CONTEXT_TTL_SECONDS = 300;
 export declare const CLOCK_LEEWAY_SECONDS = 30;
 /** `action_id` a `booking.action` button sends when it is clicked. */
 export declare const BOOKING_ACTION_INVOKE = "invoke";
-export type ExtensionSubjectType = "booking" | "member" | "installation";
+/** "booking_plan": the plan of one day; its id is the date (YYYY-MM-DD). */
+export type ExtensionSubjectType = "booking" | "member" | "installation" | "booking_plan";
 export interface ExtensionSubject {
     type: ExtensionSubjectType;
     id: string;
@@ -33,6 +34,12 @@ export interface DashboardCapabilities {
 export interface AppSettingsCapabilities {
     can_manage_app: boolean;
 }
+export interface MemberListCapabilities {
+    can_edit_members: boolean;
+}
+export interface BookingPlanCapabilities {
+    can_edit_bookings: boolean;
+}
 export interface PointCapabilities {
     "app.settings": AppSettingsCapabilities;
     "booking.detail.panel": BookingCapabilities;
@@ -40,6 +47,12 @@ export interface PointCapabilities {
     "member.profile.section": MemberCapabilities;
     "dashboard.widget": DashboardCapabilities;
     "kiosk.tile": Record<string, never>;
+    "court.annotation": Record<string, never>;
+    "member.list.column": MemberListCapabilities;
+    "member.settings.section": Record<string, never>;
+    "booking.hint": Record<string, never>;
+    "booking_plan.action": BookingPlanCapabilities;
+    "sidebar.action": Record<string, never>;
 }
 export interface PointSubject {
     "app.settings": {
@@ -60,6 +73,16 @@ export interface PointSubject {
     };
     "dashboard.widget": null;
     "kiosk.tile": null;
+    "court.annotation": null;
+    "member.list.column": null;
+    "member.settings.section": null;
+    "booking.hint": null;
+    /** `id` is the plan's day, YYYY-MM-DD. */
+    "booking_plan.action": {
+        type: "booking_plan";
+        id: string;
+    };
+    "sidebar.action": null;
 }
 interface ContextClaimsOf<P extends ExtensionPoint> {
     iss: typeof CONTEXT_ISSUER;
@@ -92,12 +115,44 @@ export type ExtensionContextClaims = {
 export declare function verifyExtensionContext(token: string, secret: string, options?: {
     now?: Date | number;
 }): Promise<ExtensionContextClaims>;
+/** A court of the plan a `court.annotation` or `booking_plan.action` request covers. */
+export interface AnnotationCourt {
+    id: number;
+    name: string;
+}
+/** A member on the visible page of the member list. */
+export interface ColumnMember {
+    /** The club membership id, as `member_id` in `member.*` events; key your column values by it. */
+    member_id: string;
+    user_id: string;
+}
+export declare const BOOKING_DRAFT_TYPES: readonly ["regular", "training", "mannschaft"];
+export type BookingDraftType = (typeof BOOKING_DRAFT_TYPES)[number];
+/** The booking a member is about to confirm, sent with `booking.hint`. */
+export interface BookingDraft {
+    court_id: number;
+    /** YYYY-MM-DD. */
+    date: string;
+    /** HH:MM. */
+    start_time: string;
+    /** HH:MM. */
+    end_time: string;
+    type: BookingDraftType;
+}
 /** Body of a declarative render request. */
 export interface ExtensionRenderRequest {
     kind: "render";
     context: ExtensionContextClaims;
     point: ExtensionPoint;
     subject: ExtensionSubject | null;
+    /** `court.annotation` and `booking_plan.action`: the plan's day, YYYY-MM-DD. */
+    date?: string;
+    /** `court.annotation` (one document for all) and `booking_plan.action`: every court of the plan. */
+    courts?: AnnotationCourt[];
+    /** `member.list.column`: the members on the visible page. */
+    members?: ColumnMember[];
+    /** `booking.hint`: the booking being drafted. */
+    draft?: BookingDraft;
 }
 /** Body of a button click or form submission. `values` is `{}` for buttons. */
 export interface ExtensionActionRequest {
@@ -107,13 +162,19 @@ export interface ExtensionActionRequest {
     subject: ExtensionSubject | null;
     actionId: string;
     values: UiFormValues;
+    /** `booking_plan.action`: the plan's day, YYYY-MM-DD. */
+    date?: string;
+    /** `booking_plan.action`: every court of the plan, so a form can offer a court select. */
+    courts?: AnnotationCourt[];
 }
 export type ExtensionRequest = ExtensionRenderRequest | ExtensionActionRequest;
 type HeaderSource = Headers | Record<string, string | string[] | undefined>;
 /**
  * Verifies a declarative extension POST: the `CheckCourt-Signature` over the raw body (it binds
  * `action_id` and `values` to the token), the context token, and that body, header token and
- * claims agree. Throws `ExtensionVerificationError`.
+ * claims agree. Renders at `court.annotation`, `member.list.column` and `booking.hint` also
+ * carry `date` and `courts`, `members` or `draft`; `booking_plan.action` renders and actions
+ * carry the plan's `date` and `courts`. Throws `ExtensionVerificationError`.
  */
 export declare function verifyExtensionRequest(options: {
     secret: string;

package/dist/extensions.js

@@ -4,7 +4,7 @@ import { hmacSha256Verify } from "./internal/hmac.js";
 import { SIGNATURE_HEADER, verifySignature } from "./webhooks.js";
 export * from "./ui.js";
 export { ExtensionVerificationError } from "./errors.js";
-export { EXTENSION_POINTS } from "./manifest.js";
+export { EXTENSION_POINTS, STATIC_ACTION_POINTS, } from "./manifest.js";
 export const CONTEXT_HEADER = "CheckCourt-Context";
 export const CONTEXT_ISSUER = "checkcourt";
 export const CONTEXT_TTL_SECONDS = 300;
@@ -65,6 +65,7 @@ export async function verifyExtensionContext(token, secret, options = {}) {
         throw fail("expired", "Token has expired");
     return claims;
 }
+export const BOOKING_DRAFT_TYPES = ["regular", "training", "mannschaft"];
 function header(headers, name) {
     if (typeof headers.get === "function")
         return headers.get(name) ?? undefined;
@@ -80,10 +81,65 @@ function sameSubject(a, b) {
         return a === b;
     return a.type === b.type && a.id === b.id;
 }
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+const TIME = /^\d{2}:\d{2}$/;
+const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** Parses the `date` and `courts` a court.annotation or booking_plan.action request carries. */
+function planCourts(body) {
+    const { date, courts } = body;
+    if (typeof date !== "string" || !DATE.test(date))
+        throw fail("invalid_body", "date is not YYYY-MM-DD");
+    if (!Array.isArray(courts) || !courts.every((c) => isObject(c) && typeof c.id === "number" && typeof c.name === "string")) {
+        throw fail("invalid_body", "courts is not a list of { id, name }");
+    }
+    return { date, courts: courts.map((c) => ({ id: c.id, name: c.name })) };
+}
+function surfaceFields(point, body) {
+    switch (point) {
+        case "court.annotation":
+        case "booking_plan.action":
+            return planCourts(body);
+        case "member.list.column": {
+            const { members } = body;
+            if (!Array.isArray(members) ||
+                !members.every((m) => isObject(m) && typeof m.member_id === "string" && typeof m.user_id === "string")) {
+                throw fail("invalid_body", "members is not a list of { member_id, user_id }");
+            }
+            return { members: members.map((m) => ({ member_id: m.member_id, user_id: m.user_id })) };
+        }
+        case "booking.hint": {
+            const d = body.draft;
+            if (!isObject(d) ||
+                typeof d.court_id !== "number" ||
+                typeof d.date !== "string" ||
+                !DATE.test(d.date) ||
+                typeof d.start_time !== "string" ||
+                !TIME.test(d.start_time) ||
+                typeof d.end_time !== "string" ||
+                !TIME.test(d.end_time) ||
+                typeof d.type !== "string") {
+                throw fail("invalid_body", "draft is not a booking draft");
+            }
+            return {
+                draft: {
+                    court_id: d.court_id,
+                    date: d.date,
+                    start_time: d.start_time,
+                    end_time: d.end_time,
+                    type: d.type,
+                },
+            };
+        }
+        default:
+            return {};
+    }
+}
 /**
  * Verifies a declarative extension POST: the `CheckCourt-Signature` over the raw body (it binds
  * `action_id` and `values` to the token), the context token, and that body, header token and
- * claims agree. Throws `ExtensionVerificationError`.
+ * claims agree. Renders at `court.annotation`, `member.list.column` and `booking.hint` also
+ * carry `date` and `courts`, `members` or `draft`; `booking_plan.action` renders and actions
+ * carry the plan's `date` and `courts`. Throws `ExtensionVerificationError`.
  */
 export async function verifyExtensionRequest(options) {
     try {
@@ -121,7 +177,7 @@ export async function verifyExtensionRequest(options) {
         throw fail("context_mismatch", "point or subject differ from the context token");
     }
     if (body.action_id === undefined)
-        return { kind: "render", context, point: context.point, subject };
+        return { kind: "render", context, point: context.point, subject, ...surfaceFields(context.point, body) };
     if (typeof body.action_id !== "string")
         throw fail("invalid_body", "action_id is not a string");
     const values = body.values ?? {};
@@ -134,5 +190,6 @@ export async function verifyExtensionRequest(options) {
         subject,
         actionId: body.action_id,
         values: values,
+        ...(context.point === "booking_plan.action" ? planCourts(body) : {}),
     };
 }