@gomusdev/web-components 1.22.3 → 1.23.0

package/dist-js/gomus-webcomponents.js

@@ -5585,6 +5585,11 @@ const isNumber = (value) => {
     return false;
   }
 };
+const boil = (array2, compareFunc) => {
+  if (!array2 || (array2.length ?? 0) === 0)
+    return null;
+  return array2.reduce(compareFunc);
+};
 function sum(array2, fn) {
   return (array2 || []).reduce((acc, item) => acc + (fn ? fn(item) : item), 0);
 }
@@ -5602,6 +5607,10 @@ const alphabetical = (array2, getter, dir = "asc") => {
   const dsc = (a2, b) => `${getter(b)}`.localeCompare(getter(a2));
   return array2.slice().sort(dir === "desc" ? dsc : asc);
 };
+function max$1(array2, getter) {
+  const get2 = getter ?? ((v) => v);
+  return boil(array2, (a2, b) => get2(a2) > get2(b) ? a2 : b);
+}
 const iterate = (count, func, initValue) => {
   let value = initValue;
   for (let i = 1; i <= count; i++) {
@@ -11985,7 +11994,7 @@ class Shop {
     const isCacheExpired = this.#fetchStatus[fetchId]?.fetchedAt < Date.now() - options.cache * 1e3;
     if (isNotFetchedYet || isCacheExpired) {
       this.apiGet(endpoint, query, options.path).then((ret) => {
-        get$2(this.#data)[dataKey] = responseKey === "" ? ret : ret[responseKey];
+        if (ret) get$2(this.#data)[dataKey] = responseKey === "" ? ret : ret[responseKey];
       });
     }
     return get$2(this.#data)[dataKey];
@@ -12004,6 +12013,12 @@ class Shop {
   getEvent(id) {
     return this.fetchAndCache(`/api/v4/events/${id}`, `single_event_${id}`, "event");
   }
+  getTicketCapacities(date2, ticketIds) {
+    return this.apiPost(`/api/v4/tickets/capacities`, {
+      body: { date: date2, ticket_ids: ticketIds },
+      requiredFields: ["date", "ticket_ids"]
+    });
+  }
   getEventDetailsOnDate(eventId, dateId) {
     return this.fetchAndCache(`/api/v4/events/${eventId}/dates/${dateId}`, `/api/v4/events/${eventId}/dates/${dateId}`, "date");
   }
@@ -15345,16 +15360,7 @@ function createUIEventTicket(apiTicket, dateId, options) {
     ...product,
     ...apiTicket,
     ...finalOptions,
-    type: "scale",
-    get max_capacity() {
-      return 18;
-    },
-    get min_quantity() {
-      return 0;
-    },
-    get max_quantity() {
-      return 18;
-    }
+    type: "scale"
   };
   return uiTicket;
 }
@@ -15434,7 +15440,7 @@ function isUITicket(x) {
   return x.product_type === "Ticket";
 }
 function createUITicket(apiTicket, options) {
-  const finalOptions = { minAvailableCapacity: 0, selectedTime: "", ...options ?? {} };
+  const finalOptions = { selectedTime: "", ...{} };
   const product = { product_type: "Ticket", ...apiTicket };
   const _ = { ...apiTicket, ...finalOptions };
   const uiTicket = {
@@ -15460,7 +15466,7 @@ function generateCartItem(cartItem) {
   switch (type) {
     case "Ticket":
       if (cartItem.product.ticket_type === "timeslot" && !inTheFuture(cartItem.attributes.time)) return;
-      const ticket = createUITicket(cartItem.product, { minAvailableCapacity: 0 });
+      const ticket = createUITicket(cartItem.product);
       return createCartItem(ticket, { time: cartItem.time, quantity: cartItem.quantity });
     case "Event":
       const event = createUIEventTicket(cartItem.product, cartItem.id);
@@ -30440,7 +30446,13 @@ function evaluateExpression(expression, data) {
     console.log(`Error while evaluating when (${expression}) in go-if: ${error.message}`);
   }
 }
-const validTicketSelectionFilters = ["timeslot", "day", "annual", "scaled-price"];
+const validTicketSelectionFilters = [
+  "timeslot",
+  "day",
+  "annual",
+  "event:scaled-price",
+  "event:ticket"
+];
 let lastUId = 0;
 class TicketSelectionDetails {
   uid = lastUId++;
@@ -30535,8 +30547,10 @@ class TicketSelectionDetails {
           return Boolean(this.selectedDate);
         case "annual":
           return true;
-        case "scaled-price":
-          return true;
+        case "event:scaled-price":
+          return Boolean(this.selectedDate);
+        case "event:ticket":
+          return Boolean(this.selectedDate);
         case "timeslot":
           switch (this.mode) {
             case "event":
@@ -31356,6 +31370,187 @@ function TicketsSum($$anchor, $$props) {
   pop();
 }
 customElements.define("go-tickets-sum", create_custom_element(TicketsSum, {}, [], [], false));
+function loadAnnualTickets(segment) {
+  const tsd = segment.ticketSelectionDetails;
+  if (!tsd) return [];
+  if (!tsd.filters?.includes("annual")) return [];
+  const tickets = snapshot(shop.tickets({
+    by_bookable: true,
+    // @ts-ignore
+    "by_ticket_types[]": ["annual"],
+    "by_ticket_ids[]": tsd.ticketIds,
+    "by_ticket_group_ids[]": tsd.ticketGroupIds
+  }));
+  if (!tickets) return [];
+  segment.tickets = initUITimeslotTickets(tickets);
+}
+function loadDayTickets(segment) {
+  const tsd = segment.ticketSelectionDetails;
+  if (!tsd) return [];
+  if (!tsd.filters?.includes("day")) return [];
+  const tickets = snapshot(shop.tickets({
+    by_bookable: true,
+    // @ts-ignore
+    "by_ticket_types[]": ["normal"],
+    "by_ticket_ids[]": tsd.ticketIds,
+    "by_ticket_group_ids[]": tsd.ticketGroupIds
+  }));
+  if (!tickets) return [];
+  segment.tickets = initUITimeslotTickets(tickets);
+}
+function loadEventScaledPricesTickets(segment) {
+  const tsd = segment.ticketSelectionDetails;
+  if (!tsd) {
+    console.warn("(loadEventScaledPricesTickets) tsd is undefined");
+    segment.tickets = [];
+    return;
+  }
+  if (!tsd.eventIds?.length) {
+    console.warn("(loadEventScaledPricesTickets) eventIds is undefined");
+    segment.tickets = [];
+    return;
+  }
+  if (!segment.filters?.includes("event:scaled-price")) {
+    console.warn("(loadEventScaledPricesTickets) filters should include event:scaled-price");
+    segment.tickets = [];
+    return;
+  }
+  if (!segment.dateId) {
+    console.warn("(loadEventScaledPricesTickets) date-id is not given to the go-ticket-segment");
+    segment.tickets = [];
+    return;
+  }
+  if (tsd.eventIds.length > 1) throw new Error("(loadEventScaledPricesTickets) currently we support only one eventId in go-ticket-selection");
+  const eid = tsd.eventIds[0];
+  const event = snapshot(shop.getEventDetailsOnDate(eid, segment.dateId));
+  segment.tickets = event?.prices.map((t) => createUIEventTicket(t, segment.dateId)) || [];
+  const seats = {
+    max_per_registration: 2,
+    available: 100,
+    overbook: true,
+    ...event?.seats
+  };
+  const max_per_registration = seats.max_per_registration || seats.available;
+  segment.contingent = seats.overbook ? max_per_registration : Math.min(seats.available, max_per_registration);
+}
+function createCapacities(apiCapacities) {
+  let reservations = {};
+  const ret = {
+    apiData: apiCapacities,
+    reservations,
+    setReservation(ticketId, timeSlot, quantity) {
+      this.reservations[ticketId + ":" + timeSlot] = quantity;
+    },
+    getReservation(ticketId, timeSlot) {
+      return this.reservations[ticketId + ":" + timeSlot] ?? 0;
+    },
+    /**
+     * a flat list of all timeslots and their capacities, considering reservations.
+     */
+    timeslots() {
+      return Object.entries(this.apiData).flatMap(([quota, cap]) => {
+        return Object.keys(cap.capacities).map((timeSlot) => {
+          const sumReserved = sum(cap.tickets.map((ticket) => this.getReservation(ticket, timeSlot)));
+          return {
+            timeSlot,
+            quota,
+            capacity: cap.capacities[timeSlot] - sumReserved,
+            tickets: cap.tickets
+          };
+        });
+      });
+    },
+    tickets(ticketId) {
+      return this.timeslots().flatMap(
+        (x) => x.tickets.map((ticket) => ({
+          timeslot: x.timeSlot,
+          ticket,
+          quota: x.quota,
+          capacity: x.capacity
+        }))
+      );
+    },
+    ticketsByTimeSlot(timeslot) {
+      return this.timeslots().filter((x) => x.timeSlot === timeslot).flatMap(
+        (x) => x.tickets.map((ticket) => ({
+          timeslot,
+          ticket,
+          quota: x.quota,
+          capacity: x.capacity
+        }))
+      );
+    },
+    ticketCapacityByTicketAndTimeslot(ticketId, timeslot) {
+      const maxCap = max$1(
+        this.ticketsByTimeSlot(timeslot).filter((x) => x.ticket === ticketId),
+        (x) => x.capacity
+      )?.capacity ?? 0;
+      return maxCap;
+    },
+    /**
+     * returns the max capacity of a ticket in all timeslots
+     */
+    ticketCapacityByTicketId(ticketId) {
+      const maxCap = max$1(
+        this.tickets(ticketId).filter((x) => x.ticket === ticketId),
+        (x) => x.capacity
+      )?.capacity ?? 0;
+      return maxCap;
+    }
+  };
+  return ret;
+}
+async function loadEventTickets(segment) {
+  const tsd = segment.ticketSelectionDetails;
+  if (!tsd) {
+    console.warn("(loadEventTickets) tsd is undefined");
+    segment.tickets = [];
+    return;
+  }
+  if (!tsd.eventIds?.length) {
+    console.warn("(loadEventTickets) eventIds is undefined");
+    segment.tickets = [];
+    return;
+  }
+  if (!segment.filters?.includes("event:ticket")) {
+    console.warn("(loadEventTickets) filters should include event:tickets");
+    segment.tickets = [];
+    return;
+  }
+  if (!tsd.selectedDate) {
+    console.warn("(loadEventTickets) selected-date is not given to the go-ticket-selection");
+    segment.tickets = [];
+    return;
+  }
+  if (tsd.eventIds.length > 1) throw new Error("(loadEventTickets) currently we support only one eventId in go-ticket-selection");
+  const eid = tsd.eventIds[0];
+  const event = shop.getEvent(eid);
+  if (!event?.tickets) return;
+  const ticketIds = event.tickets;
+  const tickets = shop.tickets({ by_ticket_ids: ticketIds });
+  const capacitiesRes = await shop.getTicketCapacities(tsd.selectedDate.toString(), ticketIds);
+  if (!tickets || !capacitiesRes) return;
+  const capacities = createCapacities(capacitiesRes.data.data);
+  segment.tickets = tickets.filter((t) => capacities.ticketCapacityByTicketId(t.id) > 0).map((t) => createUITicket(t));
+  segment.preCart = createCart(segment.tickets);
+}
+function loadTimeslotTickets(segment) {
+  const tsd = segment.ticketSelectionDetails;
+  if (!tsd) return [];
+  if (!tsd.selectedDate && !tsd.selectedTimeslot && tsd.filters?.includes("timeslot")) return [];
+  const result = snapshot(shop.ticketsAndQuotas({
+    by_bookable: true,
+    valid_at: tsd.selectedDate?.toString(),
+    // @ts-ignore
+    "by_ticket_types[]": ["time_slot"],
+    "by_museum_ids[]": tsd.museumIds,
+    "by_exhibition_ids[]": tsd.exhibitionIds,
+    "by_ticket_ids[]": tsd.ticketIds,
+    "by_ticket_group_ids[]": tsd.ticketGroupIds
+  }));
+  if (!result) return [];
+  segment.tickets = initUITimeslotTickets(result.tickets);
+}
 class TicketSegmentDetails {
   #ticketSelectionDetails;
   get ticketSelectionDetails() {
@@ -31410,7 +31605,10 @@ class TicketSegmentDetails {
         });
       });
       user_effect(() => {
-        this.preCart = createCart(this.preCartTickets(), this.contingent);
+        this.loadTickets();
+        untrack(() => {
+          this.preCart = createCart(this.tickets, this.contingent);
+        });
       });
     });
   }
@@ -31421,105 +31619,17 @@ class TicketSegmentDetails {
       preCart: this.preCart
     });
   }
-  preCartTickets() {
-    switch (this.filters) {
-      case "timeslot":
-        return this.timeslotTickets;
-      case "annual":
-        return this.annualTickets;
-      case "day":
-        return this.dayTickets;
-      case "custom":
-        return this.tickets;
-      case "scaled-price":
-        return this.scaledPricesTickets;
-      default:
-        const exhaustiveCheck = this.filters;
-        if (exhaustiveCheck) throw new Error(`(TicketGroup) Unhandled case: ${exhaustiveCheck}`);
-    }
-    return [];
-  }
-  get timeslotTickets() {
-    const tsd = this.ticketSelectionDetails;
-    if (!tsd) return [];
-    if (!tsd.selectedDate && !tsd.selectedTimeslot && tsd.filters?.includes("timeslot")) return [];
-    const result = snapshot(shop.ticketsAndQuotas({
-      by_bookable: true,
-      valid_at: tsd.selectedDate?.toString(),
-      // @ts-ignore
-      "by_ticket_types[]": ["time_slot"],
-      "by_museum_ids[]": tsd.museumIds,
-      "by_exhibition_ids[]": tsd.exhibitionIds,
-      "by_ticket_ids[]": tsd.ticketIds,
-      "by_ticket_group_ids[]": tsd.ticketGroupIds
-    }));
-    if (!result) return [];
-    return initUITimeslotTickets(result.tickets);
-  }
-  get annualTickets() {
-    const tsd = this.ticketSelectionDetails;
-    if (!tsd) return [];
-    if (!tsd.filters?.includes("annual")) return [];
-    const tickets = snapshot(shop.tickets({
-      by_bookable: true,
-      // @ts-ignore
-      "by_ticket_types[]": ["annual"],
-      "by_ticket_ids[]": tsd.ticketIds,
-      "by_ticket_group_ids[]": tsd.ticketGroupIds
-    }));
-    if (!tickets) return [];
-    return initUITimeslotTickets(tickets);
-  }
-  get dayTickets() {
-    const tsd = this.ticketSelectionDetails;
-    if (!tsd) return [];
-    if (!tsd.filters?.includes("day")) return [];
-    const tickets = snapshot(shop.tickets({
-      by_bookable: true,
-      // @ts-ignore
-      "by_ticket_types[]": ["normal"],
-      "by_ticket_ids[]": tsd.ticketIds,
-      "by_ticket_group_ids[]": tsd.ticketGroupIds
-    }));
-    if (!tickets) return [];
-    return initUITimeslotTickets(tickets);
-  }
-  get scaledPricesTickets() {
-    const tsd = this.ticketSelectionDetails;
-    if (!this.ensureScaledPrices()) return [];
-    const eid = tsd.eventIds[0];
-    const event = snapshot(shop.getEventDetailsOnDate(eid, this.dateId));
-    const ret = event?.prices.map((t) => createUIEventTicket(t, this.dateId)) || [];
-    const seats = {
-      max_per_registration: 2,
-      available: 100,
-      overbook: true,
-      ...event?.seats
-    };
-    const max_per_registration = seats.max_per_registration || seats.available;
-    this.contingent = seats.overbook ? max_per_registration : Math.min(seats.available, max_per_registration);
-    return ret;
-  }
-  ensureScaledPrices() {
-    const tsd = this.ticketSelectionDetails;
-    if (!tsd) {
-      console.warn("(scaledPricesTickets) tsd is undefined");
-      return false;
-    }
-    if (!tsd.eventIds?.length) {
-      console.warn("(scaledPricesTickets) eventIds is undefined");
-      return false;
-    }
-    if (!this.filters?.includes("scaled-price")) {
-      console.warn("(scaledPricesTickets) filters should include scaled-price");
-      return false;
-    }
-    if (!this.dateId) {
-      console.warn("(scaledPricesTickets) date-id is not given to the go-ticket-segment");
-      return false;
-    }
-    if (tsd.eventIds.length > 1) throw new Error("(scaledPricesTickets) currently we support only one eventId in go-ticket-selection");
-    return true;
+  loadTickets() {
+    const method = {
+      timeslot: loadTimeslotTickets,
+      annual: loadAnnualTickets,
+      day: loadDayTickets,
+      custom: () => {
+      },
+      "event:scaled-price": loadEventScaledPricesTickets,
+      "event:ticket": loadEventTickets
+    }[this.filters];
+    method(this);
   }
 }
 const KEY = "go-ticket-segment";
@@ -31529,7 +31639,6 @@ function TicketSegment($$anchor, $$props) {
   push($$props, true);
   const filters = prop($$props, "filters", 7), dateId = prop($$props, "dateId", 7);
   if (!filters()) throw new Error("filters is required");
-  console.log("TicketSegment: ", filters(), "dateId: ", dateId());
   const tsdWrapper = getTicketSelectionDetails($$props.$$host);
   const details = new TicketSegmentDetails(filters(), tsdWrapper);
   setTicketSegmentDetails($$props.$$host, details);
@@ -31538,7 +31647,6 @@ function TicketSegment($$anchor, $$props) {
   user_effect(() => {
     details.filters = filters();
     details.dateId = dateId();
-    console.log("SET DATEID,", dateId());
   });
   var $$exports = {
     details,
@@ -31957,7 +32065,8 @@ class Calendar {
       day: "normal",
       timeslot: "time_slot",
       annual: "annual",
-      "scaled-price": "scaled_price"
+      "event:scaled-price": "scaled_price",
+      "event:ticket": "not implemented"
     })[f]);
   }
   params() {

package/dist-js/lib/models/capacities/capacities.d.ts

@@ -0,0 +1,44 @@
+import { Capacities } from '@gomus/types';
+export type UICapacities = ReturnType<typeof createCapacities>;
+export declare function createCapacities(apiCapacities: Capacities): {
+    apiData: {
+        [key: string]: {
+            tickets: number[];
+            capacities: {
+                [key: string]: number;
+            };
+            total_capacities: {
+                [key: string]: number;
+            };
+        };
+    };
+    reservations: Record<string, number>;
+    setReservation(ticketId: number, timeSlot: string, quantity: number): void;
+    getReservation(ticketId: number, timeSlot: string): number;
+    /**
+     * a flat list of all timeslots and their capacities, considering reservations.
+     */
+    timeslots(): {
+        timeSlot: string;
+        quota: string;
+        capacity: number;
+        tickets: number[];
+    }[];
+    tickets(ticketId: number): {
+        timeslot: string;
+        ticket: number;
+        quota: string;
+        capacity: number;
+    }[];
+    ticketsByTimeSlot(timeslot: string): {
+        timeslot: string;
+        ticket: number;
+        quota: string;
+        capacity: number;
+    }[];
+    ticketCapacityByTicketAndTimeslot(ticketId: number, timeslot: string): number;
+    /**
+     * returns the max capacity of a ticket in all timeslots
+     */
+    ticketCapacityByTicketId(ticketId: number): number;
+};

package/dist-js/lib/models/capacities/capacities.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-js/lib/models/scalePrice/UIScaledPrice.svelte.d.ts

@@ -10,9 +10,6 @@ export declare function isUIEventTicket(x: Product): x is UIEventTicket;
 export type UIEventTicket = ReturnType<typeof createUIEventTicket>;
 export declare function createUIEventTicket(apiTicket: EventScalePriceTicket, dateId: number, options?: Options): {
     type: UIEventTicketTypes;
-    max_capacity: number;
-    min_quantity: number;
-    max_quantity: number;
     minAvailableCapacity: number;
     selectedTime: string;
     quantity: number;
@@ -31,9 +28,6 @@ export declare function createUIEventTicket(apiTicket: EventScalePriceTicket, da
     uid: number;
 } | {
     type: UIEventTicketTypes;
-    max_capacity: number;
-    min_quantity: number;
-    max_quantity: number;
     product_type: ProductType;
     accounting_article_id: number;
     accounting_article_type: string;

package/dist-js/lib/models/ticket/UITicket.svelte.d.ts

@@ -1,17 +1,15 @@
 import { Product, ProductType } from '../cart/types.ts';
 import { AnnualTicket, Ticket, Tickets } from '@gomus/types';
 interface Options {
-    minAvailableCapacity?: number;
     selectedTime?: string;
 }
-export type UITicketType = 'timeslot' | 'annual' | 'day';
+export type UITicketType = 'timeslot' | 'annual' | 'day' | 'event:ticket';
 export type UITicket = ReturnType<typeof createUITicket>;
 export declare function isUITicket(x: Product): x is UITicket;
 export declare function createUITicket(apiTicket: Ticket | AnnualTicket, options?: Options): {
     product_type: ProductType;
     type: UITicketType;
     shop_order: number;
-    minAvailableCapacity: number;
     selectedTime: string;
     id: number;
     title: string;
@@ -123,7 +121,6 @@ export declare function createUITicket(apiTicket: Ticket | AnnualTicket, options
     product_type: ProductType;
     type: UITicketType;
     shop_order: number;
-    minAvailableCapacity: number;
     selectedTime: string;
     id: number;
     title: string;

package/dist-js/lib/stores/shop.svelte.d.ts

@@ -3,7 +3,7 @@ import { ShopUrls } from '../helpers/urls';
 import { User } from './user.svelte.ts';
 import { OpenApiClient } from '@gomus/api';
 import { TicketsAndQuotasParams, TicketsCalendarParams, TicketsParams } from '@gomus/api/lib/types.ts';
-import { CheckoutParams, CheckoutResponse, Country, Event, Exhibition, FinalizePersonalizationParams, FinalizePersonalizationResponse, LocaleOptions, Merchandise, Museum, PasswordResetResponse, Salutation, ShopType, SignInParams, SignInResponse, SignUpParams, SignUpResponse, Tour } from '@gomus/types';
+import { CapacitiesResponse, CheckoutParams, CheckoutResponse, Country, Event, Exhibition, FinalizePersonalizationParams, FinalizePersonalizationResponse, LocaleOptions, Merchandise, Museum, PasswordResetResponse, Salutation, ShopType, SignInParams, SignInResponse, SignUpParams, SignUpResponse, Tour } from '@gomus/types';
 export type ShopKind = 'angular' | 'jmb';
 export declare class Shop {
     #private;
@@ -132,60 +132,50 @@ export declare class Shop {
         meta: import('@gomus/types').components["schemas"]["meta"];
     };
     tickets(params: TicketsParams): {
-        [key: string]: {
-            id: number;
-            title: string;
-            ticket_type: "time_slot" | "annual" | "normal";
-            bookable: boolean;
-            museum_ids: number[];
-            exhibition_ids: number[];
-            price_cents: number;
-            discount: number;
-            vat_pct: number;
-            tax_included: boolean;
-            entry_duration: number | null;
-            min_persons: number;
-            max_persons: number;
-            quota_ids: number[];
-            first_entry: number;
-            last_entry: number;
-            personalizeable: boolean;
-            attendees: boolean | string;
-            identification: boolean | string;
-            free_timing: boolean;
-            is_collective: boolean;
-            is_upgrade: boolean;
-            is_mantle: boolean;
-            description: string | null;
-            sub_ticket_ids: number[];
-            sub_tickets: {
-                [key: string]: {
-                    title?: string;
-                    min_persons?: number;
-                    max_persons?: number;
-                    description?: string | null;
-                };
-            } | null;
-            is_sub_ticket: boolean;
-            created_at: string;
-            updated_at: string;
-            shop_order: number;
-            shipped_with_merchandise_id: number | null;
-            restricted_shop_account: boolean;
-            cash_point_order: number;
-            capacities: {
-                [key: string]: number;
-            };
-            total_capacities: {
-                [key: string]: number;
+        id: number;
+        title: string;
+        ticket_type: "time_slot" | "annual" | "normal";
+        bookable: boolean;
+        museum_ids: number[];
+        exhibition_ids: number[];
+        price_cents: number;
+        discount: number;
+        vat_pct: number;
+        tax_included: boolean;
+        entry_duration: number | null;
+        quota_ids: number[];
+        first_entry: number;
+        last_entry: number;
+        personalizeable: boolean;
+        attendees: boolean | string;
+        identification: boolean | string;
+        free_timing: boolean;
+        is_collective: boolean;
+        is_upgrade: boolean;
+        is_mantle: boolean;
+        description: string | null;
+        sub_ticket_ids: number[];
+        sub_tickets: {
+            [key: string]: {
+                title?: string;
+                min_persons?: number;
+                max_persons?: number;
+                description?: string | null;
             };
-            max_capacity: number;
-            max_total_capacity: number;
-            dynamic_prices: {
-                [key: string]: number;
-            } | null;
-        };
-    };
+        } | null;
+        is_sub_ticket: boolean;
+        created_at: string;
+        updated_at: string;
+        cash_point_order: number;
+        shop_order: number;
+        shipped_with_merchandise_id: number | null;
+        restricted_shop_account: boolean;
+        min_persons: number;
+        max_persons: number;
+        dynamic_prices?: {
+            [key: string]: number;
+        } | null;
+    }[];
     signIn(params: SignInParams): Promise<SignInResponse>;
     signUp(params: SignUpParams, asGuest?: boolean): Promise<SignUpResponse>;
     passwordReset(params: {
@@ -337,6 +327,7 @@ export declare class Shop {
         documents: import('@gomus/types').components["schemas"]["document"][];
         content: Record<string, never>;
     };
+    getTicketCapacities(date: string, ticketIds: number[]): Promise<CapacitiesResponse>;
     getEventDetailsOnDate(eventId: number, dateId: number): {
         id?: number;
         event_id?: number;

package/dist-js/mocks/MSWMocks.d.ts

@@ -11,7 +11,12 @@ export declare const MSWMocks: {
     mockAnnualOrder: () => void;
     mockCountries: () => void;
     mockPersonalizationFormSubmit: () => void;
+    tickets: {
+        mockTwoTickets: (options?: Record<string, any>) => void;
+        mockOneTicketCapacity: (options?: Record<string, any>) => void;
+    };
     events: {
         mockTwoScaledPrices: (options?: Record<string, any>) => void;
+        mockTwoTickets: (options?: Record<string, any>) => void;
     };
 };