@jskit-ai/connectors-catalog 0.2.3 → 0.2.4

package/src/server/wix.js

@@ -1,58 +1,21 @@
 import { ConnectorError } from "@jskit-ai/connectors-core/server";
 import { createSchema } from "json-rest-schema";
 import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { requestPath, sameRecord, cursor, querySchema, contactIdField } from "./wixValues.js";
 import { wixDefinition } from "../shared/wix.js";
+import { wixBookingOperations } from "./wixBookings.js";
+import { wixCmsOperations } from "./wixCms.js";
+import { wixStoreOperations } from "./wixStores.js";
+import { isUuid } from "../shared/uuid.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 
-// Preserve native Wix JSON without silently dropping unsupported values.
-function serializeNativeJson(value) {
-  return JSON.stringify(value, (key, item) => {
-    if (["undefined", "function", "symbol", "bigint"].includes(typeof item) ||
-        typeof item === "number" && !Number.isFinite(item)) throw new Error("JSON required");
-    return item;
-  });
-}
-
-const guid = (value) => typeof value === "string" && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/iu.test(value);
-// Results are checked against the operation's own request; a different record is reported with what Wix got wrong.
-const requestPath = (request, index) => decodeURIComponent(new URL(request.url).pathname.split("/").at(index));
-function sameRecord(matches, message, codes) {
-  if (!matches) throw new ConnectorError("connector_response_invalid", message, { statusCode: 502, ...codes });
-  return true;
-}
-const cursor = (value) => typeof value === "string" && value.length > 0 && value.length <= 16000 && !/[\p{Cc}]/u.test(value);
-const querySchema = createSchema({
-  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
-  cursor: { type: "string", minLength: 1, maxLength: 16000, noTrim: true, validator: (value) => cursor(value) || "Use the returned Wix page cursor." }
-});
+// The Wix provider: its API-key headers, site addressing and the site and contact
+// operations. The Bookings, eCommerce and Stores, and CMS operations live beside it.
 const contactsSchema = createSchema({
   limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
   offset: { type: "integer", min: 0, max: 100000, defaultTo: 0 },
   search: { type: "string", minLength: 1, maxLength: 100 }
 });
-function bookingDirectoryOperation(kind) {
-  const staff = kind === "staff";
-  return {
-    scopes: [],
-    request(input) {
-      const cursorPaging = validateSchemaPayload({ schema: querySchema, mode: "replace" }, input, { statusCode: 422 });
-      return { method: "POST", url: staff ? "https://www.wixapis.com/bookings/v1/staff-members/query" : "https://www.wixapis.com/bookings/v2/categories/query",
-        body: {
-          query: { cursorPaging, sort: [{ fieldName: "id", order: "ASC" }], ...(staff ? { filter: { serviceProvider: true } } : {}) },
-          ...(staff ? { fields: ["RESOURCE_DETAILS"] } : {})
-        } };
-    },
-    validateResult(value) {
-      const values = staff ? value?.staffMembers : value?.categories;
-      const paging = value?.pagingMetadata;
-      return Array.isArray(values) && values.length <= 100 && values.every(item => guid(item?.id) && typeof item.name === "string" &&
-        (!staff || guid(item.resourceId))) && (paging === undefined || paging && typeof paging === "object" && !Array.isArray(paging) &&
-          (paging.hasNext === undefined || typeof paging.hasNext === "boolean") &&
-          (paging.cursors === undefined || paging.cursors && typeof paging.cursors === "object" && !Array.isArray(paging.cursors) &&
-            ["next", "prev"].every(key => paging.cursors[key] === undefined || cursor(paging.cursors[key]))));
-    }
-  };
-}
-const contactIdField = { type: "string", required: true, validator: value => guid(value) || "Use the contact ID returned by Wix." };
 const contactInfoSchema = createSchema({
   name: { type: "object", schema: createSchema({ first: { type: "string", maxLength: 1000 }, last: { type: "string", maxLength: 1000 } }) },
   company: { type: "string", maxLength: 1000 }, jobTitle: { type: "string", maxLength: 1000 },
@@ -63,8 +26,8 @@ const contactInfoSchema = createSchema({
     items: { type: "object", schema: createSchema({ phone: { type: "string", required: true, minLength: 1, maxLength: 50 },
       countryCode: { type: "string", validator: value => /^[A-Z]{2}$/u.test(value) || "Use a two-letter country code." }, primary: { type: "boolean" } }) } } }) }
 });
-const validContact = value => guid(value?.id) && Number.isSafeInteger(value.revision) && value.revision >= 0 &&
-  value.info && typeof value.info === "object" && !Array.isArray(value.info);
+const validContact = value => isUuid(value?.id) && Number.isSafeInteger(value.revision) && value.revision >= 0 &&
+  isRecord(value.info);
 function contactOperation(action) {
   const fields = action === "get" ? { contactId: contactIdField } : {
     ...(action === "update" ? { contactId: contactIdField, revision: { type: "integer", required: true, min: 0, max: 2147483647 } } : {}),
@@ -87,442 +50,6 @@ function contactOperation(action) {
       sameRecord(value.contact.id === requestPath(request, -1), "Wix returned a different contact. Check the operation outcome before retrying.", { messageCode: "connectors.wix.returnedDifferentContactCheckOperation" }))
   };
 }
