@wix/agent-skills 1.36.0 → 1.36.1

package/skills/wix-vibe-headless/references/bookings/app/rest/wix-bookings-services.js

@@ -1,300 +0,0 @@
-import { wixApiRequest } from "./wix-client.js";
-
-// Data model reference: see INSTRUCTIONS.md
-
-/**
- * Wix Bookings Service (Services V2) — key fields for the services list and booking UI.
- * This skill ships the APPOINTMENT flow; CLASS/COURSE are "Beyond the snippets".
- * Full model: https://dev.wix.com/docs/api-reference/business-solutions/bookings/services/services-v2/query-services.md
- *
- *   id {string}, type "APPOINTMENT"|"CLASS"|"COURSE", name {string}, tagLine {string},
- *   description {string}, hidden {boolean},
- *   defaultCapacity {number} — bookable seats per session; 1 for a typical appointment,
- *   media.mainMedia.image { id, url, width, height, altText } — the PRIMARY service image (what the
- *     seed sets and the card shows); media.items {array} is the gallery, media.coverMedia the cover.
- *     Read mainMedia first, fall back to items[0]/coverMedia. url may be a bare Wix media handle —
- *     pass through mediaUrl() before rendering,
- *   mainSlug.name {string} — merchant-facing slug ("swedish-massage"). This client routes on the
- *     service id; switching to slugs means changing the shipped route too,
- *   payment.rateType "FIXED"|"CUSTOM"|"VARIED"|"NO_FEE"|"SUBSCRIPTION" — branch on this before
- *     reading a price. Use servicePriceLabel() from lib/serviceFacts.js instead of payment.fixed
- *     directly, or VARIED and NO_FEE services render with no price,
- *   payment.fixed.price { value, currency, formattedValue } — value + currency are always
- *     present; formattedValue is optional (may be missing), so format the price from
- *     value+currency and use formattedValue only when present,
- *   payment.varied { defaultPrice, minPrice, maxPrice } — Money each, same shape as fixed.price,
- *   payment.options { online, inPerson, deposit, pricingPlan } — how a customer may PAY. `online`
- *     here means "can pay online", NOT that the service happens online; don't build a location
- *     label from it,
- *   conferencing.enabled {boolean} — a video service; this is the real "online" signal,
- *   schedule.id {string},
- *   schedule.availabilityConstraints.sessionDurations {number[]} — session minutes for an
- *     APPOINTMENT, empty for CLASS/COURSE; see serviceDuration(),
- *   onlineBooking { enabled, requireManualApproval } — requireManualApproval means the business
- *     confirms the booking after the fact, so the CTA is a request, not a confirmation,
- *   category { id, name } — a service with no category is not visible on the live site,
- *   staffMemberIds {string[]},
- *   locations {array} — [{ id, type "BUSINESS"|"CUSTOMER"|"CUSTOM", calculatedAddress }]. The type is
- *     where the service happens; calculatedAddress is empty for CUSTOMER and often absent until the
- *     business configures a location. See serviceLocationLabel(),
- *   bookingPolicy.participantsPolicy { enabled {boolean}, maxParticipantsPerBooking {number} }
- *     — the MOST participants a single booking may reserve. Cap the participant selector at this
- *     value (for a CLASS, also bound by the slot's remainingCapacity). It is commonly 1, in which
- *     case there is no participant choice at all — book exactly 1. Sending totalParticipants above
- *     this makes createBooking fail.
- *   bookingPolicy.reschedulePolicy / .cancellationPolicy { enabled, limitLatestReschedule /
- *     limitLatestCancellation, latestRescheduleInMinutes / latestCancellationInMinutes } — see
- *     serviceRescheduleNote(),
- *
- * TimeSlot (Time Slots V2, appointments):
- *   serviceId {string}, localStartDate {string}, localEndDate {string} — "YYYY-MM-DDThh:mm:ss" (no zone),
- *   bookable {boolean}, scheduleId {string},
- *   location { id, name, formattedAddress, locationType "BUSINESS"|"CUSTOM"|"CUSTOMER" },
- *   totalCapacity {number}, remainingCapacity {number},
- *   bookableCapacity {number} — CLASS slots: seats still bookable after policy limits, which can be
- *     lower than remainingCapacity,
- *   bookingPolicyViolations { tooEarlyToBook, tooLateToBook, bookOnlineDisabled } — why a listed slot
- *     still isn't bookable; only reachable if you drop the `bookable: true` filter,
- *   availableResources {array} — staff. getAvailableSlot populates it for an APPOINTMENT; a
- *     CLASS/COURSE slot already carries it from the list call,
- *   eventInfo { eventId, eventTitle } — CLASS/COURSE only; those slots have no scheduleId
- * Full model: https://dev.wix.com/docs/api-reference/business-solutions/bookings/time-slots/time-slots-v2/list-availability-time-slots.md
- */
-
-/** The visitor's local IANA time zone — used as the default for availability queries. */
-function defaultTimeZone() {
-  try {
-    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
-  } catch {
-    return "UTC";
-  }
-}
-
-/**
- * Resolve a service image to an absolute URL. Wix media fields are sometimes a bare
- * handle ("abc.jpg") rather than a full URL; this prefixes the Wix static host.
- * @param {{ url?: string, id?: string }|string} image
- * @returns {string|null}
- */
-export function mediaUrl(image) {
-  const raw = typeof image === "string" ? image : image?.url || image?.id;
-  if (!raw) return null;
-  if (raw.startsWith("http")) return raw;
-  if (raw.startsWith("wix:image://")) {
-    const stripped = raw.slice("wix:image://".length).replace(/^v1\//, "");
-    return `https://static.wixstatic.com/media/${stripped.split("#")[0].split("/")[0]}`;
-  }
-  return `https://static.wixstatic.com/media/${raw}`;
-}
-
-/**
- * Query bookable services (one page). Returns only services visible to visitors (hidden:false).
- * https://dev.wix.com/docs/api-reference/business-solutions/bookings/services/services-v2/query-services.md
- * @param {{ limit?: number, offset?: number }} [options]
- * @returns {Promise<{ services: object[], total: number, nextOffset: number|null }>}
- */
-export async function queryServices({ limit = 100, offset = 0 } = {}) {
-  const res = await wixApiRequest("/bookings/v2/services/query", {
-    method: "POST",
-    body: {
-      query: {
-        filter: { hidden: false },
-        paging: { limit, offset },
-      },
-    },
-  });
-  const services = res?.services ?? [];
-  const total = res?.pagingMetadata?.total ?? services.length;
-  const loaded = offset + services.length;
-  return { services, total, nextOffset: loaded < total ? loaded : null };
-}
-
-/**
- * Query visitor-visible services in one category, for a category-filtered listing.
- * The filter key is the dotted path `category.id` — a bare `categoryId` is rejected as an unknown
- * field.
- * @param {string} categoryId
- * @param {{ limit?: number, offset?: number }} [options]
- * @returns {Promise<{ services: object[], total: number, nextOffset: number|null }>}
- */
-export async function queryServicesByCategory(categoryId, { limit = 100, offset = 0 } = {}) {
-  const res = await wixApiRequest("/bookings/v2/services/query", {
-    method: "POST",
-    body: {
-      query: {
-        filter: { hidden: false, "category.id": categoryId },
-        paging: { limit, offset },
-      },
-    },
-  });
-  const services = res?.services ?? [];
-  const total = res?.pagingMetadata?.total ?? services.length;
-  const loaded = offset + services.length;
-  return { services, total, nextOffset: loaded < total ? loaded : null };
-}
-
-/**
- * The categories that visitor-visible services actually belong to, in the order Wix sorts them.
- * Derived from a services page rather than the Categories API, so the menu can never list a category
- * with nothing bookable in it.
- * @param {object[]} services
- * @returns {{ id: string, name: string }[]}
- */
-export function categoriesOf(services) {
-  const byId = new Map();
-  for (const s of services || []) {
-    const c = s?.category;
-    if (c?.id && !byId.has(c.id)) byId.set(c.id, { id: c.id, name: c.name, sortOrder: c.sortOrder ?? 0 });
-  }
-  return [...byId.values()]
-    .sort((a, b) => a.sortOrder - b.sortOrder)
-    .map(({ id, name }) => ({ id, name }));
-}
-
-/**
- * Fetch a single service by its GUID. Returns null if not found.
- * @param {string} serviceId
- * @returns {Promise<object|null>}
- */
-export async function getService(serviceId) {
-  const res = await wixApiRequest("/bookings/v2/services/query", {
-    method: "POST",
-    body: { query: { filter: { id: serviceId }, paging: { limit: 1 } } },
-  });
-  return res?.services?.[0] ?? null;
-}
-
-/**
- * Total number of visitor-visible services. Used for empty-state logic.
- * @returns {Promise<number>}
- */
-export async function countServices() {
-  const res = await wixApiRequest("/bookings/v2/services/query", {
-    method: "POST",
-    body: { query: { filter: { hidden: false }, paging: { limit: 1 } } },
-  });
-  return res?.pagingMetadata?.total ?? (res?.services?.length ?? 0);
-}
-
-/**
- * List bookable time slots for an **APPOINTMENT** service within a local date range (availability
- * comes from staff working hours). For **CLASS / COURSE** services (booked against scheduled
- * sessions) use `listEventTimeSlots` — this endpoint returns an empty list for them, silently.
- * If you render a mixed catalog, route by `service.type` via `listSlotsForService`.
- * Dates are LOCAL ("YYYY-MM-DDThh:mm:ss") in timeZone.
- * https://dev.wix.com/docs/api-reference/business-solutions/bookings/time-slots/time-slots-v2/list-availability-time-slots.md
- * For a rental (a resource-driven service), pass its resource type id(s) as `includeResourceTypeIds`
- * so the slots come back with their bookable resources; a staff appointment can omit it.
- * @param {string} serviceId
- * @param {{ fromLocalDate: string, toLocalDate: string, timeZone?: string, limit?: number, cursor?: string, includeResourceTypeIds?: string[] }} options
- * @returns {Promise<{ slots: object[], nextCursor: string|null, timeZone: string|null }>}
- */
-export async function listAvailableSlots(serviceId, { fromLocalDate, toLocalDate, timeZone, limit = 1000, cursor, includeResourceTypeIds } = {}) {
-  if (!cursor && (!fromLocalDate || !toLocalDate)) {
-    throw new Error("listAvailableSlots requires fromLocalDate and toLocalDate (local 'YYYY-MM-DDThh:mm:ss').");
-  }
-  const body = cursor
-    ? { cursorPaging: { limit, cursor } }
-    : {
-        serviceId,
-        bookable: true,
-        fromLocalDate,
-        toLocalDate,
-        timeZone: timeZone || defaultTimeZone(),
-        cursorPaging: { limit },
-        ...(includeResourceTypeIds?.length ? { includeResourceTypeIds } : {}),
-      };
-  const res = await wixApiRequest("/_api/service-availability/v2/time-slots", { method: "POST", body });
-  return {
-    slots: res?.timeSlots ?? [],
-    nextCursor: res?.cursorPagingMetadata?.cursors?.next ?? null,
-    // The zone the returned localStartDate strings are in — label the picker with this, so the times
-    // on screen and the zone named beside them can't disagree.
-    timeZone: res?.timeZone ?? null,
-  };
-}
-
-/**
- * Re-validate a specific appointment slot right before booking, and fetch its available
- * resources (staff). Always re-check before createBooking — slots can be taken between listing
- * and booking. Returns the slot or null if it's gone.
- * https://dev.wix.com/docs/api-reference/business-solutions/bookings/time-slots/time-slots-v2/get-availability-time-slot.md
- * @param {string} serviceId
- * @param {{ localStartDate: string, localEndDate: string, timeZone?: string, location?: object }} options
- * @returns {Promise<object|null>}
- */
-export async function getAvailableSlot(serviceId, { localStartDate, localEndDate, timeZone, location } = {}) {
-  if (!localStartDate || !localEndDate) {
-    throw new Error("getAvailableSlot requires localStartDate and localEndDate.");
-  }
-  const res = await wixApiRequest("/_api/service-availability/v2/time-slots/get", {
-    method: "POST",
-    body: {
-      serviceId,
-      localStartDate,
-      localEndDate,
-      timeZone: timeZone || defaultTimeZone(),
-      ...(location ? { location } : {}),
-    },
-  });
-  return res?.timeSlot ?? null;
-}
-
-/**
- * List bookable session slots for **CLASS / COURSE** services within a local date range. These
- * services are booked against scheduled sessions (calendar events), not staff working hours, so
- * they use a different endpoint than appointments. Each returned slot carries `eventInfo.eventId`
- * (the session) and has **no** `scheduleId` — `createBooking` reads that `eventId`.
- * Dates are LOCAL ("YYYY-MM-DDThh:mm:ss") in timeZone.
- * https://dev.wix.com/docs/api-reference/business-solutions/bookings/time-slots/time-slots-v2/list-event-time-slots.md
- * @param {string|string[]} serviceIds  One service id or several (the endpoint takes a plural list).
- * @param {{ fromLocalDate: string, toLocalDate: string, timeZone?: string, limit?: number, cursor?: string }} options
- * @returns {Promise<{ slots: object[], nextCursor: string|null, timeZone: string|null }>}
- */
-export async function listEventTimeSlots(serviceIds, { fromLocalDate, toLocalDate, timeZone, limit = 1000, cursor } = {}) {
-  if (!cursor && (!fromLocalDate || !toLocalDate)) {
-    throw new Error("listEventTimeSlots requires fromLocalDate and toLocalDate (local 'YYYY-MM-DDThh:mm:ss').");
-  }
-  const ids = Array.isArray(serviceIds) ? serviceIds : [serviceIds];
-  const body = cursor
-    ? { cursorPaging: { limit, cursor } }
-    : {
-        serviceIds: ids,
-        bookable: true,
-        fromLocalDate,
-        toLocalDate,
-        timeZone: timeZone || defaultTimeZone(),
-        cursorPaging: { limit },
-      };
-  const res = await wixApiRequest("/_api/service-availability/v2/time-slots/event", { method: "POST", body });
-  return {
-    slots: res?.timeSlots ?? [],
-    // This endpoint nests the cursor under `pagingMetadata`, where the appointment one uses
-    // `cursorPagingMetadata` — reading only the latter silently disables paging for classes.
-    nextCursor: res?.pagingMetadata?.cursors?.next ?? res?.cursorPagingMetadata?.cursors?.next ?? null,
-    timeZone: res?.timeZone ?? null,
-  };
-}
-
-/**
- * Type-agnostic convenience: list bookable slots for a service, routing to the right endpoint by
- * `service.type` — APPOINTMENT → `listAvailableSlots`, CLASS/COURSE → `listEventTimeSlots`. The
- * returned slots are shaped the same either way (`localStartDate`/`localEndDate`/`location`/
- * `availableResources`), and each is bookable via `createBooking`.
- * NOTE: a **COURSE** is enrolled as a whole (not per session), so it typically returns **no** slots
- * here — the per-slot booking flow applies to APPOINTMENT and CLASS.
- * @param {{ _id?: string, id?: string, type?: string }} service  A service from queryServices.
- * @param {{ fromLocalDate: string, toLocalDate: string, timeZone?: string, limit?: number, cursor?: string }} options
- * @returns {Promise<{ slots: object[], nextCursor: string|null, timeZone: string|null }>}
- */
-export async function listSlotsForService(service, options = {}) {
-  const serviceId = service?._id || service?.id;
-  if (!serviceId) throw new Error("listSlotsForService requires a service with an id.");
-  if (service?.type === "CLASS" || service?.type === "COURSE") return listEventTimeSlots(serviceId, options);
-  // For a rental, name its resource type(s) so the slots come back; reading them off the service
-  // keeps this call type-agnostic (a staff appointment just yields an empty list here).
-  const includeResourceTypeIds =
-    options.includeResourceTypeIds ??
-    (service?.serviceResources ?? []).map((sr) => sr.resourceType?._id ?? sr.resourceType?.id).filter(Boolean);
-  return listAvailableSlots(serviceId, { ...options, includeResourceTypeIds });
-}

package/skills/wix-vibe-headless/references/bookings/seed/SEED.md

@@ -1,154 +0,0 @@
-# Bookings — seeding
-
-Seed a Wix Bookings catalog by **calling `seed-bookings.cjs`** — don't hand-write the REST calls.
-It's a build-time module (run via `exec_tool`, not shipped in the app) that abstracts every Wix
-Bookings seed operation. Load it and call **`setupBookings` — the one-call path** — with plain data.
-
-> **Transcribed from `wix-headless/references/inline-recipes/setup-bookings.md` — NOT yet live-verified.**
-
-```js
-// build-time exec_tool
-const { accessToken } = await base44.asServiceRole.connectors.getConnection("wix");
-const seed = require(require("path").resolve(".agents/skills/wix-vibe-headless/references/bookings/seed/seed-bookings.cjs"));
-const ctx = { token: accessToken, siteId: WIX_METASITE_ID };
-
-// ONE call: install → resolve staff → categories → services → CLASS sessions → images, all in the
-// correct order with ids kept in memory (no hand-threading of scheduleId/resourceId). `category` is
-// a NAME (resolved to an id internally). Free service: set free:true, omit price. CLASS `sessions`
-// are local "YYYY-MM-DDThh:mm:ss".
-const result = await seed.setupBookings(ctx, {
-  services: [
-    // `imageUrl` per service is optional and attached IN this one call. Pass a plain url — the module
-    // imports it into Wix Media for you (bookings binds a service image by the Wix Media file id, not a
-    // url). Use the FINAL https://media.base44.com/... url from the COMPLETED generate_image (it runs in
-    // the background while you build — wait for it), never a still-generating /__generating__/<id>.png.
-    { type: "APPOINTMENT", name: "Consultation", description: "…", tagLine: "…", price: 75, duration: 60, category: "Our Services", imageUrl: "https://media.base44.com/…" },
-    { type: "CLASS", name: "Morning Yoga", description: "…", price: 20, capacity: 20, category: "Our Services",
-      sessions: [{ start: "2026-08-10T09:00:00", end: "2026-08-10T10:00:00" }] },
-  ],
-  // staffResourceId defaults to the fresh install's owner (queryStaff()[0].resourceId).
-});
-// result: { services:[...], categories:[{id,name}], resourceId, sessionsScheduled, imagesAttached }
-
-// fallback (finer control / re-attach): import the url to Wix Media, then patch one service after the fact.
-// const file = await seed.importImage(ctx, imageUrl);   // → { id, url } (Wix Media file id + wixstatic url)
-// await seed.attachServiceImage(ctx, { serviceId: s.id, revision: s.revision, image: { id: file.id, url: file.url, width: 1024, height: 1024 } });
-```
-
-**Seeding is additive — never delete or overwrite existing content.** Don't clean up, don't remove
-"sample" data, don't reset. Just add.
-
-## What the shipped UI renders from this
-
-Pass these and the catalog reads like a real one; omit them and the pages have visible holes:
-
-- **`sessions` on every CLASS.** A class's bookable times ARE its sessions, so a class seeded without
-  them shows "No available times in this range" — which reads as broken, not empty. Schedule a few
-  weeks out. An APPOINTMENT needs none: its slots come from staff working hours, which a fresh
-  install's owner already has.
-- **`duration`** (APPOINTMENT, minutes) → the card's `60 min · 1-to-1` line and the DURATION cell on
-  the service page. A class has no service-level duration and shows CAPACITY instead, so pass
-  `capacity` there.
-- **`tagLine`** → the card's second line. One line about the service, not a copy of `description`.
-- **`price`**, or **`free: true`** for a no-fee service, which the UI labels "Free".
-
-Two things this module can't set, so don't try: **varied pricing** (a "From €85" service needs
-`payment.varied`) and **`conferencing`** (the UI's "Online" location label reads that flag — seeded
-services all sit at the business location, which shows as "In person").
-
-## Escape hatch — individual functions
-Reach for the functions below only when the one-call `setupBookings` doesn't fit (partial re-seed,
-custom staff/ordering). `setupBookings` is built from them, in this order:
-
-```js
-await seed.installBookingsApp(ctx);
-const staff = await seed.queryStaffWithRetry(ctx);                   // → [{resourceId,id,name}]; polls (fresh install provisions the owner async); use resourceId, NOT id
-const cats = await seed.createCategories(ctx, ["Our Services"]);    // → [{id,name}]; every service needs a categoryId
-const services = await seed.createServices(ctx, [                   // → [{id,slug,revision,type,scheduleId}]
-  { type: "APPOINTMENT", name: "Consultation", price: 75, duration: 60, categoryId: cats[0].id, staffMemberIds: [staff[0].resourceId] },
-  { type: "CLASS", name: "Morning Yoga", price: 20, capacity: 20, categoryId: cats[0].id },
-]);
-// CLASS only: schedule sessions with each class's returned scheduleId (local wall-clock times)
-await seed.scheduleClassSessions(ctx, [
-  { scheduleId: services[1].scheduleId, resourceId: staff[0].resourceId, start: "2026-08-10T09:00:00", end: "2026-08-10T10:00:00", capacity: 20 },
-]);
-// images (optional): import the url to Wix Media first (bookings binds by file id), then attach.
-// Use the FINAL https://media.base44.com/... url only (never a /__generating__/ placeholder).
-const file = await seed.importImage(ctx, imageUrl);   // → { id, url } (Wix Media file id + wixstatic url)
-await seed.attachServiceImage(ctx, { serviceId: services[0].id, revision: services[0].revision, image: { id: file.id, url: file.url, width: 1024, height: 1024 } });
-```
-
-## Functions
-| fn | does |
-|---|---|
-| `setupBookings(ctx, {services, staffResourceId?})` | **one-call**: install → staff → categories → services → CLASS sessions → images |
-| `installBookingsApp(ctx)` | install the Wix Bookings app on the site |
-| `queryStaff(ctx)` | `[{resourceId,id,name}]` — one shot; use `resourceId`, not `id` |
-| `queryStaffWithRetry(ctx)` | STEP 1 — same, but polls until the default owner provisions after a fresh install (avoids `MISSING_APPOINTMENT_RESOURCES`) |
-| `createStaff(ctx, [{name,description}])` | create named staff → `[{resourceId,id,name}]` (omit email/phone) |
-| `queryCategories(ctx)` | `[{id,name}]` — reuse a category created earlier this run |
-| `createCategories(ctx, names)` | STEP 2 — every service needs a `category.id` or it's invisible → `[{id,name}]`; reuses an existing same-named category (idempotent, no dupes on re-run) |
-| `createServices(ctx, services)` | STEP 3 — one bulk create (APPOINTMENT/CLASS mixed) → `[{id,slug,revision,type,scheduleId,success,error}]` |
-| `scheduleClassSessions(ctx, sessions)` | STEP 4 (CLASS only) — one bulk Calendar-Events-V3 create → `[{id,success,error}]` |
-| `getService(ctx, serviceId)` | fetch a service (current `revision`; confirm an image landed) |
-| `importImage(ctx, url)` | import an external url into Wix Media → `{id,url}` (file id + wixstatic url); bookings binds by this file id |
-| `attachServiceImage(ctx, {serviceId,revision,image})` | optional — patch `media.mainMedia`/`coverMedia` (revision-checked); `image.id` MUST be a Wix Media file id from `importImage` |
-
-Both bulk calls report per-item `success`/`error` — retry only the failed items **once** with the
-same body; don't loop and don't re-create the ones that already succeeded.
-
-## Rentals
-
-`seed-rentals.cjs` is the rentals half — the same transport, a different create order and payload.
-Wix Rentals has no APIs of its own, so a rental is a Bookings service with rentals-specific
-field values.
-
-```js
-const seed = require(require("path").resolve(".agents/skills/wix-vibe-headless/references/bookings/seed/seed-rentals.cjs"));
-await seed.setupRentals(ctx, {
-  resourceTypeName: "Meeting rooms",
-  resources: ["Room A", "Room B"],              // parallel capacity = MORE RESOURCES
-  rentals: [
-    { name: "Meeting room, hourly", description: "…", price: 25, unit: "HOUR", min: 60, max: 480 },
-    { name: "Meeting room, daily",  description: "…", price: 180, unit: "DAY", min: 1, max: 5 },
-  ],
-});
-// → { resourceType, resources, services, ok, problems }
-```
-
-`price` is a RATE — per hour or per day — not the cost of a rental.
-Hourly `min`/`max` are MINUTES (30–1440); daily are DAYS (1–8).
-
-**`ok` must be true.** `problems` is the read-back check: a service created without `appId` or
-without `durationRange` still returns 200 and is simply a plain Bookings service from then on.
-
-### The four traps this seed handles
-
-- **Install Rentals ONLY.** It provisions the Bookings infrastructure it runs on; installing
-  Wix Bookings as well is redundant.
-- **`appId` is immutable after create.** A service created without it is a plain Bookings
-  service forever — there is no update that converts it.
-- **Order is load-bearing: resource type → resources → services.** A service whose resource
-  type holds no resources has permanently empty availability, and nothing errors.
-- **Rental services do not use categories.** Unlike bookings, do not create or assign one.
-- **`serviceResources` is required** and the docs' Create Service parameter list omits it.
-  Without it the create fails `MISSING_APPOINTMENT_RESOURCES`, whose message sends you to check
-  the resource type's contents — a dead end, since it fails even when the type is populated.
-
-Resources are seeded **24/7** (no working hours) so a multi-day rental stays one booking rather
-than a multi-service group. Pass `workingHours` only when the brief names opening hours.
-
-## Reference
-If a call returns a shape you didn't expect, or you need an operation this module doesn't cover,
-use the documentation skill available in your environment to search + read the live Wix API reference — never guess. The
-authoritative source recipe is `wix-headless/references/inline-recipes/setup-bookings.md`.
-
-Read a method's page before writing its call: it carries the exact body shape, the required
-permission scope, and the response envelope.
-- Install a Wix app onto the site: https://dev.wix.com/docs/api-reference/business-management/app-installation/app-installation/install-app.md
-- Import an image into Wix Media: https://dev.wix.com/docs/api-reference/assets/media/media-manager/files/import-file.md
-- Bulk Create Services: https://dev.wix.com/docs/api-reference/business-solutions/bookings/services/services-v2/bulk-create-services.md
-- Create Category: https://dev.wix.com/docs/api-reference/business-solutions/bookings/services/categories-v2/create-category.md
-- Create Staff Member: https://dev.wix.com/docs/api-reference/business-solutions/bookings/staff-members/staff-members/create-staff-member.md
-- Query Staff Members: https://dev.wix.com/docs/api-reference/business-solutions/bookings/staff-members/staff-members/query-staff-members.md
-- Bulk Create Event (calendar sessions): https://dev.wix.com/docs/api-reference/business-management/calendar/events-v3/bulk-create-event.md