import * as _wix_sdk_types from '@wix/sdk-types'; import { QuerySpec, Query, NonNullablePaths } from '@wix/sdk-types'; /** * A seating reservation represents a booking for one or more places within a seating plan. * * Seating reservations track specific seat assignments or area capacity allocations for events. Each reservation can include multiple places across different sections of a venue, with individual capacity requirements for each place. The system maintains referential integrity through both internal Wix identifiers and external system references, enabling seamless integration with third-party ticketing platforms. */ interface SeatingReservation { /** * Reservation ID. * @format GUID * @readonly */ _id?: string | null; /** * Seating plan ID. * @format GUID * @readonly */ seatingPlanId?: string | null; /** * External seating plan ID used for integration with third-party venue systems. * @minLength 1 * @maxLength 100 * @readonly */ externalSeatingPlanId?: string | null; /** * Places reserved in this reservation. Each place can have its own capacity requirements. * @minSize 1 * @maxSize 100 */ reservedPlaces?: PlaceReservation[]; /** * External reference ID for cross-system integration. Format: `{fqdn}:{entity guid}`. For example, `wix.events.v1.ticket:12345678-1234-1234-1234-123456789012`. * @minLength 1 * @maxLength 100 */ externalId?: string | null; /** * Revision number, which increments by 1 each time the reservation is updated. To prevent conflicting changes, the current revision must be passed when updating the reservation. Ignored when creating a reservation. * @readonly */ revision?: string | null; /** * Date and time the seating plan was created. * @readonly */ _createdDate?: Date | null; /** * Date and time the seating plan was updated. * @readonly */ _updatedDate?: Date | null; } /** Individual place reservation within a seating arrangement. */ interface PlaceReservation { /** * Place ID in the format `{section_id}-{element_id}-{label}`. For example, `0-1-5` for section 0, element 1, seat 5; or `1-1-A` for the single place of an AREA element. * @minLength 5 * @maxLength 12 */ _id?: string; /** * Number of people to be seated at this place. Used for area seating where multiple guests can occupy a single reservable location. * * Default: `1` * @min 1 * @max 50 */ capacity?: number | null; /** * Section name within the venue. For example, `Orchestra` or `Balcony`. * @readonly */ sectionLabel?: string | null; /** * Area name within a section. Used for general admission or standing areas. * @readonly */ areaLabel?: string | null; /** * Table identifier for table-based seating arrangements. * @readonly */ tableLabel?: string | null; /** * Row identifier within a section or area. * @readonly */ rowLabel?: string | null; /** * Individual seat identifier within a row or at a table. * @readonly */ seatLabel?: string | null; } /** Triggers when seating plan category summaries are updated. */ interface SeatingPlanCategoriesSummaryUpdated { /** * Seating plan ID. * @format GUID */ seatingPlanId?: string; /** External seating plan ID. */ externalSeatingPlanId?: string | null; /** * Updated category capacity and reservation counts. * @maxSize 100 */ categories?: CategoryDetails[]; /** * Summary revision number for cache invalidation. * @readonly */ revision?: string | null; } /** Category capacity and reservation summary. */ interface CategoryDetails { /** * Seating Plan ID. * @format GUID * @readonly */ seatingPlanId?: string | null; /** * External Seating Plan ID used for integration with third-party systems. * @minLength 1 * @maxLength 100 * @readonly */ externalSeatingPlanId?: string | null; /** * External Category ID used for mapping to venue-specific category names. For example, `VIP` or `ORCHESTRA`. * @minLength 1 * @maxLength 100 * @readonly */ externalCategoryId?: string | null; /** * Total seating capacity available in category. * @readonly */ totalCapacity?: number | null; /** * Number of seats currently reserved in category. * @readonly */ reserved?: number | null; } interface InvalidateCache extends InvalidateCacheGetByOneOf { /** * Invalidate by msId. NOT recommended, as this will invalidate the entire site cache! * @format GUID */ metaSiteId?: string; /** * Invalidate by Site ID. NOT recommended, as this will invalidate the entire site cache! * @format GUID */ siteId?: string; /** Invalidate by App */ app?: App; /** Invalidate by page id */ page?: Page; /** Invalidate by URI path */ uri?: URI; /** Invalidate by file (for media files such as PDFs) */ file?: File; /** Invalidate by custom tag. Tags used in BO invalidation are disabled for this endpoint (more info: https://wix-bo.com/dev/clear-ssr-cache) */ customTag?: CustomTag; /** Invalidate by multiple page ids */ pages?: Pages; /** Invalidate by multiple URI paths */ uris?: URIs; /** * tell us why you're invalidating the cache. You don't need to add your app name * @maxLength 256 */ reason?: string | null; /** Is local DS */ localDc?: boolean; hardPurge?: boolean; /** * Optional caller-provided ID for tracking this invalidation through the system. * When set, the corresponding CDN purge completion event will include this ID, * allowing you to confirm when the invalidation has fully propagated. * Example: generate a UUID, pass it here, and later match it in the CDN purge completion event. * @maxLength 256 */ correlationId?: string | null; } /** @oneof */ interface InvalidateCacheGetByOneOf { /** * Invalidate by msId. NOT recommended, as this will invalidate the entire site cache! * @format GUID */ metaSiteId?: string; /** * Invalidate by Site ID. NOT recommended, as this will invalidate the entire site cache! * @format GUID */ siteId?: string; /** Invalidate by App */ app?: App; /** Invalidate by page id */ page?: Page; /** Invalidate by URI path */ uri?: URI; /** Invalidate by file (for media files such as PDFs) */ file?: File; /** Invalidate by custom tag. Tags used in BO invalidation are disabled for this endpoint (more info: https://wix-bo.com/dev/clear-ssr-cache) */ customTag?: CustomTag; /** Invalidate by multiple page ids */ pages?: Pages; /** Invalidate by multiple URI paths */ uris?: URIs; } interface App { /** * The AppDefId * @minLength 1 */ appDefId?: string; /** * The instance Id * @format GUID */ instanceId?: string; } interface Page { /** * the msid the page is on * @format GUID */ metaSiteId?: string; /** * Invalidate by Page ID * @minLength 1 */ pageId?: string; } interface URI { /** * the msid the URI is on * @format GUID */ metaSiteId?: string; /** * URI path to invalidate (e.g. page/my/path) - without leading/trailing slashes * @minLength 1 */ uriPath?: string; } interface File { /** * the msid the file is related to * @format GUID */ metaSiteId?: string; /** * Invalidate by filename (for media files such as PDFs) * @minLength 1 * @maxLength 256 */ fileName?: string; } interface CustomTag { /** * the msid the tag is related to * @format GUID */ metaSiteId?: string; /** * Tag to invalidate by * @minLength 1 * @maxLength 256 */ tag?: string; } interface Pages { /** * the msid the pages are on * @format GUID */ metaSiteId?: string; /** * Invalidate by multiple Page IDs in a single message * @maxSize 100 * @minLength 1 */ pageIds?: string[]; } interface URIs { /** * the msid the URIs are on * @format GUID */ metaSiteId?: string; /** * URI paths to invalidate (e.g. page/my/path) - without leading/trailing slashes * @maxSize 100 * @minLength 1 */ uriPaths?: string[]; } /** Request to create a seating reservation. */ interface CreateSeatingReservationRequest { /** Reservation to create. */ reservation?: SeatingReservation; } /** Response after creating a seating reservation. */ interface CreateSeatingReservationResponse { /** Created reservation. */ reservation?: SeatingReservation; } /** Details about specific places, used for error reporting. */ interface Places { /** * List of place identifiers. For example, `0-1-5` for an individual seat or `1-1-A` for the single place of an AREA element. * @minSize 1 * @maxSize 100 */ places?: string[]; } /** Details about places that are unavailable, including capacity conflicts. */ interface UnavailablePlaces { /** * List of place identifiers that are unavailable. For example, `0-1-5` for an individual seat or `1-1-A` for the single place of an AREA element. * @minSize 1 * @maxSize 100 */ unavailablePlaces?: string[]; /** * Detailed capacity information for each unavailable place. * @minSize 1 * @maxSize 100 */ reservationErrorDetails?: ReservationErrorDetails[]; } /** Capacity conflict details for a given place. */ interface ReservationErrorDetails { /** ID of the place with a capacity conflict. */ _id?: string; /** Currently available capacity at this place. */ available?: number; /** Requested capacity that exceeds the available capacity. */ requested?: number; } /** Request to retrieve a specific seating reservation. */ interface GetReservationRequest { /** * Reservation ID. * @format GUID */ _id?: string | null; } /** Response containing the requested seating reservation. */ interface GetReservationResponse { /** Retrieved reservation. */ reservation?: SeatingReservation; } /** Request to retrieve a specific seating reservation. */ interface GetSeatingReservationRequest { /** * Reservation ID. * @format GUID */ reservationId: string; } /** Response containing the requested seating reservation. */ interface GetSeatingReservationResponse { /** Retrieved reservation. */ reservation?: SeatingReservation; } /** Request to query seating reservations. */ interface QuerySeatingReservationRequest { /** Query object with filter criteria and pagination settings. */ query?: QueryV2; } interface QueryV2 extends QueryV2PagingMethodOneOf { /** Paging options to limit and offset the number of items. */ paging?: Paging; /** Cursor token pointing to a page of results. Not used in the first request. Following requests use the cursor token and not `filter` or `sort`. */ cursorPaging?: CursorPaging; /** * Filter object. * * Learn more about [filtering](https://dev.wix.com/docs/rest/articles/getting-started/api-query-language#filters). */ filter?: Record | null; /** * Sort object. * * Learn more about [sorting](https://dev.wix.com/docs/rest/articles/getting-started/api-query-language#sorting). */ sort?: Sorting[]; /** Array of projected fields. A list of specific field names to return. If `fieldsets` are also specified, the union of `fieldsets` and `fields` is returned. */ fields?: string[]; /** Array of named, predefined sets of projected fields. A array of predefined named sets of fields to be returned. Specifying multiple `fieldsets` will return the union of fields from all sets. If `fields` are also specified, the union of `fieldsets` and `fields` is returned. */ fieldsets?: string[]; } /** @oneof */ interface QueryV2PagingMethodOneOf { /** Paging options to limit and offset the number of items. */ paging?: Paging; /** Cursor token pointing to a page of results. Not used in the first request. Following requests use the cursor token and not `filter` or `sort`. */ cursorPaging?: CursorPaging; } interface Sorting { /** * Name of the field to sort by. * @maxLength 512 */ fieldName?: string; /** Sort order. */ order?: SortOrderWithLiterals; /** * When `field_name` is a property of repeated field that is marked as `MATCH_ITEMS` and sort should be done by * a specific element from a collection, filter can/should be provided to ensure correct sort value is picked. * * If multiple filters are provided, they are combined with AND operator. * * Example: * Given we have document like {"id": "1", "nestedField": [{"price": 10, "region": "EU"}, {"price": 20, "region": "US"}]} * and `nestedField` is marked as `MATCH_ITEMS`, to ensure that sorting is done by correct region, filter should be * { fieldName: "nestedField.price", "select_items_by": [{"nestedField.region": "US"}] } * @internal * @maxSize 10 */ selectItemsBy?: Record[] | null; /** * Origin point for geo-distance sorting on a GEO field * results are ordered by distance from this point (ASC = nearest first, DESC = farthest first). */ origin?: AddressLocation; } declare enum SortOrder { ASC = "ASC", DESC = "DESC" } /** @enumType */ type SortOrderWithLiterals = SortOrder | 'ASC' | 'DESC'; interface AddressLocation { /** Address latitude. */ latitude?: number | null; /** Address longitude. */ longitude?: number | null; } interface Paging { /** Number of items to load. */ limit?: number | null; /** Number of items to skip in the current sort order. */ offset?: number | null; } interface CursorPaging { /** * Maximum number of items to return in the results. * @max 100 */ limit?: number | null; /** * Pointer to the next or previous page in the list of results. * * Pass the relevant cursor token from the `pagingMetadata` object in the previous call's response. * Not relevant for the first request. * @maxLength 16000 */ cursor?: string | null; } /** Response containing matching seating reservations. */ interface QuerySeatingReservationResponse { /** Found reservations matching the query criteria. */ reservations?: SeatingReservation[]; /** Paging metadata for result navigation. */ metadata?: PagingMetadataV2; } interface PagingMetadataV2 { /** Number of items returned in the response. */ count?: number | null; /** Offset that was requested. */ offset?: number | null; /** Total number of items that match the query. Returned if offset paging is used and the `tooManyToCount` flag is not set. */ total?: number | null; /** Flag that indicates the server failed to calculate the `total` field. */ tooManyToCount?: boolean | null; /** Cursors to navigate through the result pages using `next` and `prev`. Returned if cursor paging is used. */ cursors?: Cursors; /** * Indicates if there are more results after the current page. * If `true`, another page of results can be retrieved. * If `false`, this is the last page. * @internal */ hasNext?: boolean | null; } interface Cursors { /** * Cursor string pointing to the next page in the list of results. * @maxLength 16000 */ next?: string | null; /** * Cursor pointing to the previous page in the list of results. * @maxLength 16000 */ prev?: string | null; } /** Request to query seating reservations. */ interface QuerySeatingReservationsRequest { /** Query object with filter criteria and pagination settings. */ query?: QueryV2; } /** Response containing matching seating reservations. */ interface QuerySeatingReservationsResponse { /** Found reservations matching the query criteria. */ reservations?: SeatingReservation[]; /** Paging metadata for result navigation. */ metadata?: PagingMetadataV2; } /** Request to delete a seating reservation. */ interface DeleteSeatingReservationRequest { /** * Reservation ID. * @format GUID */ _id: string | null; } /** Response after deleting a seating reservation. */ interface DeleteSeatingReservationResponse { /** Deleted reservation. */ reservation?: SeatingReservation; } /** Request to delete a specific place reservation. */ interface DeleteSeatingPlaceReservationRequest { /** Place reservation ID. */ _id?: string | null; /** * Seating reservation ID that contains the place reservation. * @format GUID */ reservationId?: string | null; } interface Empty { } /** Request to cancel specific place reservations. */ interface CancelSeatingPlaceReservationsRequest { /** * Seating reservation ID containing the places to cancel. * @format GUID */ reservationId?: string | null; /** * Place reservations to cancel with their reduced capacity. * @minSize 1 * @maxSize 100 */ placeReservations?: PlaceReservationDetails[]; } /** Occupancy details for a specific place in a seating plan. */ interface PlaceReservationDetails { /** Place ID. */ placeId?: string; /** Number of occupied seats or capacity units at this place. */ occupied?: number; } /** Response after canceling place reservations. */ interface CancelSeatingPlaceReservationsResponse { /** Reservation with canceled place reservations. */ reservation?: SeatingReservation; } /** Request to update a seating reservation. */ interface UpdateSeatingReservationRequest { /** Reservation to update with modified capacity values. */ reservation?: SeatingReservation; } /** Response after updating a seating reservation. */ interface UpdateSeatingReservationResponse { /** Updated reservation. */ reservation?: SeatingReservation; } /** Request to retrieve all reserved places for a seating plan. */ interface GetReservedPlacesRequest { /** * Seating plan ID. * @format GUID */ _id?: string | null; } /** Response containing all reserved places for a seating plan. */ interface GetReservedPlacesResponse { /** Reserved places in the seating plan. */ placeReservations?: PlaceReservation[]; } /** Request to list reserved places with optional filtering. */ interface ListReservedPlacesRequest { /** * Seating plan ID. * @format GUID */ planId?: string | null; /** * Optional filter by reservation ID. * @format GUID */ reservationId?: string | null; /** * Optional filter by specific seat IDs. * @maxSize 50 * @maxLength 20 */ seatId?: string[]; /** Paging configuration. */ paging?: Paging; } /** Response containing filtered reserved places. */ interface ListReservedPlacesResponse { /** Reserved places matching the filter criteria. */ reservedPlaces?: ReservedPlace[]; /** Paging metadata for result navigation. */ pagingMetadata?: PagingMetadata; } /** Internal representation of a place reservation. */ interface SeatReservation { /** * Place reservation ID. * @maxLength 72 */ seatReservationId?: string | null; /** * Place ID. * @maxLength 20 */ seatId?: string | null; /** * Seating plan ID. * @format GUID */ planId?: string | null; /** * Seating reservation ID. * @format GUID */ reservationId?: string | null; /** * Number of occupied spots at this place. * @max 50000 */ spots?: number | null; /** Whether this is an area-based reservation (true) or individual seat (false). */ area?: boolean | null; } /** Individual reserved place with full context. */ interface ReservedPlace { /** Place reservation details. */ seatReservation?: SeatReservation; /** Parent reservation (active). */ reservation?: SeatingReservation; /** Parent reservation (deleted, for audit trail). */ reservationFromTrashBin?: SeatingReservation; } interface PagingMetadata { /** Number of items returned in the response. */ count?: number | null; /** Offset that was requested. */ offset?: number | null; /** Total number of items that match the query. */ total?: number | null; /** Flag that indicates the server failed to calculate the `total` field. */ tooManyToCount?: boolean | null; /** * Indicates if there are more results after the current page. * If `true`, another page of results can be retrieved. * If `false`, this is the last page. * @internal */ hasNext?: boolean | null; } /** Request to retrieve category-level capacity summary. */ interface GetSeatingCategorySummaryRequest { /** * External seating plan ID. * @minLength 1 * @maxLength 100 */ externalId?: string; } /** Response containing capacity summary by category. */ interface GetSeatingCategorySummaryResponse { /** * Capacity and reservation counts by category. * @maxSize 50000 */ categories?: CategoryDetails[]; } /** Request to retrieve category-level capacity summary by external ID. */ interface GetSeatingCategorySummaryByExternalIdRequest { /** * External seating plan ID. * @minLength 1 * @maxLength 100 */ externalId: string; } /** Response containing capacity summary by category. */ interface GetSeatingCategorySummaryByExternalIdResponse { /** * Capacity and reservation counts by category. * @maxSize 50000 */ categories?: CategoryDetails[]; } /** Request to retrieve detailed place-level occupancy data. */ interface GetSeatingReservationSummaryRequest { /** * External seating plan ID. * @minLength 1 * @maxLength 100 */ externalId?: string; /** * Whether to bypass cache for real-time accuracy. Default: `false` * @internal */ disableCache?: boolean | null; } /** Response containing complete seating plan and occupancy data. */ interface GetSeatingReservationSummaryResponse { /** Complete seating plan structure. */ plan?: SeatingPlan; /** * Occupancy details for each place in the plan. * @maxSize 50000 */ places?: PlaceReservationDetails[]; } /** A seating plan represents the layout and organization of seats within a venue. It defines the physical arrangement of seating areas, pricing categories, and individual places where attendees can be seated or positioned during an event. */ interface SeatingPlan { /** * Seating plan ID. * @format GUID * @readonly */ _id?: string | null; /** * Client-defined external ID for cross-referencing with external systems. Format: `{fqdn}:{entity_guid}`. For example, `wix.events.v1.event:abc-123-def`. * @minLength 1 * @maxLength 100 */ externalId?: string | null; /** * Human-friendly seating plan title. For example, `Madison Square Garden - Main Floor`. * @minLength 1 * @maxLength 120 */ title?: string | null; /** * High-level divisions of the venue, such as "Orchestra", "Balcony", or "VIP Section". A default section with `id = 0` is required and serves as the primary seating area. * @maxSize 100 */ sections?: Section[]; /** * Pricing tiers or groupings for organizing places, such as "VIP", "General Admission", or "Student Discount". Elements and places can be assigned to categories for pricing and availability management. * @maxSize 100 */ categories?: Category[]; /** * Date and time the seating plan was created. * @readonly */ _createdDate?: Date | null; /** * Date and time the seating plan was updated. * @readonly */ _updatedDate?: Date | null; /** * Total number of seats across all sections and elements in the seating plan. Automatically calculated by summing element capacities. * @readonly */ totalCapacity?: number | null; /** * Total number of categories defined in the seating plan. Automatically calculated. * @readonly */ totalCategories?: number | null; /** * Places that are not assigned to any category. These places require manual category assignment for pricing and organization. * @maxSize 50000 * @readonly */ uncategorizedPlaces?: Place[]; /** * Version number of the seating plan, incremented by 1 each time the plan is updated. Used for version management and tracking changes. * @readonly */ version?: string | null; /** Additional custom fields for extending the seating plan with app-specific data. Learn more about @extended fields. */ extendedFields?: ExtendedFields; /** Visual settings for the seating plan, such as background color and opacity. Used by seating chart interfaces for rendering. */ uiProperties?: SeatingPlanUiProperties; /** * Hierarchical groupings of elements for UI organization and bulk operations. Groups can contain multiple elements or nested sub-groups for easier management. * @maxSize 1000 */ elementGroups?: ElementGroup[]; /** Optimistic concurrency control; preserved from request, defaults to current plan's revision when absent. */ revision?: string | null; } /** A section represents a high-level division within a seating plan, such as "Orchestra", "Balcony", or "VIP Area". Sections contain elements that define the actual seating arrangements. */ interface Section { /** Section ID. Must be unique within the seating plan. Section with `id = 0` is required as the default section. */ _id?: number; /** * Human-readable section title. For example, `Orchestra` or `Balcony`. * @minLength 1 * @maxLength 20 */ title?: string | null; /** * Client configuration object for storing additional section metadata. Read-only field maintained for backward compatibility. * @internal * @readonly */ config?: Record | null; /** * Seating elements within this section, such as rows, tables, or general admission areas. Each element generates individual places based on its type and capacity. * @maxSize 1000 */ elements?: Element[]; /** * Total capacity of all elements within this section. Automatically calculated by summing element capacities. * @readonly */ totalCapacity?: number | null; /** * Whether this is the default section. Always `true` for section with `id = 0`. * @readonly */ default?: boolean; } /** An element represents a specific seating configuration within a section, such as a row of seats, a table, or a general admission area. Elements generate individual places based on their type and capacity. */ interface Element { /** * Element ID. Must be unique within the seating plan. * @min 1 */ _id?: number; /** * User-friendly title or label for the element. For example, `Row A` or `VIP Table 1`. * @minLength 1 * @maxLength 50 */ title?: string | null; /** Type of seating element, which determines capacity limits and place generation behavior. See ElementTypeEnum for available types. */ type?: TypeWithLiterals; /** * Number of seats or spots in this element. Not applicable for SHAPE type elements. Maximum 50,000 per element. * @min 1 * @max 50000 */ capacity?: number | null; /** ID of the category this element is assigned to for pricing and organization. References a category defined in the seating plan. */ categoryId?: number | null; /** Configuration for generating place labels and numbering within this element. Defines how seats are labeled (e.g., 1, 2, 3 or A, B, C). */ sequencing?: Sequencing; /** * Custom place configurations that override the default generated places for specific positions. Used for accessibility seating, obstructed views, or custom labeling. * @maxSize 2000 */ overrides?: Place[]; /** * Final sequence of places generated for this element, including any overrides applied. Read-only field populated by the system. * @maxSize 200 * @readonly */ places?: Place[]; /** Constraints on how this element can be reserved or booked. For example, requiring the entire element to be reserved as a unit. */ reservationOptions?: ReservationOptions; /** Visual positioning and styling properties for rendering this element in a seating chart. Includes coordinates, dimensions, and styling options. */ uiProperties?: ElementUiProperties; /** ID of the element group this element belongs to for hierarchical organization. References an ElementGroup defined in the seating plan. */ elementGroupId?: number | null; /** Additional properties for MULTI_ROW type elements, defining individual rows and their configurations. Only applicable when type is MULTI_ROW. */ multiRowProperties?: MultiRowProperties; } declare enum Type { /** General admission area with a single place containing the full capacity. */ AREA = "AREA", /** Single row of individual seats with sequential labeling. */ ROW = "ROW", /** Multiple rows treated as one element, each with individual capacity and sequencing. */ MULTI_ROW = "MULTI_ROW", /** Rectangular table with individual seats around the perimeter. */ TABLE = "TABLE", /** Circular table with individual seats around the perimeter. */ ROUND_TABLE = "ROUND_TABLE", /** Visual element with no seating capacity, used for decorative or informational purposes. */ SHAPE = "SHAPE" } /** @enumType */ type TypeWithLiterals = Type | 'AREA' | 'ROW' | 'MULTI_ROW' | 'TABLE' | 'ROUND_TABLE' | 'SHAPE'; /** Configuration for generating sequential labels for places within an element. */ interface Sequencing { /** * Starting value for the sequence. For example, `1` for numeric sequences or `A` for alphabetical sequences. * @minLength 1 * @maxLength 4 */ startAt?: string; /** * Complete sequence of labels to be used for places. Must match the element's capacity. When provided, overrides automatic label generation. * @maxSize 2500 */ labels?: string[]; /** Whether to apply labels in reverse order (right-to-left instead of left-to-right). Useful for venue-specific numbering conventions. */ reverseOrder?: boolean | null; } /** An individual seat or spot within an element where an attendee can be positioned. */ interface Place { /** Zero-based position of this place within the element's sequence. Used to identify the place's position for overrides. */ index?: number; /** * Unique place ID in the format `{section_id}-{element_id}-{label}`. For example, `0-1-A5` for section 0, element 1, seat A5. * @readonly */ _id?: string | null; /** * Human-readable label for this place, such as `A1`, `12`, or `VIP1`. Generated based on sequencing configuration or custom overrides. * @minLength 1 * @maxLength 4 */ label?: string; /** * Maximum number of people that can occupy this place. Typically 1 for individual seats, higher for AREA type places. * @readonly */ capacity?: number | null; /** * Type of the parent element that contains this place. Inherited from the element's type. * @readonly */ elementType?: TypeWithLiterals; /** * ID of the category this place is assigned to. Inherited from element or row category assignment. * @readonly */ categoryId?: number | null; /** Special characteristics or accessibility features of this place (standard, wheelchair, accessible, companion, obstructed, discount). */ type?: PlaceTypeEnumTypeWithLiterals; } declare enum PlaceTypeEnumType { /** Standard seating with no special accommodations. */ STANDARD = "STANDARD", /** Wheelchair accessible seating space. */ WHEELCHAIR = "WHEELCHAIR", /** Accessible seating for mobility-impaired guests. */ ACCESSIBLE = "ACCESSIBLE", /** Companion seat adjacent to accessible seating. */ COMPANION = "COMPANION", /** Seat with limited or obstructed view. */ OBSTRUCTED = "OBSTRUCTED", /** Discounted pricing seat. */ DISCOUNT = "DISCOUNT" } /** @enumType */ type PlaceTypeEnumTypeWithLiterals = PlaceTypeEnumType | 'STANDARD' | 'WHEELCHAIR' | 'ACCESSIBLE' | 'COMPANION' | 'OBSTRUCTED' | 'DISCOUNT'; /** Configuration options that control how an element can be reserved or booked. */ interface ReservationOptions { /** Whether the entire element must be reserved as a single unit. When `true`, individual seats cannot be booked separately. Cannot be used with AREA type elements. */ reserveWholeElement?: boolean; } /** Visual positioning and styling properties for rendering elements in a seating chart interface. */ interface ElementUiProperties { /** * Horizontal position coordinate of the element in the seating chart coordinate system. * @min -1000000 * @max 1000000 */ x?: number | null; /** * Vertical position coordinate of the element in the seating chart coordinate system. * @min -1000000 * @max 1000000 */ y?: number | null; /** * Layering order for overlapping elements. Higher values appear on top of lower values. * @min -1000000 * @max 1000000 */ zIndex?: number | null; /** * Width of the element in the coordinate system units. * @max 1000000 */ width?: number | null; /** * Height of the element in the coordinate system units. * @max 1000000 */ height?: number | null; /** * Rotation angle of the element in degrees. Positive values rotate clockwise. * @min -180 * @max 180 */ rotationAngle?: number | null; /** Shape type for SHAPE elements that don't represent seating. Only applicable when element type is SHAPE. */ shapeType?: ShapeTypeEnumTypeWithLiterals; /** * Font size for text elements in points. * @min 10 * @max 176 */ fontSize?: number | null; /** * Corner radius for rounded rectangular shapes in coordinate system units. * @max 1000000 */ cornerRadius?: number | null; /** * Horizontal spacing between individual seats within the element. * @min 1 * @max 60 */ seatSpacing?: number | null; /** Whether to hide labels on seats within this element. When `true`, seat labels are not displayed in the UI. */ hideLabel?: boolean | null; /** Position of labels relative to seats (left, right, both sides, or none). */ labelPosition?: PositionWithLiterals; /** Array defining the arrangement of seats within the element. Each number represents the count of seats in that position. */ seatLayout?: number[]; /** * Number of empty spaces at the top of the seating arrangement for visual spacing. * @max 50 */ emptyTopSeatSpaces?: number | null; /** * Text content for TEXT type shape elements. Only applicable when shape_type is TEXT. * @minLength 1 * @maxLength 10000 */ text?: string | null; /** * Primary color in hexadecimal format. For example, `#FF0000` for red. * @format COLOR_HEX */ color?: string | null; /** * Fill color for shapes in hexadecimal format. For example, `#00FF00` for green. * @format COLOR_HEX */ fillColor?: string | null; /** * Border color in hexadecimal format. For example, `#0000FF` for blue. * @format COLOR_HEX */ strokeColor?: string | null; /** * Border width in pixels for shape outlines. * @min 1 * @max 6 */ strokeWidth?: number | null; /** * Opacity level as a percentage from 0 (transparent) to 100 (opaque). * @max 100 */ opacity?: number | null; /** Icon type for ICON shape elements. Only applicable when shape_type is ICON. */ icon?: IconWithLiterals; /** Image object for IMAGE shape elements. Only applicable when shape_type is IMAGE. */ image?: Image; /** Numbering scheme for seats within this element (numeric, alphabetical, or odd/even). */ seatNumbering?: NumberingWithLiterals; } declare enum ShapeTypeEnumType { /** Unknown shape type. */ UNKNOWN_TYPE = "UNKNOWN_TYPE", /** Text label or annotation. */ TEXT = "TEXT", /** Rectangular shape. */ RECTANGLE = "RECTANGLE", /** Circular or oval shape. */ ELLIPSE = "ELLIPSE", /** Straight line. */ LINE = "LINE", /** Predefined icon symbol. */ ICON = "ICON", /** Custom image. */ IMAGE = "IMAGE" } /** @enumType */ type ShapeTypeEnumTypeWithLiterals = ShapeTypeEnumType | 'UNKNOWN_TYPE' | 'TEXT' | 'RECTANGLE' | 'ELLIPSE' | 'LINE' | 'ICON' | 'IMAGE'; declare enum Position { /** Label positioning options for seats and elements. */ UNKNOWN_POSITION = "UNKNOWN_POSITION", /** Labels appear to the left of seats. */ LEFT = "LEFT", /** Labels appear to the right of seats. */ RIGHT = "RIGHT", /** Labels appear on both sides of seats. */ BOTH = "BOTH", /** No labels are displayed. */ NONE = "NONE" } /** @enumType */ type PositionWithLiterals = Position | 'UNKNOWN_POSITION' | 'LEFT' | 'RIGHT' | 'BOTH' | 'NONE'; declare enum Icon { /** Available icon types for venue wayfinding and information. */ UNKNOWN_ICON = "UNKNOWN_ICON", /** Entrance icon. */ ENTER = "ENTER", /** Exit icon. */ EXIT = "EXIT", /** Beverage service icon. */ DRINKS = "DRINKS", /** Restroom icon. */ WC = "WC", /** Men's restroom icon. */ WC_MEN = "WC_MEN", /** Women's restroom icon. */ WC_WOMEN = "WC_WOMEN", /** Food service icon. */ FOOD = "FOOD", /** Stairway icon. */ STAIRS = "STAIRS", /** Elevator icon. */ ELEVATOR = "ELEVATOR", /** Smoking area icon. */ SMOKING = "SMOKING", /** Coat check icon. */ CHECKROOM = "CHECKROOM", /** Stage or performance area icon. */ STAGE = "STAGE" } /** @enumType */ type IconWithLiterals = Icon | 'UNKNOWN_ICON' | 'ENTER' | 'EXIT' | 'DRINKS' | 'WC' | 'WC_MEN' | 'WC_WOMEN' | 'FOOD' | 'STAIRS' | 'ELEVATOR' | 'SMOKING' | 'CHECKROOM' | 'STAGE'; /** Image reference for use in seating plan visual elements. */ interface Image { /** Image ID from Wix Media Manager. */ _id?: string; /** * Original image height in pixels. * @readonly */ height?: number; /** * Original image width in pixels. * @readonly */ width?: number; /** * Deprecated. Use the `id` field instead for referencing images. * @deprecated */ uri?: string | null; } declare enum Numbering { /** Seat numbering patterns for sequential label generation. */ UNKNOWN_NUMBERING = "UNKNOWN_NUMBERING", /** Sequential numbers (1, 2, 3, ...). */ NUMERIC = "NUMERIC", /** Alternating odd and even numbers. */ ODD_EVEN = "ODD_EVEN", /** Sequential letters (A, B, C, ...). */ ALPHABETICAL = "ALPHABETICAL" } /** @enumType */ type NumberingWithLiterals = Numbering | 'UNKNOWN_NUMBERING' | 'NUMERIC' | 'ODD_EVEN' | 'ALPHABETICAL'; /** Configuration for multi-row elements that contain multiple individual rows, each with their own capacity and sequencing. */ interface MultiRowProperties { /** * Individual rows within the multi-row element. Each row has its own capacity, sequencing, and category assignment. * @maxSize 1000 */ rows?: RowElement[]; /** Configuration for labeling rows vertically (e.g., Row A, Row B, Row C). Defines how row labels are generated. */ verticalSequencing?: VerticalSequencing; /** * Vertical spacing between rows in the multi-row element. Measured in coordinate system units. * @min 1 * @max 60 */ rowSpacing?: number | null; /** * Radius for curved row arrangements. * @internal * @max 1000000 */ curveRadius?: number | null; /** * End angle for curved row arrangements. * @internal * @max 360 */ curveAngleTo?: number | null; /** * Number of seats per row in the multi-row element. * @max 50 */ seatAmount?: number | null; /** * Start angle for curved row arrangements. * @internal * @max 360 */ curveAngleFrom?: number | null; /** * Whether the rows are arranged in a curved pattern. * @internal */ curved?: boolean | null; } /** An individual row within a multi-row element, with its own capacity, sequencing, and category assignment. */ interface RowElement { /** * Row ID. Must be unique across all multi-row elements in the seating plan. * @min 1 */ _id?: number; /** * User-friendly title or label for this row. For example, `Row A` or `Front Row`. * @minLength 1 * @maxLength 50 */ title?: string | null; /** * Number of seats in this row. Maximum 50,000 per row. * @min 1 * @max 50000 */ capacity?: number | null; /** Category assignment for this row, which can override the parent element's category. References a category defined in the seating plan. */ categoryId?: number | null; /** Configuration for generating seat labels within this row. Defines numbering scheme and starting position. */ sequencing?: Sequencing; /** Visual properties specific to this row within the multi-row element. Includes positioning relative to parent element. */ uiProperties?: RowElementUiProperties; } /** Visual properties specific to individual rows within multi-row elements. */ interface RowElementUiProperties { /** * Horizontal position relative to the parent multi-row element's coordinate system. * @min -1000000 * @max 1000000 */ relativeX?: number | null; /** * Width of this row in coordinate system units. * @max 1000000 */ width?: number | null; /** * Number of seats in this row. Overrides the capacity field when specified. * @max 50 */ seatAmount?: number | null; /** * Start angle for curved row arrangements. * @internal * @max 360 */ curveAngleFrom?: number | null; /** * End angle for curved row arrangements. * @internal * @max 360 */ curveAngleTo?: number | null; /** * Spacing between seats in this row. * @min 1 * @max 60 */ seatSpacing?: number | null; /** Position of labels relative to seats in this row (left, right, both sides, or none). // Position of labels relative to seats in this row. */ labelPosition?: PositionWithLiterals; /** Numbering scheme for seats in this row (numeric, alphabetical, or odd/even). */ seatNumbering?: NumberingWithLiterals; } /** Configuration for labeling rows vertically in multi-row elements. */ interface VerticalSequencing { /** * Starting value for row labeling. For example, `A` for alphabetical sequences or `1` for numeric sequences. * @minLength 1 * @maxLength 4 */ startAt?: string; /** Numbering scheme for row labels (numeric, alphabetical, or odd/even). */ rowNumbering?: NumberingWithLiterals; /** Whether to label rows in reverse order (bottom-to-top instead of top-to-bottom). */ reverseOrder?: boolean | null; } /** A grouping mechanism for organizing places by pricing tier, access level, or other business criteria. */ interface Category { /** * Category ID. Must be unique within the seating plan. * @min 1 */ _id?: number; /** * Client-defined external ID for cross-referencing with pricing or ticketing systems. Format: `{entity_fqdn}:{entity_id}`. * @minLength 1 * @maxLength 100 */ externalId?: string | null; /** * Human-readable category name, such as `VIP`, `General Admission`, or `Student Discount`. * @minLength 1 * @maxLength 120 */ title?: string; /** * Client configuration object for storing additional category metadata. Read-only field maintained for backward compatibility. * @internal * @readonly */ config?: Record | null; /** * Total capacity of all places assigned to this category. Automatically calculated by summing place capacities. * @readonly */ totalCapacity?: number | null; /** * All places that are assigned to this category. Populated when using the CATEGORIES fieldset. * @maxSize 50000 * @readonly */ places?: Place[]; } interface ExtendedFields { /** * Extended field data. Each key corresponds to the namespace of the app that created the extended fields. * The value of each key is structured according to the schema defined when the extended fields were configured. * * You can only access fields for which you have the appropriate permissions. * * Learn more about [extended fields](https://dev.wix.com/docs/rest/articles/getting-started/extended-fields). */ namespaces?: Record>; } /** Visual styling properties for the overall seating plan background and appearance. */ interface SeatingPlanUiProperties { /** * Background color in hexadecimal format. For example, `#F0F0F0` for light gray. * @format COLOR_HEX */ backgroundColor?: string | null; /** * Background opacity as a percentage from 0 (transparent) to 100 (opaque). * @max 100 */ backgroundOpacity?: number | null; } /** A hierarchical grouping of elements for UI organization and bulk operations. */ interface ElementGroup { /** * Element group ID. Must be unique within the seating plan. * @min 1 */ _id?: number; /** ID of the parent group for creating nested group hierarchies. References another ElementGroup in the same seating plan. */ parentElementGroupId?: number | null; /** Visual properties for rendering this group in the UI. Includes positioning and dimensions for the group container. */ uiProperties?: ElementGroupUiProperties; } /** Visual positioning and styling properties for element groups. */ interface ElementGroupUiProperties { /** * Horizontal position coordinate of the group container. * @min -1000000 * @max 1000000 */ x?: number | null; /** * Vertical position coordinate of the group container. * @min -1000000 * @max 1000000 */ y?: number | null; /** * Width of the group bounding box in coordinate system units. * @max 1000000 */ width?: number | null; /** * Height of the group bounding box in coordinate system units. * @max 1000000 */ height?: number | null; /** * Rotation angle of the group in degrees. Applied to all elements within the group. * @min -180 * @max 180 */ rotationAngle?: number | null; } /** Request to retrieve detailed place-level occupancy data by external ID. */ interface GetSeatingReservationSummaryByExternalIdRequest { /** * External seating plan ID. * @minLength 1 * @maxLength 100 */ externalId: string; /** * Whether to bypass cache for real-time accuracy. Default: `false` * @internal */ disableCache?: boolean | null; } /** Response containing complete seating plan and occupancy data. */ interface GetSeatingReservationSummaryByExternalIdResponse { /** Complete seating plan structure. */ plan?: SeatingPlan; /** * Occupancy details for each place in the plan. * @maxSize 50000 */ places?: PlaceReservationDetails[]; } /** Request to regenerate cached summaries. */ interface RegenerateSummariesRequest { /** * Seating plan ID. * @format GUID */ planId?: string | null; } /** Response after regenerating summaries. */ interface RegenerateSummariesResponse { /** Regenerated place-level occupancy summary. */ seatingReservationsSummary?: SeatingReservationsSummary; /** * Regenerated category-level summaries. * @maxSize 50000 */ categories?: CategoryDetails[]; } /** Aggregated occupancy data for all places in a seating plan. */ interface SeatingReservationsSummary { /** * Occupancy details for each place. * @maxSize 50000 */ places?: PlaceReservationDetails[]; } interface DomainEvent extends DomainEventBodyOneOf { createdEvent?: EntityCreatedEvent; updatedEvent?: EntityUpdatedEvent; deletedEvent?: EntityDeletedEvent; actionEvent?: ActionEvent; /** Event ID. With this ID you can easily spot duplicated events and ignore them. */ _id?: string; /** * Fully Qualified Domain Name of an entity. This is a unique identifier assigned to the API main business entities. * For example, `wix.stores.catalog.product`, `wix.bookings.session`, `wix.payments.transaction`. */ entityFqdn?: string; /** * Event action name, placed at the top level to make it easier for users to dispatch messages. * For example: `created`/`updated`/`deleted`/`started`/`completed`/`email_opened`. */ slug?: string; /** ID of the entity associated with the event. */ entityId?: string; /** Event timestamp in [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) format and UTC time. For example, `2020-04-26T13:57:50.699Z`. */ eventTime?: Date | null; /** * Whether the event was triggered as a result of a privacy regulation application * (for example, GDPR). */ triggeredByAnonymizeRequest?: boolean | null; /** If present, indicates the action that triggered the event. */ originatedFrom?: string | null; /** * A sequence number that indicates the order of updates to an entity. For example, if an entity was updated at `16:00` and then again at `16:01`, the second update will always have a higher sequence number. * You can use this number to make sure you're handling updates in the right order. Just save the latest sequence number on your end and compare it to the one in each new message. If the new message has an older (lower) number, you can safely ignore it. */ entityEventSequence?: string | null; } /** @oneof */ interface DomainEventBodyOneOf { createdEvent?: EntityCreatedEvent; updatedEvent?: EntityUpdatedEvent; deletedEvent?: EntityDeletedEvent; actionEvent?: ActionEvent; } interface EntityCreatedEvent { entity?: string; } interface RestoreInfo { deletedDate?: Date | null; } interface EntityUpdatedEvent { /** * Since platformized APIs only expose PATCH and not PUT we can't assume that the fields sent from the client are the actual diff. * This means that to generate a list of changed fields (as opposed to sent fields) one needs to traverse both objects. * We don't want to impose this on all developers and so we leave this traversal to the notification recipients which need it. */ currentEntity?: string; } interface EntityDeletedEvent { /** Entity that was deleted. */ deletedEntity?: string | null; } interface ActionEvent { body?: string; } /** Request to list all available places in a seating plan. */ interface ListAvailablePlacesRequest { /** * External seating plan ID. For example, `wix.events.v1.event:abc-123-def`. * @minLength 1 * @maxLength 100 */ externalId?: string; } /** Response containing all available places with their details. */ interface ListAvailablePlacesResponse { /** * Available places across all categories in the seating plan. * @maxSize 50000 */ places?: AvailablePlace[]; } /** An individual available place with all relevant details. */ interface AvailablePlace { /** * Place ID in the format `{section_id}-{element_id}-{label}`. For example, `0-1-A5`. * @minLength 1 * @maxLength 20 */ placeId?: string; /** * Human-readable label for this place, such as `A1`, `12`, or `VIP1`. * @minLength 1 * @maxLength 4 */ label?: string; /** * Section name where this place is located. For example, `Orchestra` or `Balcony`. * @minLength 1 * @maxLength 20 */ sectionLabel?: string | null; /** * Element label from the seating plan. For example, `Row A`, `Table 5`, or `General Admission`. * @minLength 1 * @maxLength 50 */ elementLabel?: string | null; /** Numeric category ID this place is assigned to for pricing and organization. */ categoryId?: number; /** * External category ID for cross-referencing with ticketing systems. Format: `{entity_fqdn}:{entity_id}`. For example, `wix.events.v1.ticket_definition:xyz-456`. * @minLength 1 * @maxLength 100 */ externalCategoryId?: string | null; /** Type of seating element (AREA, ROW, MULTI_ROW, TABLE, ROUND_TABLE, SHAPE). */ elementType?: TypeWithLiterals; /** * Available capacity at this place. For AREA type: remaining spots; for other types: 0 or 1. * @max 50000 */ availableCapacity?: number; /** * Total capacity of this place. * @max 50000 */ totalCapacity?: number; } /** Request to delete seating reservations by external ID. */ interface DeleteSeatingReservationByExternalIdRequest { /** * External ID of the seating reservation (e.g., "wix.events.v1.reservation:{uuid}"). * @minLength 1 * @maxLength 100 */ externalId?: string; } /** Response after deleting seating reservations by external ID. */ interface DeleteSeatingReservationByExternalIdResponse { } interface MessageEnvelope { /** * App instance ID. * @format GUID */ instanceId?: string | null; /** * Event type. * @maxLength 150 */ eventType?: string; /** The identification type and identity data. */ identity?: IdentificationData; /** Stringify payload. */ data?: string; /** Details related to the account */ accountInfo?: AccountInfo; } interface IdentificationData extends IdentificationDataIdOneOf { /** * ID of a site visitor that has not logged in to the site. * @format GUID */ anonymousVisitorId?: string; /** * ID of a site visitor that has logged in to the site. * @format GUID */ memberId?: string; /** * ID of a Wix user (site owner, contributor, etc.). * @format GUID */ wixUserId?: string; /** * ID of an app. * @format GUID */ appId?: string; /** @readonly */ identityType?: WebhookIdentityTypeWithLiterals; } /** @oneof */ interface IdentificationDataIdOneOf { /** * ID of a site visitor that has not logged in to the site. * @format GUID */ anonymousVisitorId?: string; /** * ID of a site visitor that has logged in to the site. * @format GUID */ memberId?: string; /** * ID of a Wix user (site owner, contributor, etc.). * @format GUID */ wixUserId?: string; /** * ID of an app. * @format GUID */ appId?: string; } declare enum WebhookIdentityType { UNKNOWN = "UNKNOWN", ANONYMOUS_VISITOR = "ANONYMOUS_VISITOR", MEMBER = "MEMBER", WIX_USER = "WIX_USER", APP = "APP" } /** @enumType */ type WebhookIdentityTypeWithLiterals = WebhookIdentityType | 'UNKNOWN' | 'ANONYMOUS_VISITOR' | 'MEMBER' | 'WIX_USER' | 'APP'; interface AccountInfo { /** * ID of the Wix account associated with the event. * @format GUID */ accountId?: string | null; /** * ID of the parent Wix account. Only included when accountId belongs to a child account. * @format GUID */ parentAccountId?: string | null; /** * ID of the Wix site associated with the event. Only included when the event is tied to a specific site. * @format GUID */ siteId?: string | null; } /** @docsIgnore */ type CreateSeatingReservationApplicationErrors = { code?: 'PLACE_NOT_FOUND'; description?: string; data?: Places; } | { code?: 'PLACE_RESERVED'; description?: string; data?: UnavailablePlaces; }; interface BaseEventMetadata { /** * App instance ID. * @format GUID */ instanceId?: string | null; /** * Event type. * @maxLength 150 */ eventType?: string; /** The identification type and identity data. */ identity?: IdentificationData; /** Details related to the account */ accountInfo?: AccountInfo; } interface EventMetadata extends BaseEventMetadata { /** Event ID. With this ID you can easily spot duplicated events and ignore them. */ _id?: string; /** * Fully Qualified Domain Name of an entity. This is a unique identifier assigned to the API main business entities. * For example, `wix.stores.catalog.product`, `wix.bookings.session`, `wix.payments.transaction`. */ entityFqdn?: string; /** * Event action name, placed at the top level to make it easier for users to dispatch messages. * For example: `created`/`updated`/`deleted`/`started`/`completed`/`email_opened`. */ slug?: string; /** ID of the entity associated with the event. */ entityId?: string; /** Event timestamp in [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) format and UTC time. For example, `2020-04-26T13:57:50.699Z`. */ eventTime?: Date | null; /** * Whether the event was triggered as a result of a privacy regulation application * (for example, GDPR). */ triggeredByAnonymizeRequest?: boolean | null; /** If present, indicates the action that triggered the event. */ originatedFrom?: string | null; /** * A sequence number that indicates the order of updates to an entity. For example, if an entity was updated at `16:00` and then again at `16:01`, the second update will always have a higher sequence number. * You can use this number to make sure you're handling updates in the right order. Just save the latest sequence number on your end and compare it to the one in each new message. If the new message has an older (lower) number, you can safely ignore it. */ entityEventSequence?: string | null; accountInfo?: AccountInfoMetadata; } interface AccountInfoMetadata { /** ID of the Wix account associated with the event */ accountId: string; /** ID of the Wix site associated with the event. Only included when the event is tied to a specific site. */ siteId?: string; /** ID of the parent Wix account. Only included when 'accountId' belongs to a child account. */ parentAccountId?: string; } interface SeatingReservationCreatedEnvelope { entity: SeatingReservation; metadata: EventMetadata; } /** @permissionScope Manage Events * @permissionScopeId SCOPE.EVENTS.MANAGE-EVENTS * @permissionId SEATING_PLANS.READ_RESERVATIONS * @webhook * @eventType wix.seating.v1.seating_reservation_created * @slug created * @documentationMaturity preview */ declare function onSeatingReservationCreated(handler: (event: SeatingReservationCreatedEnvelope) => void | Promise): void; interface SeatingReservationDeletedEnvelope { entity: SeatingReservation; metadata: EventMetadata; } /** @permissionScope Manage Events * @permissionScopeId SCOPE.EVENTS.MANAGE-EVENTS * @permissionId SEATING_PLANS.READ_RESERVATIONS * @webhook * @eventType wix.seating.v1.seating_reservation_deleted * @slug deleted * @documentationMaturity preview */ declare function onSeatingReservationDeleted(handler: (event: SeatingReservationDeletedEnvelope) => void | Promise): void; /** * Creates a seating reservation for one or more places within a seating plan. * @public * @documentationMaturity preview * @permissionId SEATING_PLANS.MANAGE_RESERVATIONS * @applicableIdentity APP * @returns Created reservation. * @fqn com.wixpress.seating.SeatingReservationService.CreateSeatingReservation */ declare function createSeatingReservation(options?: CreateSeatingReservationOptions): Promise & { __applicationErrorsType?: CreateSeatingReservationApplicationErrors; }>; interface CreateSeatingReservationOptions { /** Reservation to create. */ reservation?: SeatingReservation; } /** * Retrieves a seating reservation by ID. * @param reservationId - Reservation ID. * @public * @documentationMaturity preview * @requiredField reservationId * @permissionId SEATING_PLANS.READ_RESERVATIONS * @applicableIdentity APP * @returns Retrieved reservation. * @fqn com.wixpress.seating.SeatingReservationService.GetSeatingReservation */ declare function getSeatingReservation(reservationId: string): Promise>; /** * Retrieves seating reservations that match specified criteria. * @public * @documentationMaturity preview * @permissionId SEATING_PLANS.READ_RESERVATIONS * @applicableIdentity APP * @fqn com.wixpress.seating.SeatingReservationService.QuerySeatingReservations */ declare function querySeatingReservations(): ReservationsQueryBuilder; interface QueryCursorResult { cursors: Cursors; hasNext: () => boolean; hasPrev: () => boolean; length: number; pageSize: number; } interface ReservationsQueryResult extends QueryCursorResult { items: SeatingReservation[]; query: ReservationsQueryBuilder; next: () => Promise; prev: () => Promise; } interface ReservationsQueryBuilder { /** @param propertyName - Property whose value is compared with `value`. * @param value - Value to compare against. * @documentationMaturity preview */ eq: (propertyName: '_id' | 'seatingPlanId' | 'externalId' | '_createdDate' | '_updatedDate', value: any) => ReservationsQueryBuilder; /** @param propertyName - Property whose value is compared with `value`. * @param value - Value to compare against. * @documentationMaturity preview */ ne: (propertyName: '_id' | 'seatingPlanId' | 'externalId' | '_createdDate' | '_updatedDate', value: any) => ReservationsQueryBuilder; /** @param propertyName - Property whose value is compared with `value`. * @param value - Value to compare against. * @documentationMaturity preview */ ge: (propertyName: '_createdDate' | '_updatedDate', value: any) => ReservationsQueryBuilder; /** @param propertyName - Property whose value is compared with `value`. * @param value - Value to compare against. * @documentationMaturity preview */ gt: (propertyName: '_createdDate' | '_updatedDate', value: any) => ReservationsQueryBuilder; /** @param propertyName - Property whose value is compared with `value`. * @param value - Value to compare against. * @documentationMaturity preview */ le: (propertyName: '_createdDate' | '_updatedDate', value: any) => ReservationsQueryBuilder; /** @param propertyName - Property whose value is compared with `value`. * @param value - Value to compare against. * @documentationMaturity preview */ lt: (propertyName: '_createdDate' | '_updatedDate', value: any) => ReservationsQueryBuilder; /** @param propertyName - Property whose value is compared with `string`. * @param string - String to compare against. Case-insensitive. * @documentationMaturity preview */ startsWith: (propertyName: 'externalId', value: string) => ReservationsQueryBuilder; /** @documentationMaturity preview */ in: (propertyName: '_id' | 'seatingPlanId' | 'externalId' | '_createdDate' | '_updatedDate', value: any) => ReservationsQueryBuilder; /** @documentationMaturity preview */ exists: (propertyName: 'externalId', value: boolean) => ReservationsQueryBuilder; /** @param propertyNames - Properties used in the sort. To sort by multiple properties, pass properties as additional arguments. * @documentationMaturity preview */ ascending: (...propertyNames: Array<'_createdDate' | '_updatedDate'>) => ReservationsQueryBuilder; /** @param propertyNames - Properties used in the sort. To sort by multiple properties, pass properties as additional arguments. * @documentationMaturity preview */ descending: (...propertyNames: Array<'_createdDate' | '_updatedDate'>) => ReservationsQueryBuilder; /** @param limit - Number of items to return, which is also the `pageSize` of the results object. * @documentationMaturity preview */ limit: (limit: number) => ReservationsQueryBuilder; /** @param cursor - A pointer to specific record * @documentationMaturity preview */ skipTo: (cursor: string) => ReservationsQueryBuilder; /** @documentationMaturity preview */ find: () => Promise; } /** * @hidden * @fqn com.wixpress.seating.SeatingReservationService.QuerySeatingReservations * @requiredField query * @returns Response containing matching seating reservations. */ declare function typedQuerySeatingReservations(query: SeatingReservationQuery): Promise>; interface SeatingReservationQuerySpec extends QuerySpec { paging: 'cursor'; wql: [ { fields: ['_id', 'seatingPlanId']; operators: ['$eq', '$in', '$ne', '$nin']; sort: 'NONE'; }, { fields: ['externalId']; operators: ['$eq', '$exists', '$in', '$ne', '$nin', '$startsWith']; sort: 'NONE'; }, { fields: ['_createdDate', '_updatedDate']; operators: ['$eq', '$gt', '$gte', '$in', '$lt', '$lte', '$ne', '$nin']; sort: 'BOTH'; } ]; } type CommonQueryWithEntityContext = Query; type SeatingReservationQuery = { /** Cursor token pointing to a page of results. Not used in the first request. Following requests use the cursor token and not `filter` or `sort`. */ cursorPaging?: { /** Maximum number of items to return in the results. @max: 100 */ limit?: NonNullable['limit'] | null; /** Pointer to the next or previous page in the list of results. Pass the relevant cursor token from the `pagingMetadata` object in the previous call's response. Not relevant for the first request. @maxLength: 16000 */ cursor?: NonNullable['cursor'] | null; }; /** Filter object. Learn more about [filtering](https://dev.wix.com/docs/rest/articles/getting-started/api-query-language#filters). */ filter?: CommonQueryWithEntityContext['filter'] | null; /** Sort object. Learn more about [sorting](https://dev.wix.com/docs/rest/articles/getting-started/api-query-language#sorting). */ sort?: { /** Name of the field to sort by. @maxLength: 512 */ fieldName?: NonNullable[number]['fieldName']; /** Sort order. */ order?: NonNullable[number]['order']; /** When `field_name` is a property of repeated field that is marked as `MATCH_ITEMS` and sort should be done by a specific element from a collection, filter can/should be provided to ensure correct sort value is picked. If multiple filters are provided, they are combined with AND operator. Example: Given we have document like {"id": "1", "nestedField": [{"price": 10, "region": "EU"}, {"price": 20, "region": "US"}]} and `nestedField` is marked as `MATCH_ITEMS`, to ensure that sorting is done by correct region, filter should be { fieldName: "nestedField.price", "select_items_by": [{"nestedField.region": "US"}] } @internal: undefined, @maxSize: 10 */ selectItemsBy?: NonNullable[number]['selectItemsBy'] | null; /** Origin point for geo-distance sorting on a GEO field results are ordered by distance from this point (ASC = nearest first, DESC = farthest first). */ origin?: NonNullable[number]['origin']; }[]; }; declare const utils: { query: { QueryBuilder: () => _wix_sdk_types.QueryBuilder; Filter: _wix_sdk_types.FilterFactory; Sort: _wix_sdk_types.SortFactory; }; }; /** * Deletes a seating reservation and releases all reserved places. * @param _id - Reservation ID. * @public * @documentationMaturity preview * @requiredField _id * @permissionId SEATING_PLANS.MANAGE_RESERVATIONS * @applicableIdentity APP * @returns Response after deleting a seating reservation. * @fqn com.wixpress.seating.SeatingReservationService.DeleteSeatingReservation */ declare function deleteSeatingReservation(_id: string): Promise>; /** * Retrieves capacity and reservation summary by seating category. * @param externalId - External seating plan ID. * @public * @documentationMaturity preview * @requiredField externalId * @permissionId SEATING_PLANS.READ_SEATING_PLANS * @applicableIdentity APP * @returns Response containing capacity summary by category. * @fqn com.wixpress.seating.SeatingReservationService.GetSeatingCategorySummaryByExternalId */ declare function getSeatingCategorySummaryByExternalId(externalId: string): Promise>; /** * Retrieves detailed place-level occupancy data for a seating plan. * @param externalId - External seating plan ID. * @public * @documentationMaturity preview * @requiredField externalId * @permissionId SEATING_PLANS.READ_SEATING_PLANS * @applicableIdentity APP * @returns Response containing complete seating plan and occupancy data. * @fqn com.wixpress.seating.SeatingReservationService.GetSeatingReservationSummaryByExternalId */ declare function getSeatingReservationSummaryByExternalId(externalId: string): Promise>; export { type AccountInfo, type AccountInfoMetadata, type ActionEvent, type AddressLocation, type App, type AvailablePlace, type BaseEventMetadata, type CancelSeatingPlaceReservationsRequest, type CancelSeatingPlaceReservationsResponse, type Category, type CategoryDetails, type CommonQueryWithEntityContext, type CreateSeatingReservationApplicationErrors, type CreateSeatingReservationOptions, type CreateSeatingReservationRequest, type CreateSeatingReservationResponse, type CursorPaging, type Cursors, type CustomTag, type DeleteSeatingPlaceReservationRequest, type DeleteSeatingReservationByExternalIdRequest, type DeleteSeatingReservationByExternalIdResponse, type DeleteSeatingReservationRequest, type DeleteSeatingReservationResponse, type DomainEvent, type DomainEventBodyOneOf, type Element, type ElementGroup, type ElementGroupUiProperties, type ElementUiProperties, type Empty, type EntityCreatedEvent, type EntityDeletedEvent, type EntityUpdatedEvent, type EventMetadata, type ExtendedFields, type File, type GetReservationRequest, type GetReservationResponse, type GetReservedPlacesRequest, type GetReservedPlacesResponse, type GetSeatingCategorySummaryByExternalIdRequest, type GetSeatingCategorySummaryByExternalIdResponse, type GetSeatingCategorySummaryRequest, type GetSeatingCategorySummaryResponse, type GetSeatingReservationRequest, type GetSeatingReservationResponse, type GetSeatingReservationSummaryByExternalIdRequest, type GetSeatingReservationSummaryByExternalIdResponse, type GetSeatingReservationSummaryRequest, type GetSeatingReservationSummaryResponse, Icon, type IconWithLiterals, type IdentificationData, type IdentificationDataIdOneOf, type Image, type InvalidateCache, type InvalidateCacheGetByOneOf, type ListAvailablePlacesRequest, type ListAvailablePlacesResponse, type ListReservedPlacesRequest, type ListReservedPlacesResponse, type MessageEnvelope, type MultiRowProperties, Numbering, type NumberingWithLiterals, type Page, type Pages, type Paging, type PagingMetadata, type PagingMetadataV2, type Place, type PlaceReservation, type PlaceReservationDetails, PlaceTypeEnumType, type PlaceTypeEnumTypeWithLiterals, type Places, Position, type PositionWithLiterals, type QuerySeatingReservationRequest, type QuerySeatingReservationResponse, type QuerySeatingReservationsRequest, type QuerySeatingReservationsResponse, type QueryV2, type QueryV2PagingMethodOneOf, type RegenerateSummariesRequest, type RegenerateSummariesResponse, type ReservationErrorDetails, type ReservationOptions, type ReservationsQueryBuilder, type ReservationsQueryResult, type ReservedPlace, type RestoreInfo, type RowElement, type RowElementUiProperties, type SeatReservation, type SeatingPlan, type SeatingPlanCategoriesSummaryUpdated, type SeatingPlanUiProperties, type SeatingReservation, type SeatingReservationCreatedEnvelope, type SeatingReservationDeletedEnvelope, type SeatingReservationQuery, type SeatingReservationQuerySpec, type SeatingReservationsSummary, type Section, type Sequencing, ShapeTypeEnumType, type ShapeTypeEnumTypeWithLiterals, SortOrder, type SortOrderWithLiterals, type Sorting, Type, type TypeWithLiterals, type URI, type URIs, type UnavailablePlaces, type UpdateSeatingReservationRequest, type UpdateSeatingReservationResponse, type VerticalSequencing, WebhookIdentityType, type WebhookIdentityTypeWithLiterals, createSeatingReservation, deleteSeatingReservation, getSeatingCategorySummaryByExternalId, getSeatingReservation, getSeatingReservationSummaryByExternalId, onSeatingReservationCreated, onSeatingReservationDeleted, querySeatingReservations, typedQuerySeatingReservations, utils };