@wix/himalaya-cli 0.1536.0 → 0.1538.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/bookings-v2/src/extensions.d.ts

@@ -126,6 +126,22 @@ export interface WixQueryServicesResponse {
  *  read it — NOT the owner/BO `_api/` gateway (which fails for visitors, #463). Takes
  *  the standard query envelope (filter/sort/paging). */
 export declare function queryServices(req?: WixQueryServicesRequest): Promise<WixQueryServicesResponse>;
+/** One service category, as the categories query returns it. `sortOrder` is the business's
+ *  own order; the response is already in it. */
+export interface WixServiceCategory {
+    id?: string;
+    name?: string;
+    sortOrder?: number;
+}
+export interface WixQueryServiceCategoriesResponse {
+    categories: WixServiceCategory[];
+}
+/** List the site's service categories — POST /bookings/v2/services/categories/query with an
+ *  empty body. Returns only the categories that have services, in the business's own order
+ *  (the order of the site's Book Online page). Verified live 2026-11-01 with an anonymous
+ *  visitor token: 200.
+ *  @scope visitor — an anonymous visitor session is enough. */
+export declare function queryServiceCategories(): Promise<WixQueryServiceCategoriesResponse>;
 export interface WixGetServiceResponse {
     service: WixService;
 }

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/data-collections-v1/src/extensions.d.ts

@@ -4,5 +4,9 @@ export declare function createDataCollection(collection: WixDataCollection): Pro
 /**
  * Replace a data collection's schema. Wix uses optimistic concurrency: pass the
  * `revision` read from getDataCollection, or the call is rejected as stale.
+ *
+ * The id travels in the body — `PUT /data/v2/collections` with `{ collection }`, as Wix
+ * documents it; the path form `PUT /data/v2/collections/{id}` is not a route. Needs an owner
+ * identity, and the call replaces the schema, so send every field you want to keep.
  */
 export declare function updateDataCollection(collection: WixDataCollection): Promise<WixUpdateDataCollectionResponse>;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/wix-data/src/index.d.ts

@@ -20,15 +20,50 @@ export interface WixDataSort {
     fieldName: string;
     order?: "ASC" | "DESC";
 }
+/** Cursor paging: pass `cursor` from the previous page's `pagingMetadata.cursors.next`. */
+export interface WixDataCursorPaging {
+    limit?: number;
+    cursor?: string;
+}
+/** Inline the items a reference or multi-reference field points at. */
+export interface WixIncludeReference {
+    field: string;
+    /** Per-item cap on inlined references. Wix defaults to 50 and allows up to 1000. */
+    limit?: number;
+}
+/** The rarely-needed read parameters of `queryDataItems`. Every field is omitted from the wire
+ *  body unless set, so a caller that passes none sends the exact body it always sent. */
+export interface WixQueryOptions {
+    /** Read from the primary database instance instead of the nearest mirror. Slower, but a read
+     *  right after your own write sees it — the default is eventually consistent. */
+    consistentRead?: boolean;
+    /** Page by cursor instead of `offset`. Mutually exclusive with `offset`. */
+    cursorPaging?: WixDataCursorPaging;
+    /** Return only these fields (`_id` always comes back). */
+    fields?: string[];
+    includeReferences?: WixIncludeReference[];
+    /** IETF BCP 47 tag; needs Wix Multilingual enabled for the collection. */
+    language?: string;
+    /** Also read pending drafts (collections with the draft-items plugin). */
+    includeDraftItems?: boolean;
+}
 export interface WixQueryDataItemsRequest {
     dataCollectionId: string;
     query?: {
         filter?: Record<string, unknown>;
         paging?: WixDataPaging;
+        cursorPaging?: WixDataCursorPaging;
         sort?: WixDataSort[];
+        fields?: string[];
     };
     /** When true, `pagingMetadata.total` is filled (offset paging only). Default omitted. */
     returnTotalCount?: boolean;
+    consistentRead?: boolean;
+    includeReferences?: WixIncludeReference[];
+    language?: string;
+    publishPluginOptions?: {
+        includeDraftItems: boolean;
+    };
 }
 export interface WixQueryDataItemsResponse {
     dataItems?: WixDataItem[];
@@ -39,14 +74,27 @@ export interface WixQueryDataItemsResponse {
         total?: number;
         totalCount?: number;
         tooManyToCount?: boolean;
+        /** Present under cursor paging. `next` is absent on the last page. */
+        cursors?: {
+            next?: string;
+            prev?: string;
+        };
     };
 }
 export interface WixInsertDataItemRequest {
     dataCollectionId: string;
     dataItem: {
+        id?: string;
         data: Record<string, unknown>;
     };
 }
+/** Optional `insertDataItem` parameters. */
+export interface WixInsertDataItemOptions {
+    /** A client-chosen item id (max 128 chars). Wix keeps it verbatim and answers a second insert
+     *  of the same id with 409 `WDE0074` rather than a duplicate — which is what makes a retry
+     *  after a lost response safe, and what the offline outbox relies on. */
+    id?: string;
+}
 export interface WixUpdateDataItemRequest {
     dataCollectionId: string;
     dataItem: {
@@ -85,8 +133,34 @@ export interface WixUpdateDataItemRequest {
  *  ```
  *
  *  To read ONE row, use `getDataItem` rather than a page plus a client-side
- *  `.find()` — that pattern breaks silently once the collection outgrows `limit`. */
-export declare function queryDataItems(dataCollectionId: string, limit?: number, filter?: Record<string, unknown>, returnTotalCount?: boolean, offset?: number, sort?: WixDataSort[]): Promise<WixQueryDataItemsResponse>;
+ *  `.find()` — that pattern breaks silently once the collection outgrows `limit`.
+ *
+ *  The seventh argument carries the rarer read options. `consistentRead` is the one that
+ *  matters after your own write — the default read may come from a mirror that has not caught
+ *  up yet, so "insert, then query" can miss the row you just wrote:
+ *
+ *  ```ts
+ *  await insertDataItem("Messages", { text });
+ *  await queryDataItems("Messages", 50, undefined, false, 0, undefined, { consistentRead: true });
+ *  ```
+ *
+ *  `cursorPaging` pages by an opaque cursor instead of `offset` (up to 1000 per page, and it
+ *  stays correct while rows are inserted between pages). Define `filter`, `sort` and
+ *  `returnTotalCount` on the first request: the cursor carries them, and Wix refuses a follow-up
+ *  that sends them again (`400 WDE0080`, checked against a live site), so this drops them
+ *  whenever a cursor is passed and the same arguments can be reused for every page. `fields` projects, and
+ *  `includeReferences` inlines referenced items (a multi-reference field is absent from a
+ *  result unless it is named here).
+ *
+ *  ```ts
+ *  let cursor: string | undefined;
+ *  do {
+ *    const page = await queryDataItems("Posts", 50, { status: "live" }, false, 0, undefined, { cursorPaging: { cursor } });
+ *    render(page.dataItems);
+ *    cursor = page.pagingMetadata?.cursors?.next; // absent on the last page: stop there
+ *  } while (cursor);
+ *  ``` */
+export declare function queryDataItems(dataCollectionId: string, limit?: number, filter?: Record<string, unknown>, returnTotalCount?: boolean, offset?: number, sort?: WixDataSort[], options?: WixQueryOptions): Promise<WixQueryDataItemsResponse>;
 /** Read ONE item by id — GET /wix-data/v2/items/{dataItemId}?dataCollectionId=…
  *
  *  Reach for this on a detail screen. Before it existed the only read this package
@@ -112,8 +186,15 @@ export declare function queryDataItems(dataCollectionId: string, limit?: number,
 export declare function getDataItem(dataCollectionId: string, dataItemId: string): Promise<{
     dataItem?: WixDataItem;
 }>;
-/** Insert an item — POST /wix-data/v2/items. */
-export declare function insertDataItem(dataCollectionId: string, data: Record<string, unknown>): Promise<{
+/** Insert an item — POST /wix-data/v2/items.
+ *
+ *  Insert is create-only: a second insert of an existing id fails with 409 `WDE0074` instead of
+ *  overwriting. Pass `{ id }` to choose the id yourself — mint it once before the first attempt
+ *  and a retry after a lost response cannot create a duplicate (the 409 means "already there").
+ *  Wix reads the id from the item envelope and refuses `data._id` on its own (`400 WDE0080`), so an
+ *  `_id` given only inside `data` is moved onto the envelope for you. To insert-or-replace by id,
+ *  use `saveDataItem`. */
+export declare function insertDataItem(dataCollectionId: string, data: Record<string, unknown>, options?: WixInsertDataItemOptions): Promise<{
     dataItem?: WixDataItem;
 }>;
 /** Update an item — PUT /wix-data/v2/items/{id}. */
@@ -122,4 +203,416 @@ export declare function updateDataItem(dataCollectionId: string, id: string, dat
 }>;
 /** Remove an item — DELETE /wix-data/v2/items/{id}?dataCollectionId=…. */
 export declare function removeDataItem(dataCollectionId: string, id: string): Promise<unknown>;
+/** One edit inside a patch. Build them with `setField`, `removeField`, `incrementField`,
+ *  `appendToArray` and `removeFromArray` rather than by hand. */
+export type WixFieldModification = {
+    fieldPath: string;
+    action: "SET_FIELD";
+    setFieldOptions: {
+        value: unknown;
+    };
+} | {
+    fieldPath: string;
+    action: "REMOVE_FIELD";
+} | {
+    fieldPath: string;
+    action: "INCREMENT_FIELD";
+    incrementFieldOptions: {
+        value: number;
+    };
+} | {
+    fieldPath: string;
+    action: "APPEND_TO_ARRAY";
+    appendToArrayOptions: {
+        value: unknown;
+    };
+} | {
+    fieldPath: string;
+    action: "REMOVE_FROM_ARRAY";
+    removeFromArrayOptions: {
+        value: unknown;
+    };
+};
+/** Set one field to `value`, leaving every other field alone. `fieldPath` may be dotted
+ *  (`"address.city"`). For a MULTI_REFERENCE field `value` is an array of item ids and the
+ *  call REPLACES the whole link set. */
+export declare function setField(fieldPath: string, value: unknown): WixFieldModification;
+/** Clear one field. */
+export declare function removeField(fieldPath: string): WixFieldModification;
+/** Add `by` to a numeric field atomically on the server (negative to subtract). Two devices that
+ *  each increment a counter both land; a read-then-`updateDataItem` would lose one. */
+export declare function incrementField(fieldPath: string, by?: number): WixFieldModification;
+/** Append `value` to an array field. Not for MULTI_REFERENCE fields — Wix fails that per item
+ *  with `WDE0303`; use `insertDataItemReferences` or `setField` with an array of ids. */
+export declare function appendToArray(fieldPath: string, value: unknown): WixFieldModification;
+/** Remove the first occurrence of `value` from an array field. */
+export declare function removeFromArray(fieldPath: string, value: unknown): WixFieldModification;
+/** Change only the named fields of one item — PATCH /wix-data/v2/items/{id}.
+ *
+ *  Prefer this to `updateDataItem` for any partial change. `updateDataItem` REPLACES the whole
+ *  item, so sending two fields deletes every other field — including the one you look the row up
+ *  by. A patch touches only what you name, can increment a number atomically, and takes 1 to 100
+ *  modifications.
+ *
+ *  ```ts
+ *  await patchDataItem("Posts", id, [setField("title", "New"), incrementField("views")]);
+ *  ```
+ *
+ *  Works on collections created in the CMS or through the API; Wix does not support it on Wix
+ *  app collections (Stores products and the like). Needs write permission on the collection
+ *  for the calling identity.
+ *
+ *  @scope visitor — enough when the collection's update role is ANYONE; a stricter role answers `403 WDE0027` (checked against a live site).
+ */
+export declare function patchDataItem(dataCollectionId: string, dataItemId: string, fieldModifications: WixFieldModification[]): Promise<{
+    dataItem?: WixDataItem;
+}>;
+/** Optional `saveDataItem` parameters. */
+export interface WixSaveDataItemOptions {
+    /** The item's id (max 128 chars). If an item with this id exists it is replaced, otherwise it is
+     *  created with exactly this id. Omit it to let Wix generate one. */
+    id?: string;
+}
+/** Insert the item, or replace it if the id already exists — POST /wix-data/v2/items/save.
+ *
+ *  With an explicit `{ id }` this is the idempotent write: saving the same id twice leaves one row
+ *  holding the second write, so it is safe to retry and it is one of the two item writes the
+ *  offline write queue may hold (last write wins — there is no revision check). On an existing id
+ *  it REPLACES the whole item like `updateDataItem` — use `patchDataItem` to change only some fields.
+ *
+ *  Without an id Wix generates one and the call is an insert, so a retry after a lost response adds
+ *  a second row: mint the id once and pass it if you may retry. An `_id` given only inside `data` is
+ *  moved onto the envelope. `action` in the result says which happened (`INSERT` or `UPDATE`).
+ *
+ *  @scope visitor — enough when the collection's insert and update roles are ANYONE; a stricter role answers `403 WDE0027` (checked against a live site).
+ */
+export declare function saveDataItem(dataCollectionId: string, data: Record<string, unknown>, options?: WixSaveDataItemOptions): Promise<{
+    action?: string;
+    dataItem?: WixDataItem;
+}>;
+/** Optional read parameters shared by the count, aggregate and reference reads. */
+export interface WixReadOptions {
+    /** Read from the primary instance; see `WixQueryOptions.consistentRead`. */
+    consistentRead?: boolean;
+    language?: string;
+    includeDraftItems?: boolean;
+}
+/** How many items match — POST /wix-data/v2/items/count.
+ *
+ *  One read, and cheaper than `queryDataItems(..., returnTotalCount)` when you do not need the
+ *  rows. `filter` is the same Wix filter object `queryDataItems` takes. Returns `{ totalCount }`.
+ *
+ *  @scope visitor — enough when the collection's read role is ANYONE; a stricter role answers `403 WDE0027` (checked against a live site).
+ */
+export declare function countDataItems(dataCollectionId: string, filter?: Record<string, unknown>, options?: WixReadOptions): Promise<{
+    totalCount?: number;
+}>;
+export interface WixBulkItemError {
+    code?: string;
+    description?: string;
+    data?: Record<string, unknown>;
+}
+export interface WixBulkItemMetadata {
+    id?: string;
+    /** Index of this item in the array you sent — how a result is matched back to its input. */
+    originalIndex?: number;
+    success?: boolean;
+    error?: WixBulkItemError;
+}
+export interface WixBulkDataItemResult {
+    action?: string;
+    itemMetadata?: WixBulkItemMetadata;
+    /** Present only when the request set `returnEntity: true`. */
+    dataItem?: WixDataItem;
+}
+export interface WixBulkActionMetadata {
+    totalSuccesses?: number;
+    totalFailures?: number;
+}
+export interface WixBulkDataItemsResponse {
+    results?: WixBulkDataItemResult[];
+    bulkActionMetadata?: WixBulkActionMetadata;
+}
+export interface WixBulkWriteOptions {
+    /** Return each written item in `results[].dataItem`. Off by default to keep the response small. */
+    returnEntity?: boolean;
+}
+export interface WixBulkConditionalWriteOptions extends WixBulkWriteOptions {
+    /** Apply the write only to items that also match this filter (an optimistic-concurrency guard). */
+    condition?: {
+        filter: Record<string, unknown>;
+    };
+}
+/** The items of a bulk response that failed — an empty array means every item was written.
+ *  An item counts as failed when its result says `success: false`, or carries a non-null `error`
+ *  without `success: true`, so a response that leaves `success` off a failed item is still caught.
+ *  Wix sends `originalIndex` on every result, `0` included (checked against a live site).
+ *
+ *  ```ts
+ *  const res = await bulkInsertDataItems("Menu", rows);
+ *  for (const f of bulkFailures(res)) console.warn(rows[f.itemMetadata!.originalIndex!], f.itemMetadata!.error);
+ *  ``` */
+export declare function bulkFailures<T extends {
+    itemMetadata?: WixBulkItemMetadata;
+    referenceMetadata?: WixBulkItemMetadata;
+}>(res: {
+    results?: T[];
+} | undefined): T[];
+/** Insert up to 1000 items in one call — POST /wix-data/v2/bulk/items/insert.
+ *
+ *  Create-only: an item whose `id` already exists is rejected (Wix reports it per item, not as a
+ *  failed call). CHECK THE RESULT — the HTTP status is 200 even when items failed; use `bulkFailures(res)` or
+ *  `res.bulkActionMetadata.totalFailures`. A retry of the whole call after a lost response re-sends
+ *  rows that landed, so give rows an `id` (it goes beside `data`, not inside it) if a duplicate
+ *  would matter. Multi-reference values in `data` are silently dropped by Wix; write those with
+ *  `insertDataItemReferences`. The payload is capped at about 4 MB.
+ *
+ *  @scope visitor — enough when the collection's insert role is ANYONE; a stricter role fails every item with `WDE0027` inside a 200 (checked against a live site).
+ */
+export declare function bulkInsertDataItems(dataCollectionId: string, dataItems: {
+    id?: string;
+    data: Record<string, unknown>;
+}[], options?: WixBulkWriteOptions): Promise<WixBulkDataItemsResponse>;
+/** Insert-or-replace up to 1000 items in one call — POST /wix-data/v2/bulk/items/save.
+ *
+ *  The idempotent bulk write for items that carry an `id`: rerunning the same call converges on the
+ *  same rows, so it is the right one for imports and syncs. An item without an id is inserted again
+ *  on every run. Each item with an existing `id` is REPLACED whole. As with
+ *  every bulk call the HTTP status is 200 whatever happened — read `bulkFailures(res)`.
+ *
+ *  @scope visitor — enough when the collection's insert and update roles are ANYONE; a stricter role fails the items with `WDE0027` inside a 200.
+ */
+export declare function bulkSaveDataItems(dataCollectionId: string, dataItems: {
+    id?: string;
+    data: Record<string, unknown>;
+}[], options?: WixBulkWriteOptions): Promise<WixBulkDataItemsResponse>;
+/** Replace up to 1000 existing items — POST /wix-data/v2/bulk/items/update.
+ *
+ *  Every item needs its `id` on the envelope. `data._id` may stay when it equals that id (so an item
+ *  read back from a query can be sent as is) but must not differ — Wix answers a mismatch with
+ *  `400 WDE0080` (both checked against a live site). An id that does not exist fails that item. Like
+ *  `updateDataItem` this REPLACES each item whole, so fields you leave out are deleted — prefer
+ *  `bulkPatchDataItems` for partial changes. The status is 200 whatever happened; read
+ *  `bulkFailures(res)`.
+ *
+ *  @scope visitor — enough when the collection's update role is ANYONE; a stricter role fails every item with `WDE0027` inside a 200 (checked against a live site).
+ */
+export declare function bulkUpdateDataItems(dataCollectionId: string, dataItems: {
+    id: string;
+    data: Record<string, unknown>;
+}[], options?: WixBulkConditionalWriteOptions): Promise<WixBulkDataItemsResponse>;
+/** Patch up to 100 items in one call — POST /wix-data/v2/bulk/items/patch.
+ *
+ *  Each patch names an item and 1 to 100 modifications (`setField`, `incrementField`, …); fields
+ *  not named are untouched, and increments are atomic. The body key is `patches`, not `dataItems`
+ *  — sending the latter fails with `WDE0080`. Not for Wix app collections. The status is 200
+ *  whatever happened; read `bulkFailures(res)`.
+ *
+ *  @scope visitor — enough when the collection's update role is ANYONE; a stricter role fails every item with `WDE0027` inside a 200 (checked against a live site).
+ */
+export declare function bulkPatchDataItems(dataCollectionId: string, patches: {
+    dataItemId: string;
+    fieldModifications: WixFieldModification[];
+}[], options?: WixBulkConditionalWriteOptions): Promise<WixBulkDataItemsResponse>;
+/** Remove up to 1000 items by id in one call — POST /wix-data/v2/bulk/items/remove.
+ *
+ *  Irreversible, and it clears references to the removed items. Results are per item, and the
+ *  status is 200 even when some items fail (an id that does not exist is `WDE0073` per item);
+ *  read `bulkFailures(res)`. A remove the caller may not make at all is a 403 instead.
+ *
+ *  @scope visitor — enough when the collection's remove role is ANYONE; a stricter role answers `403 WDE0027` for the whole request (checked against a live site).
+ */
+export declare function bulkRemoveDataItems(dataCollectionId: string, dataItemIds: string[], options?: {
+    condition?: {
+        filter: Record<string, unknown>;
+    };
+}): Promise<WixBulkDataItemsResponse>;
+/** Paging block of the reads below, as Wix returns it. */
+export interface WixPagingMetadata {
+    count?: number;
+    offset?: number;
+    /** Filled for offset paging when `returnTotalCount` was set and the server could count. */
+    total?: number;
+    tooManyToCount?: boolean;
+    cursors?: {
+        next?: string;
+        prev?: string;
+    };
+    hasNext?: boolean;
+}
+/** One aggregation stage: an object with exactly one key — `group`, `filter`, `sort`, `projection`,
+ *  `unwindArray`, `objectToArray`, `skip` or `limit`. Wix's pipeline reference documents each. */
+export type WixPipelineStage = Record<string, unknown>;
+export interface WixAggregationPipeline {
+    /** Up to 100 stages, run in order, each on the previous stage's output. */
+    stages: WixPipelineStage[];
+    /** Page the pipeline's results. Offset and cursor paging are mutually exclusive. */
+    paging?: WixDataPaging;
+    cursorPaging?: WixDataCursorPaging;
+}
+export interface WixAggregateOptions extends WixReadOptions {
+    returnTotalCount?: boolean;
+}
+/** Run an aggregation pipeline — POST /wix-data/v2/items/aggregate-pipeline.
+ *
+ *  Counts, sums, averages and group-bys computed by Wix instead of by downloading every row and
+ *  folding it on the device — one read, however large the collection.
+ *
+ *  ```ts
+ *  const { results } = await aggregateDataItemsPipeline("Products", {
+ *    stages: [{ group: {
+ *      groupIds: [{ key: "category", expression: { fieldPath: "category" } }],
+ *      accumulators: [{ resultFieldName: "count", sum: { expression: { numeric: 1 } } }],
+ *    } }],
+ *  });
+ *  ```
+ *
+ *  Each result is a group: its group keys sit under `_id`, accumulators under their
+ *  `resultFieldName`. Not supported on Wix app collections. Up to 10000 results per response.
+ *
+ *  A follow-up page (`pipeline.cursorPaging.cursor` set) sends only the cursor: it already carries
+ *  the stages, and Wix refuses stages or `returnTotalCount` beside it (`400 WDE0080`, checked
+ *  against a live site). So pass the same pipeline for every page, with the next cursor.
+ *
+ *  @scope visitor — enough when the collection's read role is ANYONE; a stricter role answers `403 WDE0027` (checked against a live site).
+ */
+export declare function aggregateDataItemsPipeline(dataCollectionId: string, pipeline: WixAggregationPipeline | {
+    cursorPaging: WixDataCursorPaging & {
+        cursor: string;
+    };
+    stages?: undefined;
+    paging?: undefined;
+}, options?: WixAggregateOptions): Promise<{
+    results?: Record<string, unknown>[];
+    pagingMetadata?: WixPagingMetadata;
+}>;
+export interface WixDistinctOptions extends WixReadOptions {
+    filter?: Record<string, unknown>;
+    order?: "ASC" | "DESC";
+    paging?: WixDataPaging;
+    cursorPaging?: WixDataCursorPaging;
+    returnTotalCount?: boolean;
+}
+/** The unique values of one field, across the items matching `filter` — POST
+ *  /wix-data/v2/items/query-distinct-values.
+ *
+ *  What a filter chip or a category picker needs: the list of cities in use, without fetching every
+ *  row to build it. Returns `{ distinctValues, pagingMetadata }`. Wix's reference types each entry
+ *  as a value union (string, number, boolean, list, struct or null); inspect one live response
+ *  before depending on the exact serialisation of non-string fields.
+ *
+ *  @scope visitor — enough when the collection's read role is ANYONE; a stricter role answers `403 WDE0027` (checked against a live site).
+ */
+export declare function queryDistinctValues(dataCollectionId: string, fieldName: string, options?: WixDistinctOptions): Promise<{
+    distinctValues?: unknown[];
+    pagingMetadata?: WixPagingMetadata;
+}>;
+export interface WixSearchOptions {
+    /** `OR` (default): any term matches. `AND`: every term must. */
+    mode?: "OR" | "AND";
+    /** Tolerate typos and partial matches. */
+    fuzzy?: boolean;
+    filter?: Record<string, unknown>;
+    sort?: WixDataSort[];
+    /** Fields to return (`_id` always comes back). */
+    fields?: string[];
+    /** Offset paging only: Wix answers cursor paging on search with `400 WDE0080` ("Cursor paging is
+     *  not supported for search"), checked against a live site. */
+    paging?: WixDataPaging;
+    includeReferences?: WixIncludeReference[];
+    includeDraftItems?: boolean;
+}
+/** Full-text search a collection — POST /wix-data/v2/items/search.
+ *
+ *  `expression` is up to 100 characters; terms are split on whitespace and combined by `mode`.
+ *  Only collections created in the CMS or through the Data Collections API can be searched — not
+ *  Wix app collections, external collections or Blocks. Filtering is limited to fields defined in
+ *  the collection's structure, each field type accepts only some operators, and search results are
+ *  ALWAYS eventually consistent (there is no `consistentRead`), so a row written a moment ago may
+ *  not be found yet. Returns the same shape as `queryDataItems`.
+ *
+ *  @scope visitor — enough when the collection's read role is ANYONE; a stricter role answers `403 WDE0027` (checked against a live site).
+ */
+export declare function searchDataItems(dataCollectionId: string, expression: string, options?: WixSearchOptions): Promise<WixQueryDataItemsResponse>;
+export interface WixDataItemReference {
+    referringItemId: string;
+    referringItemFieldName: string;
+    referencedItemId: string;
+}
+export interface WixBulkReferenceResult {
+    action?: string;
+    referenceMetadata?: WixBulkItemMetadata;
+    dataItemReference?: WixDataItemReference;
+}
+export interface WixBulkReferencesResponse {
+    results?: WixBulkReferenceResult[];
+    bulkActionMetadata?: WixBulkActionMetadata;
+}
+/** What `queryReferencedDataItems` returns for one link: the item, or why it could not be read. */
+export interface WixReferencedResult {
+    referringItemId?: string;
+    dataItem?: WixDataItem;
+    /** The link points at an id that is missing, still a draft, or not readable by this identity
+     *  (`unauthorized: true`). */
+    unresolvedReference?: {
+        referencedItemId?: string;
+        unauthorized?: boolean;
+    };
+}
+export interface WixQueryReferencedOptions extends WixReadOptions {
+    order?: "ASC" | "DESC";
+    paging?: WixDataPaging;
+    cursorPaging?: WixDataCursorPaging;
+    fields?: string[];
+    returnTotalCount?: boolean;
+}
+/** Read the items one item links to, page by page — POST /wix-data/v2/items/query-referenced.
+ *
+ *  Use this when a multi-reference field can hold more items than `includeReferences` should
+ *  inline (that caps at 1000 per item, 50 by default). Results come in the order the links were
+ *  made (`order: "DESC"` for newest first). A link that cannot be resolved comes back as
+ *  `unresolvedReference` instead of being dropped.
+ *
+ *  @scope visitor — enough when the collection's read role is ANYONE; a stricter role answers `403 WDE0027` (checked against a live site).
+ */
+export declare function queryReferencedDataItems(dataCollectionId: string, referringItemId: string, referringItemFieldName: string, options?: WixQueryReferencedOptions): Promise<{
+    results?: WixReferencedResult[];
+    pagingMetadata?: WixPagingMetadata;
+}>;
+/** Does `referringItemId`'s field link to `referencedItemId`? — POST /wix-data/v2/items/is-referenced.
+ *  Returns `{ isReferenced }`.
+ *
+ *  @scope visitor — enough when the collection's read role is ANYONE; a stricter role answers `403 WDE0027` (checked against a live site).
+ */
+export declare function isReferencedDataItem(dataCollectionId: string, referringItemId: string, referringItemFieldName: string, referencedItemId: string, options?: {
+    consistentRead?: boolean;
+}): Promise<{
+    isReferenced?: boolean;
+}>;
+/** Add links to a reference or multi-reference field, keeping the links already there — POST
+ *  /wix-data/v2/bulk/items/insert-references. Up to 1000 per call.
+ *
+ *  The safe way to write a multi-reference field: Wix silently drops multi-reference values written
+ *  through insert, save, update or any bulk item write, and answers 200. After writing, read the item
+ *  back with `queryDataItems(..., { includeReferences })` to confirm. This call's own status is 200
+ *  whatever happened; read `bulkFailures(res)`.
+ *
+ *  @scope visitor — enough when the referring collection's update role is ANYONE; a stricter role is refused with `WDE0027` (checked against a live site).
+ */
+export declare function insertDataItemReferences(dataCollectionId: string, references: WixDataItemReference[], options?: WixBulkWriteOptions): Promise<WixBulkReferencesResponse>;
+/** Remove specific links without touching the others — POST /wix-data/v2/bulk/items/remove-references.
+ *  Up to 1000 per call; the status is 200 whatever happened, so read `bulkFailures(res)`.
+ *
+ *  @scope visitor — enough when the referring collection's update role is ANYONE; a stricter role is refused with `WDE0027` (checked against a live site).
+ */
+export declare function removeDataItemReferences(dataCollectionId: string, references: WixDataItemReference[]): Promise<WixBulkReferencesResponse>;
+/** Make a field's links exactly `newReferencedItemIds`, dropping any others — POST
+ *  /wix-data/v2/items/replace-references. An empty array removes every link. Up to 1000 ids.
+ *  Returns the resulting `{ dataItemReferences }`.
+ *
+ *  @scope visitor — enough when the referring collection's update role is ANYONE; a stricter role is refused with `WDE0027` (checked against a live site).
+ */
+export declare function replaceDataItemReferences(dataCollectionId: string, referringItemId: string, referringItemFieldName: string, newReferencedItemIds: string[]): Promise<{
+    dataItemReferences?: WixDataItemReference[];
+}>;
 export { wixCall };

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/wix-bookings.mjs

@@ -19,6 +19,10 @@ async function queryServices(req = {}) {
   const res = await wixCall("POST", "/bookings/v2/services/query", req);
   return { ...res, services: (res.services ?? []).map(decodeService) };
 }
+async function queryServiceCategories() {
+  const res = await wixCall("POST", "/bookings/v2/services/categories/query", {});
+  return { ...res, categories: Array.isArray(res?.categories) ? res.categories : [] };
+}
 async function getService(serviceId, options) {
   const path = `/bookings/v2/services/${serviceId}`;
   const conditionalFields = options?.conditionalFields ?? [];
@@ -323,6 +327,7 @@ export {
   queryBookings,
   queryResources,
   queryServiceAvailability,
+  queryServiceCategories,
   queryServices,
   queryStaff,
   registerToWaitlist,

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/wix-data-collections.mjs

@@ -5,11 +5,7 @@ function createDataCollection(collection) {
 }
 function updateDataCollection(collection) {
   if (!collection?.id) throw new Error("updateDataCollection: collection.id is required");
-  return wixCall(
-    "PUT",
-    `/data/v2/collections/${encodeURIComponent(collection.id)}`,
-    { collection }
-  );
+  return wixCall("PUT", "/data/v2/collections", { collection });
 }
 
 // ../../stdlib/wix-sdk/data-collections-v1/src/index.ts