-const servicePagingSchema = createSchema({ limit: { type: "integer", min: 1, max: 100, defaultTo: 20 }, offset: { type: "integer", min: 0, max: 100000, defaultTo: 0 } });
-const serviceIdSchema = createSchema({ serviceId: contactIdField });
-const nativeJsonObjectField = { type: "none", validator: value => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return "Use a native Wix JSON object.";
-  try {
-    const json = serializeNativeJson(value);
-    return Buffer.byteLength(json) <= 100000 || "Keep native Wix object data within 100KB.";
-  } catch { return "Use serializable native Wix JSON data."; }
-} };
-const serviceUpdateSchema = createSchema({
-  serviceId: contactIdField,
-  revision: { type: "none", required: true, validator: value => typeof value === "string" && /^\d{1,19}$/u.test(value) && BigInt(value) <= 9223372036854775807n || "Use the returned service revision string." },
-  name: { type: "string", minLength: 1, maxLength: 400 }, description: { type: "string", maxLength: 7000 }, tagLine: { type: "string", maxLength: 6000 },
-  payment: nativeJsonObjectField,
-  onlineBooking: { type: "object", schema: createSchema({ enabled: { type: "boolean" }, requireManualApproval: { type: "boolean" }, allowMultipleRequests: { type: "boolean" } }) },
-  defaultCapacity: { type: "integer", min: 1, max: 1000 },
-  staffMemberIds: { type: "array", validator: values => values.length > 0 && values.length <= 100 || "Select 1–100 staff resource IDs.", items: { type: "string", validator: value => guid(value) || "Use a staff resource ID." } },
-  schedule: { type: "object", schema: createSchema({ availabilityConstraints: { type: "object", required: true, schema: createSchema({
-    sessionDurations: { type: "array", validator: values => values.length > 0 && values.length <= 50 || "Use 1–50 appointment durations.", items: { type: "integer", min: 1 } },
-    timeBetweenSessions: { type: "integer", min: 0 }
-  }) } }) }
-});
-const validService = value => guid(value?.id) && typeof value.name === "string" && typeof value.revision === "string" && /^\d{1,19}$/u.test(value.revision) &&
-  ["APPOINTMENT", "CLASS", "COURSE"].includes(value.type);
-const localDate = value => typeof value === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/u.test(value) &&
-  Number.isFinite(Date.parse(`${value}Z`)) && new Date(`${value}Z`).toISOString().slice(0, 19) === value;
-const validSlot = value => guid(value?.serviceId) && localDate(value.localStartDate) && localDate(value.localEndDate) &&
-  value.localStartDate < value.localEndDate && typeof value.bookable === "boolean";
-const availabilityLocationSchema = createSchema({
-  id: { type: "string", validator: value => guid(value) || "Use the Wix business location ID." },
-  locationType: { type: "string", required: true, enum: ["BUSINESS", "CUSTOM", "CUSTOMER"] },
-  name: { type: "string", maxLength: 1000 }, formattedAddress: { type: "string", maxLength: 4000 }
-});
-// Availability must answer for the requested service, local time window and time zone.
-function requestedAvailability(value, requested, events) {
-  const slots = value.timeSlots ?? [value.timeSlot];
-  sameRecord(!(requested.timeZone && value.timeZone !== requested.timeZone || slots.some(slot => requested.serviceId && slot.serviceId !== requested.serviceId ||
-    requested.localStartDate && (slot.localStartDate !== requested.localStartDate || slot.localEndDate !== requested.localEndDate))),
-  "Wix returned availability for a different service, time or time zone.", { messageCode: "connectors.wix.returnedAvailabilityDifferentServiceTime" });
-  return !events || !requested.serviceIds || sameRecord(slots.every(slot => requested.serviceIds.includes(slot.serviceId)), "Wix returned a class slot for a different service.", { messageCode: "connectors.wix.returnedClassSlotDifferentService" });
-}
-function availabilityOperation(action, events = false) {
-  const schema = createSchema({
-    ...(!events ? {
-      customerChoices: { type: "object", schema: createSchema({
-        durationInMinutes: { type: "integer", min: 1, max: 57600 },
-        addOnIds: { type: "array", validator: values => values.length > 0 && values.length <= 21 && new Set(values).size === values.length || "Select 1–21 distinct add-ons.",
-          items: { type: "string", validator: value => guid(value) || "Use the add-on ID returned by Wix." } }
-      }) },
-      includeResourceTypeIds: { type: "array", validator: values => values.length <= 100 || "Choose at most 100 resource types.", items: { type: "string", validator: value => guid(value) || "Use a resource type ID." } },
-      ...(action === "list" ? { locations: { type: "array", validator: values => values.length <= 5 || "Choose at most five locations.", items: { type: "object", schema: availabilityLocationSchema } } } : {
-        location: { type: "object", schema: availabilityLocationSchema },
-        resourceTypes: { type: "array", validator: values => values.length <= 8 || "Choose at most eight resource types.", items: { type: "object", schema: createSchema({
-          resourceTypeId: { type: "string", required: true, validator: value => guid(value) || "Use a resource type ID." },
-          resourceIds: { type: "array", required: true, validator: values => values.length > 0 && values.length <= 135 || "Choose 1–135 resource IDs.", items: { type: "string", validator: value => guid(value) || "Use a resource ID." } }
-        }) } }
-      })
-    } : {}),
-    ...(events ? { minBookableCapacity: { type: "integer", min: 1, max: 1000 } } : {}),
-    serviceId: { type: "string", validator: value => guid(value) || "Use the appointment service ID." },
-    ...(action === "list" ? {
-      fromLocalDate: { type: "string", validator: value => localDate(value) || "Use YYYY-MM-DDThh:mm:ss without an offset." },
-      toLocalDate: { type: "string", validator: value => localDate(value) || "Use YYYY-MM-DDThh:mm:ss without an offset." },
-      limit: { type: "integer", min: 1, max: 1000, defaultTo: 100 },
-      cursor: { type: "string", validator: value => cursor(value) || "Use the returned page cursor." }
-    } : {
-      localStartDate: { type: "string", required: true, validator: value => localDate(value) || "Use the returned local start date." },
-      localEndDate: { type: "string", required: true, validator: value => localDate(value) || "Use the returned local end date." }
-    }),
-    timeZone: { type: "string", maxLength: events ? 100 : 150, validator: value => {
-      try { new Intl.DateTimeFormat("en", { timeZone: value }); return true; } catch { return "Use an IANA time zone."; }
-    } }
-  });
-  return {
-    scopes: [],
-    request(input) {
-      const { limit, cursor: next, ...body } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
-      if (next && Object.keys(body).length) throw new ConnectorError("connector_input_invalid", "Use only cursor and limit for the next availability page.", { statusCode: 422, messageCode: "connectors.wix.useCursorLimitNextAvailability" });
-      if (body.customerChoices && !Object.keys(body.customerChoices).length) throw new ConnectorError("connector_input_invalid", "Select a duration or add-ons before supplying customer choices.", { statusCode: 422, messageCode: "connectors.wix.selectDurationAddOnsSupplying" });
-      if (!next && (!body.serviceId || !body.timeZone || (action === "list" ? !body.fromLocalDate || !body.toLocalDate || body.fromLocalDate >= body.toLocalDate : body.localStartDate >= body.localEndDate))) {
-        throw new ConnectorError("connector_input_invalid", "Choose the service, time zone and an increasing local date range.", { statusCode: 422, messageCode: "connectors.wix.chooseServiceTimeZoneIncreasing" });
-      }
-      const locations = body.locations ?? (body.location ? [body.location] : []);
-      if (locations.some(location => location.locationType === "BUSINESS" && !location.id)) throw new ConnectorError("connector_input_invalid", "Choose the business location ID.", { statusCode: 422, messageCode: "connectors.wix.chooseBusinessLocationId" });
-      const { serviceId, ...eventBody } = body;
-      return { method: "POST", url: `https://www.wixapis.com/_api/service-availability/v2/time-slots${events ? "/event" : action === "get" ? "/get" : ""}`,
-        body: action === "get" ? body : next ? { cursorPaging: { limit, cursor: next } } : { ...(events ? { ...eventBody, serviceIds: [serviceId], includeNonBookable: false } : { ...body, bookable: true }), cursorPaging: { limit } } };
-    },
-    validateResult: (value, request) => typeof value?.timeZone === "string" && (action === "get" ? validSlot(value.timeSlot) :
-      Array.isArray(value.timeSlots) && value.timeSlots.length <= 1000 && value.timeSlots.every(slot => validSlot(slot) && (!events || typeof slot.eventInfo?.eventId === "string" && slot.eventInfo.eventId.length >= 36 && slot.eventInfo.eventId.length <= 250)) &&
-      (value[events ? "pagingMetadata" : "cursorPagingMetadata"] === undefined || value[events ? "pagingMetadata" : "cursorPagingMetadata"] && typeof value[events ? "pagingMetadata" : "cursorPagingMetadata"] === "object" && !Array.isArray(value[events ? "pagingMetadata" : "cursorPagingMetadata"]) &&
-        (value[events ? "pagingMetadata" : "cursorPagingMetadata"].cursors === undefined || value[events ? "pagingMetadata" : "cursorPagingMetadata"].cursors && typeof value[events ? "pagingMetadata" : "cursorPagingMetadata"].cursors === "object" && !Array.isArray(value[events ? "pagingMetadata" : "cursorPagingMetadata"].cursors) &&
-          ["next", "prev"].every(key => value[events ? "pagingMetadata" : "cursorPagingMetadata"].cursors[key] === undefined || cursor(value[events ? "pagingMetadata" : "cursorPagingMetadata"].cursors[key]))))) &&
-      requestedAvailability(value, request.body, events)
-  };
-}
-const eventSlotSchema = createSchema({
-  eventId: { type: "string", required: true, minLength: 36, maxLength: 250, validator: value => !/[\p{Cc}]/u.test(value) || "Use the returned event ID." },
-  timeZone: { type: "string", required: true, maxLength: 100, validator: value => {
-    try { new Intl.DateTimeFormat("en", { timeZone: value }); return true; } catch { return "Use an IANA time zone."; }
-  } }
-});
-function productReadOperation(version, action) {
-  const schema = createSchema(action === "get" ? {
-    productId: { type: "string", required: true, validator: value => guid(value) || "Use the Wix product ID." }
-  } : {
-    limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
-    ...(version === 1 ? { offset: { type: "integer", min: 0, max: 100000, defaultTo: 0 }, includeVariants: { type: "boolean", defaultTo: false } } :
-      { cursor: { type: "string", validator: value => cursor(value) || "Use the returned product cursor." } })
-  });
-  const validProduct = value => guid(value?.id) && typeof value.name === "string" && value.name.length > 0;
-  return {
-    scopes: [],
-    request(input) {
-      const value = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
-      const base = version === 1 ? "https://www.wixapis.com/stores-reader/v1/products" : "https://www.wixapis.com/stores/v3/products";
-      if (action === "get") return { method: "GET", url: `${base}/${value.productId}` };
-      const { includeVariants, ...paging } = value;
-      return { method: "POST", url: `${base}/query`,
-        body: version === 1 ? { query: { paging }, includeVariants } : { query: { cursorPaging: paging } } };
-    },
-    validateResult: (value, request) => action === "get" ? validProduct(value?.product) && sameRecord(value.product.id === requestPath(request, -1), "Wix returned a different product.", { messageCode: "connectors.wix.returnedDifferentProduct" }) : Array.isArray(value?.products) && value.products.length <= 100 && value.products.every(validProduct) &&
-      (version === 1 ? (value.totalResults === undefined || Number.isSafeInteger(value.totalResults) && value.totalResults >= 0) &&
-        (value.metadata === undefined || value.metadata && typeof value.metadata === "object" && !Array.isArray(value.metadata) &&
-          ["items", "offset"].every(key => value.metadata[key] === undefined || Number.isSafeInteger(value.metadata[key]) && value.metadata[key] >= 0)) :
-        (value.pagingMetadata === undefined || value.pagingMetadata && typeof value.pagingMetadata === "object" && !Array.isArray(value.pagingMetadata) &&
-          (value.pagingMetadata.cursors === undefined || value.pagingMetadata.cursors && typeof value.pagingMetadata.cursors === "object" && !Array.isArray(value.pagingMetadata.cursors) &&
-            ["next", "prev"].every(key => value.pagingMetadata.cursors[key] === undefined || cursor(value.pagingMetadata.cursors[key])))))
-  };
-}
-const collectionId = value => typeof value === "string" && value.length > 0 && value.length <= 256 &&
-  !/[\p{Cc}]/u.test(value) && value.split("/").every(part => part.length > 0 && ![".", ".."].includes(part));
-const collectionListSchema = createSchema({
-  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 }, offset: { type: "integer", min: 0, max: 100000, defaultTo: 0 },
-  consistentRead: { type: "boolean", defaultTo: false }
-});
-const cmsFilterField = { type: "none", validator: value => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) return "Use a Wix filter object.";
-    try {
-      const json = serializeNativeJson(value);
-      return Buffer.byteLength(json) <= 100000 || "Keep the Wix filter within 100KB.";
-    } catch { return "Use serializable JSON filter data."; }
-  } };
-const cmsItemQuerySchema = createSchema({
-  collectionId: { type: "string", required: true, validator: value => collectionId(value) || "Use the returned Wix collection ID." },
-  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 }, offset: { type: "integer", min: 0, max: 100000, defaultTo: 0 },
-  consistentRead: { type: "boolean", defaultTo: false },
-  filter: cmsFilterField,
-  sort: { type: "array", validator: values => values.length <= 100 || "Use at most 100 sort fields.", items: { type: "object", schema: createSchema({
-    fieldName: { type: "string", required: true, minLength: 1, maxLength: 1000 }, order: { type: "string", required: true, enum: ["ASC", "DESC"] }
-  }) } },
-  fields: { type: "array", validator: values => values.length <= 1000 || "Use at most 1000 projected fields.", items: { type: "string", minLength: 1, maxLength: 5000 } },
-  returnTotalCount: { type: "boolean" },
-  includeReferences: { type: "array", validator: values => values.length <= 100 || "Use at most 100 reference configurations.", items: { type: "object", schema: createSchema({
-    field: { type: "string", required: true, minLength: 1, maxLength: 1000 }, limit: { type: "integer", min: 1, max: 1000 }
-  }) } }
-});
-const cmsItemIdField = { type: "string", required: true, minLength: 1, maxLength: 128,
-  validator: value => !/[\p{Cc}]/u.test(value) && ![".", ".."].includes(value) || "Use a returned Wix item ID." };
-const cmsItemGetSchema = createSchema({
-  collectionId: { type: "string", required: true, validator: value => collectionId(value) || "Use the returned Wix collection ID." },
-  itemId: cmsItemIdField, consistentRead: { type: "boolean", defaultTo: false }
-});
-const cmsItemPatchSchema = createSchema({
-  collectionId: { type: "string", required: true, validator: value => collectionId(value) || "Use the returned Wix collection ID." },
-  itemId: cmsItemIdField, conditionFilter: cmsFilterField,
-  fieldModifications: { type: "none", required: true, validator: values => {
-    if (!Array.isArray(values) || values.length < 1 || values.length > 100) return "Provide 1–100 Wix field modifications.";
-    const options = { SET_FIELD: "setFieldOptions", INCREMENT_FIELD: "incrementFieldOptions", APPEND_TO_ARRAY: "appendToArrayOptions", REMOVE_FROM_ARRAY: "removeFromArrayOptions" };
-    for (const value of values) {
-      if (!value || typeof value !== "object" || Array.isArray(value) || typeof value.fieldPath !== "string" ||
-          !value.fieldPath.length || value.fieldPath.length > 1000 || /[\p{Cc}]/u.test(value.fieldPath)) return "Use a Wix field path for each modification.";
-      if (value.action === "REMOVE_FIELD") {
-        if (Object.keys(value).some(key => !["fieldPath", "action"].includes(key))) return "REMOVE_FIELD accepts no value options.";
-      } else {
-        const key = Object.hasOwn(options, value.action) ? options[value.action] : undefined;
-        if (!key || Object.keys(value).some(name => !["fieldPath", "action", key].includes(name))) return "Use the options matching the Wix patch action.";
-        const config = value[key];
-        if (!config || typeof config !== "object" || Array.isArray(config) || !Object.hasOwn(config, "value") || Object.keys(config).length !== 1) return "Provide the patch action's value.";
-        if (value.action === "INCREMENT_FIELD" && (typeof config.value !== "number" || !Number.isFinite(config.value))) return "Use a finite increment value.";
-      }
-    }
-    try {
-      const json = serializeNativeJson(values);
-      return Buffer.byteLength(json) <= 100000 || "Keep field modifications within 100KB.";
-    } catch { return "Use serializable JSON field values."; }
-  } }
-});
-const collectionGetSchema = createSchema({
-  collectionId: { type: "string", required: true, validator: value => collectionId(value) || "Use the returned Wix collection ID." },
-  consistentRead: { type: "boolean", defaultTo: false }
-});
-const validCollection = value => collectionId(value?.id) &&
-  (value.fields === undefined || Array.isArray(value.fields)) && (value.displayName === undefined || typeof value.displayName === "string");
-const serviceLocationSchema = createSchema({
-  type: { type: "string", required: true, enum: ["BUSINESS", "CUSTOM", "CUSTOMER"] },
-  business: { type: "object", schema: createSchema({ id: contactIdField }) },
-  custom: { type: "object", schema: createSchema({ address: { ...nativeJsonObjectField, required: true } }) }
-});
-const setServiceLocationsSchema = createSchema({
-  serviceId: contactIdField,
-  locations: { type: "array", required: true, validator: values => values.length <= 100 || "Use at most 100 locations.", items: { type: "object", schema: serviceLocationSchema } },
-  removedLocationAction: { type: "string", required: true, enum: ["KEEP_AT_CURRENT_LOCATION", "MOVE_TO_LOCATION"] },
-  moveToLocation: { type: "object", schema: serviceLocationSchema },
-  notifyParticipants: { type: "boolean", defaultTo: false }, notificationMessage: { type: "string", maxLength: 2000 }
-});
-const serviceCreateSchema = createSchema({ service: { ...nativeJsonObjectField, required: true } });
-function locationWriteOperation(action) {
-  const schema = createSchema({
-    ...(action === "update" ? {
-      locationId: contactIdField,
-      revision: { type: "none", required: true, validator: value => typeof value === "string" && /^\d{1,19}$/u.test(value) && BigInt(value) <= 9223372036854775807n || "Use the current location revision string." }
-    } : {}),
-    name: { type: "string", required: true, minLength: 1, maxLength: 150 },
-    timeZone: { type: "string", required: true, maxLength: 150, validator: value => {
-      try { new Intl.DateTimeFormat("en", { timeZone: value }); return true; } catch { return "Use an IANA time zone."; }
-    } },
-    description: { type: "string", maxLength: 500 }, email: { type: "string", maxLength: 320 },
-    phone: { type: "string", maxLength: 100 }, fax: { type: "string", maxLength: 100 },
-    status: { type: "string", enum: ["ACTIVE"] },
-    locationTypes: { type: "array", validator: values => values.length <= 10 || "Use at most 10 location types.", items: { type: "string", enum: ["UNKNOWN", "BRANCH", "OFFICES", "RECEPTION", "HEADQUARTERS", "INVENTORY"] } },
-    businessSchedule: nativeJsonObjectField, extendedFields: nativeJsonObjectField,
-    address: { type: "object", required: true, schema: createSchema({
-      country: { type: "string", validator: value => /^[A-Z]{2}$/u.test(value) || "Use a two-letter country code." },
-      subdivision: { type: "string", maxLength: 100 }, city: { type: "string", maxLength: 1000 }, postalCode: { type: "string", maxLength: 20 },
-      formattedAddress: { type: "string", maxLength: 4000 }, hint: { type: "string", maxLength: 500 },
-      streetAddress: { type: "object", schema: createSchema({ number: { type: "string", maxLength: 100 }, name: { type: "string", maxLength: 1000 }, apt: { type: "string", maxLength: 100 } }) },
-      geocode: { type: "object", schema: createSchema({ latitude: { type: "number", required: true, min: -90, max: 90 }, longitude: { type: "number", required: true, min: -180, max: 180 } }) }
-    }) }
-  });
-  return {
-    scopes: [],
-    request(input) {
-      const { locationId, ...location } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
-      if (!Object.keys(location.address).length) throw new ConnectorError("connector_input_invalid", "Provide the location address.", { statusCode: 422, messageCode: "connectors.wix.provideLocationAddress" });
-      if (location.businessSchedule && (["periods", "specialHourPeriod"].some(key => location.businessSchedule[key] !== undefined &&
-          (!Array.isArray(location.businessSchedule[key]) || location.businessSchedule[key].length > 100)) ||
-          Object.keys(location.businessSchedule).some(key => !["periods", "specialHourPeriod"].includes(key)))) {
-        throw new ConnectorError("connector_input_invalid", "Use native businessSchedule periods and specialHourPeriod arrays with at most 100 entries each.", { statusCode: 422, messageCode: "connectors.wix.businessScheduleLimits" });
-      }
-      return { method: action === "create" ? "POST" : "PUT", url: `https://www.wixapis.com/locations/v1/locations${locationId ? `/${locationId}` : ""}`,
-        body: { location: { ...(locationId ? { id: locationId } : {}), ...location } } };
-    },
-    validateResult: (value, request) => validLocation(value?.location) && typeof value.location.revision === "string" && /^\d{1,19}$/u.test(value.location.revision) &&
-      (action === "create" || sameRecord(value.location.id === requestPath(request, -1), "Wix returned a different business location.", { messageCode: "connectors.wix.returnedDifferentBusinessLocation" }))
-  };
-}
-function locationActionOperation(action) {
-  const schema = createSchema({ locationId: contactIdField });
-  return {
-    scopes: [],
-    request(input) {
-      const { locationId } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
-      return { method: "POST", url: `https://www.wixapis.com/locations/v1/locations/${locationId}/${action}`,
-        body: {} };
-    },
-    validateResult: (value, request) => validLocation(value?.location) && sameRecord(value.location.id === requestPath(request, -2), "Wix returned a different business location.", { messageCode: "connectors.wix.returnedDifferentBusinessLocation" }) &&
-      (action === "archive" ? value.location.archived === true : value.location.default === true)
-  };
-}
-const locationQuerySchema = createSchema({
-  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 }, offset: { type: "integer", min: 0, max: 100000, defaultTo: 0 },
-  archived: { type: "boolean", defaultTo: false }
-});
-const locationGetSchema = createSchema({ locationId: { type: "string", required: true, validator: value => guid(value) || "Use the returned location ID." } });
-const validLocation = value => guid(value?.id) && typeof value.name === "string" &&
-  (value.timeZone === undefined || typeof value.timeZone === "string") && (value.archived === undefined || typeof value.archived === "boolean");
-const productV1UpdateSchema = createSchema({
-  productId: { type: "string", required: true, validator: value => guid(value) || "Use the Wix product ID." },
-  name: { type: "string", minLength: 1, maxLength: 80 }, visible: { type: "boolean" },
-  price: { type: "none", validator: value => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 999999999.99 || "Use a numeric Wix base price from 0 to 999999999.99." }
-});
-const productV3UpdateSchema = createSchema({
-  productId: { type: "string", required: true, validator: value => guid(value) || "Use the Wix product ID." },
-  revision: { type: "none", required: true, validator: value => typeof value === "string" && /^\d{1,19}$/u.test(value) && BigInt(value) <= 9223372036854775807n || "Use the current product revision string." },
-  name: { type: "string", minLength: 1, maxLength: 80 },
-  visible: { type: "boolean" }
-});
-const catalogVersionSchema = createSchema({});
-const orderSearchSchema = createSchema({
-  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
-  cursor: { type: "string", validator: value => cursor(value) || "Use the returned order cursor." },
-  status: { type: "string", minLength: 1, maxLength: 100 },
-  contactId: { type: "string", validator: value => guid(value) || "Use the buyer's contact ID." }
-});
-const orderIdSchema = createSchema({ orderId: { type: "string", required: true, minLength: 1, maxLength: 100, validator: value => !/[\p{Cc}]/u.test(value) && ![".", ".."].includes(value) || "Use the returned order ID." } });
-const cartCreateSchema = createSchema({
-  note: { type: "string", maxLength: 1000 },
-  catalogItems: { type: "array", required: true, validator: values => values.length > 0 && values.length <= 300 || "Select 1–300 catalogue items.",
-    items: { type: "object", schema: createSchema({
-      quantity: { type: "integer", required: true, min: 1, max: 100000 },
-      catalogReference: { type: "object", required: true, schema: createSchema({
-        appId: { type: "string", required: true, validator: value => guid(value) || "Use the catalogue app ID." },
-        catalogItemId: { type: "string", required: true, minLength: 1, maxLength: 36, validator: value => !/[\p{Cc}]/u.test(value) || "Use the selected catalogue item ID." },
-        options: nativeJsonObjectField
-      }) }
-    }) } }
-});
-const cartIdSchema = createSchema({ cartId: { type: "string", required: true, validator: value => guid(value) || "Use the cart ID returned by Wix." } });
-const validOrder = value => typeof value?.id === "string" && value.id.length > 0 && value.id.length <= 100 &&
-  typeof value.status === "string" && value.status.length > 0 && (value.currency === undefined || typeof value.currency === "string") &&
-  (value.lineItems === undefined || Array.isArray(value.lineItems));
-const formSummarySchema = createSchema({ formId: { type: "string", required: true, validator: value => guid(value) || "Use the service form ID." } });
-const bookingCreateSchema = createSchema({
-  serviceId: { type: "string", required: true, validator: value => guid(value) || "Use the Wix service ID." },
-  kind: { type: "string", required: true, enum: ["APPOINTMENT", "CLASS", "COURSE"] },
-  timeZone: { type: "string", required: true, maxLength: 150, validator: value => {
-    try { new Intl.DateTimeFormat("en", { timeZone: value }); return true; } catch { return "Use an IANA time zone."; }
-  } },
-  startDate: { type: "string", validator: value => localDate(value) || "Use the selected slot's local start date." },
-  endDate: { type: "string", validator: value => localDate(value) || "Use the selected slot's local end date." },
-  eventId: { type: "string", minLength: 36, maxLength: 250, validator: value => !/[\p{Cc}]/u.test(value) || "Use the returned event ID." },
-  scheduleId: { type: "string", validator: value => guid(value) || "Use the course schedule ID." },
-  resourceId: { type: "string", validator: value => guid(value) || "Use the selected resource ID." },
-  location: { type: "object", schema: createSchema({
-    id: { type: "string", validator: value => guid(value) || "Use the business location ID." },
-    locationType: { type: "string", required: true, enum: ["OWNER_BUSINESS", "OWNER_CUSTOM", "CUSTOM"] },
-    name: { type: "string", maxLength: 1000 }, formattedAddress: { type: "string", maxLength: 4000 }
-  }) },
-  totalParticipants: { type: "integer", min: 1, max: 1000 },
-  participantsChoices: { type: "object", schema: createSchema({
-    serviceChoices: { type: "array", required: true, validator: values => values.length > 0 && values.length <= 20 || "Use 1–20 participant groups.",
-      items: { type: "object", schema: createSchema({
-        numberOfParticipants: { type: "integer", required: true, min: 1, max: 1000 },
-        choices: { type: "array", required: true, validator: values => values.length > 0 && values.length <= 5 || "Use 1–5 service choices per group.",
-          items: { type: "object", schema: createSchema({
-            optionId: { type: "string", required: true, validator: value => guid(value) || "Use the option ID returned by Wix." },
-            custom: { type: "string", minLength: 1, maxLength: 1000 },
-            duration: { type: "object", schema: createSchema({ minutes: { type: "integer", required: true, min: 1, max: 44639 }, name: { type: "string", maxLength: 255 } }) }
-          }) } }
-      }) } }
-  }) },
-  bookedAddOns: { type: "array", validator: values => values.length > 0 && values.length <= 21 && new Set(values.map(value => value?.id)).size === values.length || "Select 1–21 distinct add-ons.",
-    items: { type: "object", schema: createSchema({
-      id: { type: "string", required: true, validator: value => guid(value) || "Use the add-on ID returned by Wix." },
-      groupId: { type: "string", validator: value => guid(value) || "Use the add-on group ID." },
-      quantity: { type: "integer", min: 1, max: 1000 }
-    }) } },
-  formSubmission: { type: "none", required: true, validator: value => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) return "Provide the booking form's field-value object.";
-    try {
-      const json = serializeNativeJson(value);
-      return Buffer.byteLength(json) <= 100000 || "Keep booking form data within 100KB.";
-    } catch { return "Use serializable JSON booking form data."; }
-  } },
-  notifyParticipants: { type: "boolean", defaultTo: false }, sendSmsReminder: { type: "boolean", defaultTo: false }
-});
-const bookingQuerySchema = createSchema({
-  bookingId: { type: "string", validator: value => guid(value) || "Use the Wix booking ID." },
-  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
-  offset: { type: "integer", min: 0, max: 100000, defaultTo: 0 }
-});
-const bookingCancelSchema = createSchema({
-  bookingId: { type: "string", required: true, validator: value => guid(value) || "Use the Wix booking ID." },
-  revision: { type: "none", required: true, validator: value => typeof value === "string" && /^\d{1,19}$/u.test(value) && BigInt(value) <= 9223372036854775807n || "Use the current booking revision string." },
-  notifyParticipants: { type: "boolean", defaultTo: false },
-  message: { type: "string", maxLength: 2000 },
-  waiveCharges: { type: "boolean", defaultTo: false }
-});
-const bookingRescheduleSchema = createSchema({
-  bookingId: { type: "string", required: true, validator: value => guid(value) || "Use the Wix booking ID." },
-  revision: { type: "none", required: true, validator: value => typeof value === "string" && /^\d{1,19}$/u.test(value) && BigInt(value) <= 9223372036854775807n || "Use the current booking revision string." },
-  slot: { ...nativeJsonObjectField, required: true },
-  notifyParticipants: { type: "boolean", defaultTo: false }, message: { type: "string", maxLength: 2000 }
-});
-function bookingConfirmationOperation(action) {
-  const automatic = action === "confirmOrDecline";
-  const schema = createSchema({
-    bookingId: { type: "string", required: true, validator: value => guid(value) || "Use the Wix booking ID." },
-    ...(automatic ? {
-      paymentStatus: { type: "string", required: true, enum: ["UNDEFINED", "NOT_PAID", "PAID", "PARTIALLY_PAID", "REFUNDED", "EXEMPT"] }
-    } : {
-      revision: { type: "none", required: true, validator: value => typeof value === "string" && /^\d{1,19}$/u.test(value) && BigInt(value) <= 9223372036854775807n || "Use the current booking revision string." },
-      notifyParticipants: { type: "boolean", defaultTo: false }, message: { type: "string", maxLength: 2000 }
-    })
-  });
-  return {
-    scopes: [],
-    request(input) {
-      const { bookingId, paymentStatus, revision, notifyParticipants, message } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
-      if (message !== undefined && !notifyParticipants) throw new ConnectorError("connector_input_invalid", "Enable participant notification before supplying a message.", { statusCode: 422, messageCode: "connectors.wix.enableParticipantNotificationSupplyingMessage" });
-      return { method: "POST", url: automatic ? `https://www.wixapis.com/bookings/v2/confirmation/${bookingId}:confirmOrDecline` :
-        `https://www.wixapis.com/_api/bookings-service/v2/bookings/${bookingId}/${action}`,
-        body: automatic ? { paymentStatus } : { revision, participantNotification: { notifyParticipants, ...(message === undefined ? {} : { message }) } } };
-    },
-    validateResult: (value, request) => guid(value?.booking?.id) &&
-      sameRecord(value.booking.id === (automatic ? requestPath(request, -1).split(":")[0] : requestPath(request, -2)), "Wix returned a different booking. Check the operation outcome before retrying.", { messageCode: "connectors.wix.returnedDifferentBookingCheckOperation" }) &&
-      typeof value.booking.revision === "string" && /^\d{1,19}$/u.test(value.booking.revision) &&
-      BigInt(value.booking.revision) <= 9223372036854775807n && (automatic ? ["CONFIRMED", "PENDING", "DECLINED"].includes(value.booking.status) : value.booking.status === (action === "confirm" ? "CONFIRMED" : "DECLINED"))
-  };
-}
-function fulfillmentWriteOperation(update) {
-  const trackingSchema = createSchema({
-    trackingNumber: { type: "string", minLength: 1, maxLength: 100 },
-    shippingProvider: { type: "string", minLength: 1, maxLength: 100 },
-    trackingLink: { type: "string", minLength: 1, maxLength: 2048, validator: value => {
-      try { const url = new URL(value); return ["https:", "http:"].includes(url.protocol) && !url.username && !url.password || "Use a public tracking URL."; }
-      catch { return "Use a public tracking URL."; }
-    } }
-  });
-  const schema = createSchema({
-    orderId: { type: "string", required: true, minLength: 1, maxLength: 100, validator: value => !/[\p{Cc}]/u.test(value) && ![".", ".."].includes(value) || "Use the returned order ID." },
-    ...(update ? { fulfillmentId: contactIdField } : {}),
-    lineItems: { type: "array", required: !update, validator: values => values.length > 0 && values.length <= 300 && new Set(values.map(item => item?.id)).size === values.length || "Select 1–300 distinct order line items.",
-      items: { type: "object", schema: createSchema({ id: contactIdField, quantity: { type: "integer", required: true, min: 1, max: 100000 } }) } },
-    trackingInfo: { type: "object", schema: trackingSchema },
-    status: { type: "string", enum: ["Pending", "Accepted", "Ready", "In_Delivery", "Fulfilled"] },
-    completed: { type: "boolean" }
-  });
-  return {
-    scopes: [],
-    request(input) {
-      const { orderId, fulfillmentId, ...fulfillment } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
-      if (!Object.keys(fulfillment).length || fulfillment.trackingInfo && !Object.keys(fulfillment.trackingInfo).length) {
-        throw new ConnectorError("connector_input_invalid", "Supply the fulfillment properties to write.", { statusCode: 422, messageCode: "connectors.wix.supplyFulfillmentPropertiesWrite" });
-      }
-      const tracking = fulfillment.trackingInfo;
-      if (!update && tracking && (!tracking.trackingNumber || !tracking.shippingProvider ||
-          !["fedex", "ups", "usps", "dhl", "canadaPost"].includes(tracking.shippingProvider) && !tracking.trackingLink)) {
-        throw new ConnectorError("connector_input_invalid", "Supply tracking number and provider; custom carriers also require a tracking URL.", { statusCode: 422, messageCode: "connectors.wix.supplyTrackingNumberProviderCustom" });
-      }
-      return { method: update ? "PATCH" : "POST", url: update
-        ? `https://www.wixapis.com/ecom/v1/fulfillments/${fulfillmentId}/orders/${encodeURIComponent(orderId)}`
-        : `https://www.wixapis.com/ecom/v1/fulfillments/orders/${encodeURIComponent(orderId)}/create-fulfillment`,
-        body: { fulfillment } };
-    },
-    validateResult: (value, request) => typeof value?.orderWithFulfillments?.orderId === "string" &&
-      sameRecord(value.orderWithFulfillments.orderId === requestPath(request, update ? -1 : -2), "Wix returned fulfillments for a different order.", { messageCode: "connectors.wix.returnedFulfillmentsDifferentOrder" }) &&
-      Array.isArray(value.orderWithFulfillments.fulfillments) &&
-      value.orderWithFulfillments.fulfillments.every(item => guid(item?.id) && Array.isArray(item.lineItems) && item.lineItems.length <= 300 &&
-        item.lineItems.every(line => guid(line?.id) && Number.isInteger(line.quantity) && line.quantity >= 1 && line.quantity <= 100000)) &&
-      (update ? sameRecord(value.orderWithFulfillments.fulfillments.some(item => item.id === requestPath(request, -3)),
-        "Wix did not return the updated fulfillment. Inspect the order before retrying.", { messageCode: "connectors.wix.didNotReturnUpdatedFulfillment" }) :
-        guid(value.fulfillmentId) && value.orderWithFulfillments.fulfillments.some(item => item.id === value.fulfillmentId))
-  };
-}
 const wixRuntime = {
   ...wixDefinition, apiOrigins: ["https://www.wixapis.com"],
   apiKey: { headers: (key, settings) => ({ Authorization: key, "wix-account-id": settings.accountId }) },
@@ -534,394 +61,9 @@ const wixRuntime = {
     return request(address, { ...options, headers });
   },
   operations: {
-    "carts.create": {
-      scopes: [],
-      request(input) {
-        const { note, catalogItems } = validateSchemaPayload({ schema: cartCreateSchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "POST", url: "https://www.wixapis.com/ecom/v2/carts",
-          body: { cart: { source: { channelType: "WEB" }, ...(note === undefined ? {} : { note }) }, catalogItems } };
-      },
-      validateResult: value => guid(value?.cart?.id) && Array.isArray(value.cart.lineItems) && value.cart.lineItems.length <= 300 &&
-        value.cart.lineItems.every(item => guid(item?.id))
-    },
-    "carts.getCheckoutUrl": {
-      scopes: [],
-      request(input) {
-        const { cartId } = validateSchemaPayload({ schema: cartIdSchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "POST", url: `https://www.wixapis.com/ecom/v2/carts/${cartId}/get-checkout-url`, body: {} };
-      },
-      validateResult(value) {
-        if (typeof value?.checkoutUrl !== "string" || value.checkoutUrl.length > 8000 || /[\p{Cc}]/u.test(value.checkoutUrl)) return false;
-        try { const url = new URL(value.checkoutUrl); return url.protocol === "https:" && !url.username && !url.password; } catch { return false; }
-      }
-    },
-    "bookings.reschedule": {
-      scopes: [],
-      request(input) {
-        const { bookingId, revision, slot, notifyParticipants, message } = validateSchemaPayload({ schema: bookingRescheduleSchema, mode: "replace" }, input, { statusCode: 422 });
-        if (message !== undefined && !notifyParticipants) throw new ConnectorError("connector_input_invalid", "Enable participant notification before supplying a message.", { statusCode: 422, messageCode: "connectors.wix.enableParticipantNotificationSupplyingMessage" });
-        if (slot.eventId !== undefined) {
-          if (Object.keys(slot).length !== 1 || typeof slot.eventId !== "string" || slot.eventId.length < 36 || slot.eventId.length > 250 || /[\p{Cc}]/u.test(slot.eventId)) {
-            throw new ConnectorError("connector_input_invalid", "For a class, supply only the selected eventId in slot.", { statusCode: 422, messageCode: "connectors.wix.classSupplySelectedEventidSlot" });
-          }
-        } else {
-          let validTimeZone = false;
-          try { validTimeZone = typeof slot.timezone === "string" && !!new Intl.DateTimeFormat("en", { timeZone: slot.timezone }); } catch {}
-          if (!guid(slot.serviceId) || !guid(slot.scheduleId) || !localDate(slot.startDate) || !localDate(slot.endDate) || slot.startDate >= slot.endDate || !validTimeZone) {
-            throw new ConnectorError("connector_input_invalid", "For an appointment, supply its service/schedule IDs, increasing local slot dates and IANA timezone. Courses cannot be rescheduled.", { statusCode: 422, messageCode: "connectors.wix.appointmentSupplyServiceScheduleIds" });
-          }
-        }
-        return { method: "POST", url: `https://www.wixapis.com/_api/bookings-service/v2/bookings/${bookingId}/reschedule`,
-          body: { revision, slot, participantNotification: { notifyParticipants, ...(message === undefined ? {} : { message }) } } };
-      },
-      validateResult: (value, request) => guid(value?.booking?.id) && sameRecord(value.booking.id === requestPath(request, -2), "Wix returned a different booking. Check the operation outcome before retrying.", { messageCode: "connectors.wix.returnedDifferentBookingCheckOperation" }) && typeof value.booking.revision === "string" && /^\d{1,19}$/u.test(value.booking.revision) &&
-        BigInt(value.booking.revision) <= 9223372036854775807n && typeof value.booking.status === "string" && value.booking.status.length > 0
-    },
-    "bookings.confirm": bookingConfirmationOperation("confirm"),
-    "bookings.decline": bookingConfirmationOperation("decline"),
-    "bookings.confirmOrDecline": bookingConfirmationOperation("confirmOrDecline"),
-    "bookingServices.listAddOnGroups": {
-      scopes: [],
-      request(input) {
-        const value = validateSchemaPayload({ schema: serviceIdSchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "POST", url: "https://www.wixapis.com/_api/bookings/v2/services/add-on-groups/list-add-on-groups-by-service-id",
-          body: value };
-      },
-      validateResult: value => Array.isArray(value?.addOnGroupsDetails) && value.addOnGroupsDetails.length <= 3 &&
-        value.addOnGroupsDetails.every(group => guid(group?.groupId) && typeof group.groupName === "string" &&
-          Number.isInteger(group.maxNumberOfAddOns) && group.maxNumberOfAddOns >= 0 &&
-          Array.isArray(group.addOns) && group.addOns.length <= 7 && group.addOns.every(addOn => guid(addOn?.addOnId) && typeof addOn.name === "string"))
-    },
-    "bookingServices.getVariants": {
-      scopes: [],
-      request(input) {
-        const { serviceId } = validateSchemaPayload({ schema: serviceIdSchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "GET", url: `https://www.wixapis.com/bookings/v1/serviceOptionsAndVariants/service_id/${serviceId}` };
-      },
-      validateResult(value, request) {
-        const variants = value?.serviceVariants;
-        return guid(variants?.id) && guid(variants.serviceId) && sameRecord(variants.serviceId === requestPath(request, -1), "Wix returned variants for a different service.", { messageCode: "connectors.wix.returnedVariantsDifferentService" }) &&
-          Array.isArray(variants.options?.values) && variants.options.values.every(option => guid(option?.id) && typeof option.type === "string") &&
-          Array.isArray(variants.variants?.values) && variants.variants.values.every(variant =>
-            Array.isArray(variant?.choices) && variant.choices.every(choice => guid(choice?.optionId)));
-      }
-    },
-    "bookingCategories.list": bookingDirectoryOperation("categories"),
-    "bookingStaff.list": bookingDirectoryOperation("staff"),
-    "bookingServices.setLocations": {
-      scopes: [],
-      request(input) {
-        const { serviceId, locations, removedLocationAction: action, moveToLocation, notifyParticipants, notificationMessage } = validateSchemaPayload({ schema: setServiceLocationsSchema, mode: "replace" }, input, { statusCode: 422 });
-        if ((action === "MOVE_TO_LOCATION") !== (moveToLocation !== undefined)) throw new ConnectorError("connector_input_invalid", "Provide a destination only when moving future sessions.", { statusCode: 422, messageCode: "connectors.wix.provideDestinationMovingFutureSessions" });
-        if (notificationMessage !== undefined && !notifyParticipants) throw new ConnectorError("connector_input_invalid", "Enable participant notification before supplying a message.", { statusCode: 422, messageCode: "connectors.wix.enableParticipantNotificationSupplyingMessage" });
-        for (const location of [...locations, ...(moveToLocation ? [moveToLocation] : [])]) {
-          if (location.type === "BUSINESS" && (!location.business || location.custom) ||
-              location.type === "CUSTOM" && (!location.custom || location.business || !Object.keys(location.custom.address).length) ||
-              location.type === "CUSTOMER" && (location.business || location.custom)) {
-            throw new ConnectorError("connector_input_invalid", "Supply the details matching each service location type.", { statusCode: 422, messageCode: "connectors.wix.supplyDetailsMatchingServiceLocation" });
-          }
-        }
-        return { method: "POST", url: `https://www.wixapis.com/_api/bookings/v2/services/${serviceId}/locations`, body: {
-          locations, removedLocationSessionsAction: { action, ...(moveToLocation ? { moveToLocationOptions: { newLocation: moveToLocation } } : {}) },
-          participantNotification: { notifyParticipants, ...(notificationMessage !== undefined ? { message: notificationMessage } : {}) }
-        } };
-      },
-      validateResult: (value, request) => validService(value?.service) && sameRecord(value.service.id === requestPath(request, -2), "Wix returned a different booking service. Check the outcome before retrying.", { messageCode: "connectors.wix.returnedDifferentBookingServiceCheck" })
-    },
-    "bookingServices.create": {
-      scopes: [],
-      request(input) {
-        const { service } = validateSchemaPayload({ schema: serviceCreateSchema, mode: "replace" }, input, { statusCode: 422 });
-        const invalid = (message, codes) => { throw new ConnectorError("connector_input_invalid", message, { statusCode: 422, ...codes }); };
-        if (!["APPOINTMENT", "CLASS", "COURSE"].includes(service.type) || typeof service.name !== "string" || !service.name.trim() || service.name.length > 400) invalid("Provide a service type and name of up to 400 characters.", { messageCode: "connectors.wix.provideServiceTypeNameUp" });
-        if (["id", "revision", "createdByAppId", "createdDate", "updatedDate", "addOnGroups"].some(key => Object.hasOwn(service, key))) invalid("Do not send generated service identity fields or existing add-on groups when creating a service.", { messageCode: "connectors.wix.doNotSendGeneratedService" });
-        if (!Number.isInteger(service.defaultCapacity) || service.defaultCapacity < 1 || service.defaultCapacity > 1000 || service.type === "APPOINTMENT" && service.defaultCapacity !== 1) invalid("Set appointment capacity to 1, or class/course capacity from 1 to 1000.", { messageCode: "connectors.wix.setAppointmentCapacity1Class" });
-        const online = service.onlineBooking;
-        if (!online || typeof online.enabled !== "boolean" || ["requireManualApproval", "allowMultipleRequests"].some(key => online[key] !== undefined && typeof online[key] !== "boolean")) invalid("Provide explicit online-booking settings.", { messageCode: "connectors.wix.provideExplicitOnlineBookingSettings" });
-        const payment = service.payment;
-        if (!payment || !["FIXED", "VARIED", "CUSTOM", "NO_FEE"].includes(payment.rateType)) invalid("Use FIXED, VARIED, CUSTOM or NO_FEE service payment settings.", { messageCode: "connectors.wix.useFixedVariedCustomNo" });
-        const options = payment.options;
-        if (!options || typeof options !== "object" || ["online", "inPerson", "deposit", "pricingPlan"].some(key => options[key] !== undefined && typeof options[key] !== "boolean") || !(options.online === true || options.inPerson === true)) invalid("Select in-person or online payment, including for a free service.", { messageCode: "connectors.wix.selectPersonOnlinePaymentIncluding" });
-        if (online.requireManualApproval && options.pricingPlan || !online.enabled && options.online) invalid("Manual approval cannot use pricing plans; online payment requires online booking.", { messageCode: "connectors.wix.manualApprovalCannotUsePricing" });
-        const priced = ["FIXED", "VARIED"].includes(payment.rateType);
-        if ((options.online || options.deposit) && !priced) invalid("Online and deposit payments require fixed or varied pricing.", { messageCode: "connectors.wix.onlineDepositPaymentsRequireFixed" });
-        const rate = payment.rateType === "FIXED" ? payment.fixed : payment.varied;
-        const money = value => value && typeof value.value === "string" && value.value.length <= 30 && /^\d+(?:\.\d{1,2})?$/u.test(value.value) && /[1-9]/u.test(value.value) && /^[A-Z]{3}$/u.test(value.currency);
-        if (priced && !money(payment.rateType === "FIXED" ? rate?.price : rate?.defaultPrice)) invalid("Provide a positive decimal price string and three-letter currency code.", { messageCode: "connectors.wix.providePositiveDecimalPriceString" });
-        if (payment.rateType === "CUSTOM" && (typeof payment.custom?.description !== "string" || !payment.custom.description.length || payment.custom.description.length > 50)) invalid("Describe the custom payment in up to 50 characters.", { messageCode: "connectors.wix.describeCustomPaymentUp50" });
-        if (options.deposit && (!options.online || options.inPerson || !money(rate?.deposit))) invalid("A deposit requires its amount, online payment and no in-person payment.", { messageCode: "connectors.wix.depositRequiresAmountOnlinePayment" });
-        const durations = service.schedule?.availabilityConstraints?.sessionDurations;
-        if (service.type === "APPOINTMENT") {
-          if (!Array.isArray(service.staffMemberIds) || !service.staffMemberIds.length || !service.staffMemberIds.every(guid)) invalid("Select at least one staff resource ID for the appointment service.", { messageCode: "connectors.wix.selectLeastStaffResourceId" });
-          if (!Array.isArray(durations) || !durations.length || !durations.every(value => Number.isInteger(value) && value > 0)) invalid("Provide appointment session durations in minutes.", { messageCode: "connectors.wix.provideAppointmentSessionDurationsMinutes" });
-        } else if (durations !== undefined) invalid("Class/course session durations belong to their sessions, not service availability constraints.", { messageCode: "connectors.wix.classCourseSessionDurationsBelong" });
-        return { method: "POST", url: "https://www.wixapis.com/_api/bookings/v2/services", body: { service } };
-      },
-      validateResult: value => validService(value?.service)
-    },
-    "cmsItems.get": {
-      scopes: [],
-      request(input) {
-        const { collectionId: dataCollectionId, itemId, consistentRead } = validateSchemaPayload({ schema: cmsItemGetSchema, mode: "replace" }, input, { statusCode: 422 });
-        const url = new URL(`https://www.wixapis.com/wix-data/v2/items/${encodeURIComponent(itemId)}`);
-        url.searchParams.set("dataCollectionId", dataCollectionId); url.searchParams.set("consistentRead", String(consistentRead));
-        return { method: "GET", url: url.href };
-      },
-      validateResult: (value, request) => value?.dataItem?.data && typeof value.dataItem.data === "object" && !Array.isArray(value.dataItem.data) &&
-        sameRecord(value.dataItem.id === requestPath(request, -1) && value.dataItem.dataCollectionId === new URL(request.url).searchParams.get("dataCollectionId"), "Wix returned a different CMS item or collection. Check write outcomes before retrying.", { messageCode: "connectors.wix.returnedDifferentCmsItemCollection" })
-    },
-    "cmsItems.patch": {
-      scopes: [],
-      request(input) {
-        const { collectionId: dataCollectionId, itemId, fieldModifications, conditionFilter } = validateSchemaPayload({ schema: cmsItemPatchSchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "PATCH", url: `https://www.wixapis.com/wix-data/v2/items/${encodeURIComponent(itemId)}`,
-          body: { dataCollectionId, patch: { dataItemId: itemId, fieldModifications }, ...(conditionFilter !== undefined ? { condition: { filter: conditionFilter } } : {}) } };
-      },
-      validateResult: (value, request) => value?.dataItem?.data && typeof value.dataItem.data === "object" && !Array.isArray(value.dataItem.data) &&
-        sameRecord(value.dataItem.id === requestPath(request, -1) && value.dataItem.dataCollectionId === request.body.dataCollectionId, "Wix returned a different CMS item or collection. Check write outcomes before retrying.", { messageCode: "connectors.wix.returnedDifferentCmsItemCollection" })
-    },
-    "cmsItems.list": {
-      scopes: [],
-      request(input) {
-        const { collectionId: dataCollectionId, consistentRead, filter, sort, fields, returnTotalCount, includeReferences, ...paging } = validateSchemaPayload({ schema: cmsItemQuerySchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "POST", url: "https://www.wixapis.com/wix-data/v2/items/query",
-          body: { dataCollectionId, consistentRead,
-            ...(returnTotalCount !== undefined ? { returnTotalCount } : {}), ...(includeReferences !== undefined ? { includeReferences } : {}),
-            query: { paging, ...(filter !== undefined ? { filter } : {}), ...(sort !== undefined ? { sort } : {}), ...(fields !== undefined ? { fields } : {}) } } };
-      },
-      validateResult: (value, request) => Array.isArray(value?.dataItems) && value.dataItems.length <= 100 && value.dataItems.every(item =>
-        typeof item?.id === "string" && item.id.length > 0 && collectionId(item.dataCollectionId) && item.data && typeof item.data === "object" && !Array.isArray(item.data)) &&
-        (value.pagingMetadata === undefined || value.pagingMetadata && typeof value.pagingMetadata === "object" && !Array.isArray(value.pagingMetadata)) &&
-        sameRecord(value.dataItems.every(item => item.dataCollectionId === request.body.dataCollectionId), "Wix returned items from a different CMS collection.", { messageCode: "connectors.wix.returnedItemsDifferentCmsCollection" })
-    },
-    "cmsCollections.list": {
-      scopes: [],
-      request(input) {
-        const value = validateSchemaPayload({ schema: collectionListSchema, mode: "replace" }, input, { statusCode: 422 });
-        const url = new URL("https://www.wixapis.com/wix-data/v2/collections");
-        url.searchParams.set("paging.limit", String(value.limit)); url.searchParams.set("paging.offset", String(value.offset));
-        url.searchParams.set("consistentRead", String(value.consistentRead));
-        return { method: "GET", url: url.href };
-      },
-      validateResult: value => Array.isArray(value?.collections) && value.collections.length <= 100 && value.collections.every(validCollection) &&
-        (value.pagingMetadata === undefined || value.pagingMetadata && typeof value.pagingMetadata === "object" && !Array.isArray(value.pagingMetadata))
-    },
-    "cmsCollections.get": {
-      scopes: [],
-      request(input) {
-        const value = validateSchemaPayload({ schema: collectionGetSchema, mode: "replace" }, input, { statusCode: 422 });
-        const id = value.collectionId.split("/").map(encodeURIComponent).join("/");
-        return { method: "GET", url: `https://www.wixapis.com/wix-data/v2/collections/${id}?consistentRead=${value.consistentRead}` };
-      },
-      validateResult: (value, request) => validCollection(value?.collection) &&
-        sameRecord(value.collection.id === new URL(request.url).pathname.split("/").slice(4).map(decodeURIComponent).join("/"), "Wix returned a different CMS collection.", { messageCode: "connectors.wix.returnedDifferentCmsCollection" })
-    },
-    "locations.archive": locationActionOperation("archive"),
-    "locations.setDefault": locationActionOperation("set-default"),
-    "locations.create": locationWriteOperation("create"),
-    "locations.update": locationWriteOperation("update"),
-    "locations.list": {
-      scopes: [],
-      request(input) {
-        const { archived, ...paging } = validateSchemaPayload({ schema: locationQuerySchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "POST", url: "https://www.wixapis.com/locations/v1/locations/query",
-          body: { query: { filter: { archived }, paging }, filterAuthorizedLocationEntities: true } };
-      },
-      validateResult: value => Array.isArray(value?.locations) && value.locations.length <= 100 && value.locations.every(validLocation) &&
-        (value.pagingMetadata === undefined || value.pagingMetadata && typeof value.pagingMetadata === "object" && !Array.isArray(value.pagingMetadata) &&
-          ["count", "offset", "total"].every(key => value.pagingMetadata[key] === undefined || Number.isSafeInteger(value.pagingMetadata[key]) && value.pagingMetadata[key] >= 0))
-    },
-    "locations.get": {
-      scopes: [],
-      request(input) {
-        const { locationId } = validateSchemaPayload({ schema: locationGetSchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "GET", url: `https://www.wixapis.com/locations/v1/locations/${locationId}` };
-      },
-      validateResult: (value, request) => validLocation(value?.location) && sameRecord(value.location.id === requestPath(request, -1), "Wix returned a different business location.", { messageCode: "connectors.wix.returnedDifferentBusinessLocation" })
-    },
-    "productsV1.list": productReadOperation(1, "list"),
-    "productsV1.get": productReadOperation(1, "get"),
-    "productsV1.update": {
-      scopes: [],
-      request(input) {
-        const { productId, price, ...changes } = validateSchemaPayload({ schema: productV1UpdateSchema, mode: "replace" }, input, { statusCode: 422 });
-        if (!Object.keys(changes).length && price === undefined) throw new ConnectorError("connector_input_invalid", "Provide a product name, visibility or base-price change.", { statusCode: 422, messageCode: "connectors.wix.provideProductNameVisibilityBase" });
-        return { method: "PATCH", url: `https://www.wixapis.com/stores/v1/products/${productId}`,
-          body: { product: { ...changes, ...(price === undefined ? {} : { priceData: { price } }) } } };
-      },
-      validateResult: (value, request) => guid(value?.product?.id) && typeof value.product.name === "string" && value.product.name.length > 0 &&
-        sameRecord(value.product.id === requestPath(request, -1), "Wix returned a different product.", { messageCode: "connectors.wix.returnedDifferentProduct" })
-    },
-    "productsV3.list": productReadOperation(3, "list"),
-    "productsV3.get": productReadOperation(3, "get"),
-    "productsV3.update": {
-      scopes: [],
-      request(input) {
-        const { productId, revision, ...changes } = validateSchemaPayload({ schema: productV3UpdateSchema, mode: "replace" }, input, { statusCode: 422 });
-        if (!Object.keys(changes).length) throw new ConnectorError("connector_input_invalid", "Provide a product name or visibility change.", { statusCode: 422, messageCode: "connectors.wix.provideProductNameVisibilityChange" });
-        return { method: "PATCH", url: `https://www.wixapis.com/stores/v3/products/${productId}`,
-          body: { product: { id: productId, revision, ...changes } } };
-      },
-      validateResult: (value, request) => guid(value?.product?.id) && typeof value.product.name === "string" && value.product.name.length > 0 &&
-        sameRecord(value.product.id === requestPath(request, -1), "Wix returned a different product.", { messageCode: "connectors.wix.returnedDifferentProduct" }) &&
-        typeof value.product.revision === "string" && /^\d{1,19}$/u.test(value.product.revision) && BigInt(value.product.revision) <= 9223372036854775807n
-    },
-    "catalog.version": {
-      scopes: [],
-      request(input) {
-        validateSchemaPayload({ schema: catalogVersionSchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "GET", url: "https://www.wixapis.com/stores/v3/provision/version" };
-      }, validateResult: value => ["V1_CATALOG", "V3_CATALOG", "STORES_NOT_INSTALLED"].includes(value?.catalogVersion)
-    },
-    "orders.list": {
-      scopes: [],
-      request(input) {
-        const { status, contactId, ...cursorPaging } = validateSchemaPayload({ schema: orderSearchSchema, mode: "replace" }, input, { statusCode: 422 });
-        if (cursorPaging.cursor && (status || contactId)) throw new ConnectorError("connector_input_invalid", "Use only cursor and limit for the next order page.", { statusCode: 422, messageCode: "connectors.wix.useCursorLimitNextOrder" });
-        const filter = { ...(status ? { status } : {}), ...(contactId ? { "buyerInfo.contactId": contactId } : {}) };
-        return { method: "POST", url: "https://www.wixapis.com/ecom/v1/orders/search",
-          body: { search: { cursorPaging, ...(Object.keys(filter).length ? { filter } : {}) } } };
-      },
-      validateResult: value => Array.isArray(value?.orders) && value.orders.length <= 100 && value.orders.every(validOrder) &&
-        (value.metadata === undefined || value.metadata && typeof value.metadata === "object" && !Array.isArray(value.metadata) &&
-          (value.metadata.count === undefined || value.metadata.count === value.orders.length) &&
-          (value.metadata.hasNext === undefined || typeof value.metadata.hasNext === "boolean") &&
-          (value.metadata.cursors === undefined || value.metadata.cursors && typeof value.metadata.cursors === "object" && !Array.isArray(value.metadata.cursors) &&
-            ["next", "prev"].every(key => value.metadata.cursors[key] === undefined || cursor(value.metadata.cursors[key]))))
-    },
-    "orders.get": {
-      scopes: [],
-      request(input) {
-        const { orderId } = validateSchemaPayload({ schema: orderIdSchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "GET", url: `https://www.wixapis.com/ecom/v1/orders/${encodeURIComponent(orderId)}` };
-      }, validateResult: (value, request) => validOrder(value?.order) && sameRecord(value.order.id === requestPath(request, -1), "Wix returned a different order.", { messageCode: "connectors.wix.returnedDifferentOrder" })
-    },
-    "orderFulfillments.create": fulfillmentWriteOperation(false),
-    "orderFulfillments.update": fulfillmentWriteOperation(true),
-    "orderFulfillments.list": {
-      scopes: [],
-      request(input) {
-        const { orderId } = validateSchemaPayload({ schema: orderIdSchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "GET", url: `https://www.wixapis.com/ecom/v1/fulfillments/orders/${encodeURIComponent(orderId)}` };
-      },
-      validateResult: (value, request) => guid(value?.orderWithFulfillments?.orderId) &&
-        sameRecord(value.orderWithFulfillments.orderId === requestPath(request, -1), "Wix returned fulfillments for a different order.", { messageCode: "connectors.wix.returnedFulfillmentsDifferentOrder" }) &&
-        Array.isArray(value.orderWithFulfillments.fulfillments) &&
-        value.orderWithFulfillments.fulfillments.every(item => guid(item?.id) && Array.isArray(item.lineItems) && item.lineItems.length <= 300 &&
-          item.lineItems.every(line => guid(line?.id) && Number.isInteger(line.quantity) && line.quantity >= 1 && line.quantity <= 100000))
-    },
-    "classAvailability.list": availabilityOperation("list", true),
-    "classAvailability.get": {
-      scopes: [],
-      request(input) {
-        const { eventId, timeZone } = validateSchemaPayload({ schema: eventSlotSchema, mode: "replace" }, input, { statusCode: 422 });
-        const url = new URL(`https://www.wixapis.com/_api/service-availability/v2/time-slots/event/${encodeURIComponent(eventId)}`);
-        url.searchParams.set("timeZone", timeZone);
-        return { method: "GET", url: url.href };
-      }, validateResult: (value, request) => validSlot(value?.timeSlot) && typeof value.timeSlot.eventInfo?.eventId === "string" && typeof value.timeZone === "string" &&
-        sameRecord(value.timeSlot.eventInfo.eventId === requestPath(request, -1) && value.timeZone === new URL(request.url).searchParams.get("timeZone"), "Wix returned a different event slot or time zone.", { messageCode: "connectors.wix.returnedDifferentEventSlotTime" })
-    },
-    "forms.summary": {
-      scopes: [],
-      request(input) {
-        const { formId } = validateSchemaPayload({ schema: formSummarySchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "GET", url: `https://www.wixapis.com/form-schema-service/v4/forms/${formId}/summary` };
-      },
-      validateResult: (value, request) => guid(value?.formSummary?.id) && sameRecord(value.formSummary.id === requestPath(request, -2), "Wix returned a different form summary.", { messageCode: "connectors.wix.returnedDifferentFormSummary" }) &&
-        Array.isArray(value.formSummary.fields) && value.formSummary.fields.length <= 500 &&
-        value.formSummary.fields.every(field => guid(field?.id) && typeof field.target === "string" && field.target.length > 0 && field.target.length <= 200 &&
-          typeof field.type === "string" && field.type.length > 0 && (field.label === undefined || typeof field.label === "string" && field.label.length <= 350) &&
-          (field.deleted === undefined || typeof field.deleted === "boolean") && (field.options === undefined || Array.isArray(field.options) && field.options.length <= 400))
-    },
-    "bookings.create": {
-      scopes: [],
-      request(input) {
-        const value = validateSchemaPayload({ schema: bookingCreateSchema, mode: "replace" }, input, { statusCode: 422 });
-        const { kind, serviceId, timeZone, startDate, endDate, eventId, scheduleId, resourceId, location, totalParticipants, participantsChoices, bookedAddOns, formSubmission, notifyParticipants, sendSmsReminder } = value;
-        if (participantsChoices) {
-          if (totalParticipants !== undefined) throw new ConnectorError("connector_input_invalid", "Use participant choices or a fixed participant total, not both.", { statusCode: 422, messageCode: "connectors.wix.useParticipantChoicesFixedParticipant" });
-          if (participantsChoices.serviceChoices.reduce((total, group) => total + group.numberOfParticipants, 0) > 1000 ||
-              participantsChoices.serviceChoices.some(group => new Set(group.choices.map(choice => choice.optionId)).size !== group.choices.length ||
-                group.choices.some(choice => (choice.custom !== undefined) === (choice.duration !== undefined)))) {
-            throw new ConnectorError("connector_input_invalid", "Use at most 1000 participants, distinct options per group and exactly one custom or duration value per choice.", { statusCode: 422, messageCode: "connectors.wix.useMost1000ParticipantsDistinct" });
-          }
-        }
-        if (kind === "APPOINTMENT" ? !startDate || !endDate || startDate >= endDate || !resourceId || !location || eventId || scheduleId :
-            kind === "CLASS" ? !eventId || startDate || endDate || resourceId || location || scheduleId : !scheduleId || startDate || endDate || resourceId || location || eventId) {
-          throw new ConnectorError("connector_input_invalid", "Use appointment dates/resource/location, a class event ID, or a course schedule ID, matching the selected service type.", { statusCode: 422, messageCode: "connectors.wix.useAppointmentDatesResourceLocation" });
-        }
-        if (location?.locationType === "OWNER_BUSINESS" && !location.id) throw new ConnectorError("connector_input_invalid", "Choose the business location ID.", { statusCode: 422, messageCode: "connectors.wix.chooseBusinessLocationId" });
-        const bookedEntity = kind === "COURSE" ? { schedule: { scheduleId, serviceId, timezone: timeZone } } :
-          { slot: { serviceId, timezone: timeZone, ...(kind === "CLASS" ? { eventId } : { startDate, endDate, resource: { id: resourceId }, location }) } };
-        return { method: "POST", url: "https://www.wixapis.com/_api/bookings-service/v2/bookings",
-          body: { booking: { bookedEntity, ...(participantsChoices ? { participantsChoices } : { totalParticipants: totalParticipants ?? 1 }),
-            ...(bookedAddOns ? { bookedAddOns } : {}) }, formSubmission, participantNotification: { notifyParticipants }, sendSmsReminder } };
-      },
-      validateResult: value => guid(value?.booking?.id) && typeof value.booking.revision === "string" && /^\d{1,19}$/u.test(value.booking.revision) &&
-        BigInt(value.booking.revision) <= 9223372036854775807n && typeof value.booking.status === "string" && value.booking.status.length > 0
-    },
-    "availability.list": availabilityOperation("list"),
-    "availability.get": availabilityOperation("get"),
-    "bookings.list": {
-      scopes: [],
-      request(input) {
-        const { bookingId, ...paging } = validateSchemaPayload({ schema: bookingQuerySchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "POST", url: "https://www.wixapis.com/_api/bookings-reader/v2/extended-bookings/query",
-          body: { query: { paging, ...(bookingId ? { filter: { id: bookingId } } : {}) }, withBookingAllowedActions: true } };
-      },
-      validateResult: (value, request) => Array.isArray(value?.extendedBookings) && value.extendedBookings.length <= 100 && value.extendedBookings.every(record =>
-        guid(record?.booking?.id) && typeof record.booking.revision === "string" && /^\d{1,19}$/u.test(record.booking.revision) && BigInt(record.booking.revision) <= 9223372036854775807n &&
-        typeof record.booking.status === "string" && record.booking.status.length > 0 &&
-        (record.allowedActions === undefined || record.allowedActions && typeof record.allowedActions === "object" && !Array.isArray(record.allowedActions) &&
-          ["cancel", "reschedule"].every(key => record.allowedActions[key] === undefined || typeof record.allowedActions[key] === "boolean"))) &&
-        (value.pagingMetadata === undefined || value.pagingMetadata && typeof value.pagingMetadata === "object" && !Array.isArray(value.pagingMetadata) &&
-          ["count", "offset", "total"].every(key => value.pagingMetadata[key] === undefined || Number.isSafeInteger(value.pagingMetadata[key]) && value.pagingMetadata[key] >= 0) &&
-          (value.pagingMetadata.count === undefined || value.pagingMetadata.count === value.extendedBookings.length)) &&
-        (!request.body.query.filter?.id || sameRecord(value.extendedBookings.length <= 1 && value.extendedBookings.every(record => record.booking.id === request.body.query.filter.id),
-          "Wix returned an unexpected booking for the requested ID.", { messageCode: "connectors.wix.returnedUnexpectedBookingRequestedId" }))
-    },
-    "bookings.cancel": {
-      scopes: [],
-      request(input) {
-        const { bookingId, revision, notifyParticipants, message, waiveCharges } = validateSchemaPayload({ schema: bookingCancelSchema, mode: "replace" }, input, { statusCode: 422 });
-        if (message && !notifyParticipants) throw new ConnectorError("connector_input_invalid", "Enable participant notification to send a cancellation message.", { statusCode: 422, messageCode: "connectors.wix.enableParticipantNotificationSendCancellation" });
-        return { method: "POST", url: `https://www.wixapis.com/_api/bookings-service/v2/bookings/${bookingId}/cancel`,
-          body: { revision, waiveCharges,
-            participantNotification: { notifyParticipants, ...(message === undefined ? {} : { message }) } } };
-      },
-      validateResult: (value, request) => guid(value?.booking?.id) && sameRecord(value.booking.id === requestPath(request, -2), "Wix returned a different booking. Check the operation outcome before retrying.", { messageCode: "connectors.wix.returnedDifferentBookingCheckOperation" }) && value.booking.status === "CANCELED" &&
-        typeof value.booking.revision === "string" && /^\d{1,19}$/u.test(value.booking.revision) && BigInt(value.booking.revision) <= 9223372036854775807n
-    },
-    "bookingServices.list": {
-      scopes: [],
-      request(input) {
-        const paging = validateSchemaPayload({ schema: servicePagingSchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "POST", url: "https://www.wixapis.com/_api/bookings/v2/services/query", body: { query: { paging } } };
-      },
-      validateResult: value => Array.isArray(value?.services) && value.services.length <= 100 && value.services.every(validService) &&
-        (value.pagingMetadata === undefined || value.pagingMetadata && typeof value.pagingMetadata === "object" && !Array.isArray(value.pagingMetadata) &&
-          ["count", "offset", "total"].every(key => value.pagingMetadata[key] === undefined || Number.isSafeInteger(value.pagingMetadata[key]) && value.pagingMetadata[key] >= 0) &&
-          (value.pagingMetadata.count === undefined || value.pagingMetadata.count === value.services.length))
-    },
-    "bookingServices.get": {
-      scopes: [],
-      request(input) {
-        const { serviceId } = validateSchemaPayload({ schema: serviceIdSchema, mode: "replace" }, input, { statusCode: 422 });
-        return { method: "GET", url: `https://www.wixapis.com/_api/bookings/v2/services/${serviceId}` };
-      }, validateResult: (value, request) => validService(value?.service) && sameRecord(value.service.id === requestPath(request, -1), "Wix returned a different booking service. Check the outcome before retrying.", { messageCode: "connectors.wix.returnedDifferentBookingServiceCheck" })
-    },
-    "bookingServices.update": {
-      scopes: [],
-      request(input) {
-        const { serviceId, ...service } = validateSchemaPayload({ schema: serviceUpdateSchema, mode: "replace" }, input, { statusCode: 422 });
-        if (Object.keys(service).length < 2) throw new ConnectorError("connector_input_invalid", "Choose a service field to update.", { statusCode: 422, messageCode: "connectors.wix.chooseServiceFieldUpdate" });
-        if (["payment", "onlineBooking"].some(key => service[key] !== undefined && !Object.keys(service[key]).length) ||
-            service.schedule && !Object.keys(service.schedule.availabilityConstraints).length) {
-          throw new ConnectorError("connector_input_invalid", "Provide the selected service settings instead of an empty object.", { statusCode: 422, messageCode: "connectors.wix.provideSelectedServiceSettingsInstead" });
-        }
-        return { method: "PATCH", url: `https://www.wixapis.com/_api/bookings/v2/services/${serviceId}`, body: { service: { id: serviceId, ...service } } };
-      }, validateResult: (value, request) => validService(value?.service) && sameRecord(value.service.id === requestPath(request, -1), "Wix returned a different booking service. Check the outcome before retrying.", { messageCode: "connectors.wix.returnedDifferentBookingServiceCheck" })
-    },
+    ...wixStoreOperations,
+    ...wixBookingOperations,
+    ...wixCmsOperations,
     "contacts.get": contactOperation("get"),
     "contacts.create": contactOperation("create"),
     "contacts.update": contactOperation("update"),
@@ -933,8 +75,8 @@ const wixRuntime = {
           body: { query: { paging }, ...(search === undefined ? {} : { search }) } };
       },
       validateResult: value => Array.isArray(value?.contacts) && value.contacts.length <= 100 &&
-        value.contacts.every(contact => guid(contact?.id) && (contact.info === undefined || contact.info && typeof contact.info === "object" && !Array.isArray(contact.info))) &&
-        (value.pagingMetadata === undefined || value.pagingMetadata && typeof value.pagingMetadata === "object" && !Array.isArray(value.pagingMetadata) &&
+        value.contacts.every(contact => isUuid(contact?.id) && (contact.info === undefined || isRecord(contact.info))) &&
+        (value.pagingMetadata === undefined || isRecord(value.pagingMetadata) &&
           ["count", "offset", "total"].every(key => value.pagingMetadata[key] === undefined || Number.isSafeInteger(value.pagingMetadata[key]) && value.pagingMetadata[key] >= 0) &&
           (value.pagingMetadata.count === undefined || value.pagingMetadata.count === value.contacts.length))
     },
@@ -944,12 +86,12 @@ const wixRuntime = {
         const paging = validateSchemaPayload({ schema: querySchema, mode: "replace" }, input, { statusCode: 422 });
         return { method: "POST", url: "https://www.wixapis.com/site-list/v2/sites/query", body: { query: { cursorPaging: paging } } };
       },
-      validateResult: (value) => Array.isArray(value?.sites) && value.sites.length <= 100 && value.sites.every((site) => guid(site?.id) &&
+      validateResult: (value) => Array.isArray(value?.sites) && value.sites.length <= 100 && value.sites.every((site) => isUuid(site?.id) &&
         ["name", "displayName", "viewUrl", "editUrl", "thumbnail"].every((key) => site[key] === undefined || typeof site[key] === "string") &&
         ["published", "premium", "domainConnected"].every((key) => site[key] === undefined || typeof site[key] === "boolean")) &&
-        (value.metadata === undefined || value.metadata && typeof value.metadata === "object" && !Array.isArray(value.metadata) &&
+        (value.metadata === undefined || isRecord(value.metadata) &&
           (value.metadata.count === undefined || Number.isSafeInteger(value.metadata.count) && value.metadata.count === value.sites.length) &&
-          (value.metadata.cursors === undefined || value.metadata.cursors && typeof value.metadata.cursors === "object" && !Array.isArray(value.metadata.cursors) &&
+          (value.metadata.cursors === undefined || isRecord(value.metadata.cursors) &&
             ["next", "prev"].every((key) => value.metadata.cursors[key] === undefined || cursor(value.metadata.cursors[key]))))
     }
   }
@@ -962,10 +104,10 @@ function wixSiteOperation(operation) {
       let siteId = settings.siteId, values = input;
       if (input && Object.hasOwn(input, "siteId")) {
         ({ siteId, ...values } = input);
-        if (!guid(siteId)) throw new ConnectorError("connector_input_invalid", "Choose a valid Wix Site ID.", { statusCode: 422, messageCode: "connectors.wix.chooseValidSiteId" });
+        if (!isUuid(siteId)) throw new ConnectorError("connector_input_invalid", "Choose a valid Wix Site ID.", { statusCode: 422, messageCode: "connectors.wix.chooseValidSiteId" });
         const allowed = (settings.selectableSiteIds || "").split(",").map(id => id.trim().toLowerCase());
         if (!allowed.includes(siteId.toLowerCase())) throw new ConnectorError("connector_input_invalid", "This site is not enabled in the project's Selectable Site IDs.", { statusCode: 422, messageCode: "connectors.wix.siteNotEnabledProjectSelectable" });
-      } else if (!guid(siteId)) throw new ConnectorError("connector_input_invalid", "Configure the Wix Site ID first.", { statusCode: 422, messageCode: "connectors.wix.configureSiteIdFirst" });
+      } else if (!isUuid(siteId)) throw new ConnectorError("connector_input_invalid", "Configure the Wix Site ID first.", { statusCode: 422, messageCode: "connectors.wix.configureSiteIdFirst" });
       const request = operation.request(values, { ...settings, siteId });
       return { ...request, headers: { ...request.headers, "wix-site-id": siteId } };
     }