@wix/auto_sdk_seatings_seating-plan 1.0.20 → 1.0.21

package/build/internal/cjs/meta.d.ts

@@ -1,481 +1,560 @@
 import { CreateSeatingPlanRequest as CreateSeatingPlanRequest$1, CreateSeatingPlanResponse as CreateSeatingPlanResponse$1, UpdateSeatingPlanRequest as UpdateSeatingPlanRequest$1, UpdateSeatingPlanResponse as UpdateSeatingPlanResponse$1, CopySeatingPlanRequest as CopySeatingPlanRequest$1, CopySeatingPlanResponse as CopySeatingPlanResponse$1, QuerySeatingPlanRequest as QuerySeatingPlanRequest$1, QuerySeatingPlanResponse as QuerySeatingPlanResponse$1, GetSeatingPlanRequest as GetSeatingPlanRequest$1, GetSeatingPlanResponse as GetSeatingPlanResponse$1, FindSeatingPlanRequest as FindSeatingPlanRequest$1, FindSeatingPlanResponse as FindSeatingPlanResponse$1, DeleteSeatingPlanRequest as DeleteSeatingPlanRequest$1, DeleteSeatingPlanResponse as DeleteSeatingPlanResponse$1, UpdateSeatingPlanThumbnailRequest as UpdateSeatingPlanThumbnailRequest$1, UpdateSeatingPlanThumbnailResponse as UpdateSeatingPlanThumbnailResponse$1, GetSeatingPlanThumbnailRequest as GetSeatingPlanThumbnailRequest$1, GetSeatingPlanThumbnailResponse as GetSeatingPlanThumbnailResponse$1 } from './index.typings.js';
 import '@wix/sdk-types';
 
+/** 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 {
     /**
-     * Auto generated unique plan id
+     * Seating plan ID.
      * @format GUID
      * @readonly
      */
     id?: string | null;
     /**
-     * A client defined external id for cross referencing.
-     * Can reference external entities.
-     * Format: "{fqdn}:{entity guid}"
+     * 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 plan title
+     * Human-friendly seating plan title. For example, `Madison Square Garden - Main Floor`.
      * @minLength 1
      * @maxLength 120
      */
     title?: string | null;
     /**
-     * Sections of the plan. Seating plan is divided in high level sections.
+     * 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[];
     /**
-     * Categories for plan element grouping.
+     * 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[];
     /**
-     * Seating plan created timestamp.
+     * Date and time the seating plan was created.
      * @readonly
      */
     createdDate?: Date | null;
     /**
-     * Seating plan updated timestamp.
+     * Date and time the seating plan was updated.
      * @readonly
      */
     updatedDate?: Date | null;
     /**
-     * Total capacity
+     * Total number of seats across all sections and elements in the seating plan. Automatically calculated by summing element capacities.
      * @readonly
      */
     totalCapacity?: number | null;
     /**
-     * Total categories
+     * Total number of categories defined in the seating plan. Automatically calculated.
      * @readonly
      */
     totalCategories?: number | null;
     /**
-     * Places not assigned to categories
+     * Places that are not assigned to any category. These places require manual category assignment for pricing and organization.
      * @maxSize 50000
      * @readonly
      */
     uncategorizedPlaces?: Place[];
     /**
-     * A version of the seating plan
+     * 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;
-    /** Data extensions */
+    /** Additional custom fields for extending the seating plan with app-specific data. Learn more about @extended fields. */
     extendedFields?: ExtendedFields;
-    /** Seating Plan UI settings */
+    /** Visual settings for the seating plan, such as background color and opacity. Used by seating chart interfaces for rendering. */
     uiProperties?: SeatingPlanUiProperties;
     /**
-     * Element groups
+     * 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[];
 }
+/** 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 {
-    /** Unique section id */
+    /** 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
+     * Human-readable section title. For example, `Orchestra` or `Balcony`.
      * @minLength 1
      * @maxLength 20
      */
     title?: string | null;
     /**
-     * Client configuration object
+     * Client configuration object for storing additional section metadata. Read-only field maintained for backward compatibility.
      * @readonly
      */
     config?: Record<string, any> | null;
     /**
-     * Elements of the section.
+     * 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
+     * Total capacity of all elements within this section. Automatically calculated by summing element capacities.
      * @readonly
      */
     totalCapacity?: number | null;
     /**
-     * Is default section
+     * 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 {
     /**
-     * Unique element id
+     * Element ID. Must be unique within the seating plan.
      * @min 1
      */
     id?: number;
     /**
-     * User friendly title/label of the element.
+     * User-friendly title or label for the element. For example, `Row A` or `VIP Table 1`.
      * @minLength 1
      * @maxLength 50
      */
     title?: string | null;
-    /** Element type */
+    /** Type of seating element, which determines capacity limits and place generation behavior. See ElementTypeEnum for available types. */
     type?: TypeWithLiterals;
     /**
-     * Capacity. None for Shape type Element.
+     * 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;
-    /** Assigned to a category */
+    /** ID of the category this element is assigned to for pricing and organization. References a category defined in the seating plan. */
     categoryId?: number | null;
-    /** A place numbering meta data */
+    /** 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;
     /**
-     * Place override (by seq_id)
+     * 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 place sequence with overrides
+     * Final sequence of places generated for this element, including any overrides applied. Read-only field populated by the system.
      * @maxSize 200
      * @readonly
      */
     places?: Place[];
-    /** Element reservation options */
+    /** Constraints on how this element can be reserved or booked. For example, requiring the entire element to be reserved as a unit. */
     reservationOptions?: ReservationOptions;
-    /** Element UI settings */
+    /** Visual positioning and styling properties for rendering this element in a seating chart. Includes coordinates, dimensions, and styling options. */
     uiProperties?: ElementUiProperties;
-    /** Element group id */
+    /** ID of the element group this element belongs to for hierarchical organization. References an ElementGroup defined in the seating plan. */
     elementGroupId?: number | null;
-    /** Multi row element relevant for MULTI_ROW element type */
+    /** 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 {
     /**
-     * First seq element
+     * Starting value for the sequence. For example, `1` for numeric sequences or `A` for alphabetical sequences.
      * @minLength 1
      * @maxLength 4
      */
     startAt?: string;
     /**
-     * Finite generated seq of labels
+     * 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[];
-    /** If true - direction right to left. Otherwise left to right. */
+    /** 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 {
-    /** Local id of the place in the sequence */
+    /** Zero-based position of this place within the element's sequence. Used to identify the place's position for overrides. */
     index?: number;
     /**
-     * Generated composite unique id in the seating plan.
+     * 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;
     /**
-     * Unique label of the place
+     * 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;
     /**
-     * Max capacity per place
+     * 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
+     * Type of the parent element that contains this place. Inherited from the element's type.
      * @readonly
      */
     elementType?: TypeWithLiterals;
     /**
-     * Assigned category id
+     * ID of the category this place is assigned to. Inherited from element or row category assignment.
      * @readonly
      */
     categoryId?: number | null;
-    /** Place type */
+    /** Special characteristics or accessibility features of this place (standard, wheelchair, accessible, companion, obstructed, discount). */
     type?: PlaceTypeEnumTypeWithLiterals;
 }
 declare enum PlaceTypeEnumType {
+    /** Unknown place type. */
     UNKNOWN_PROPERTY = "UNKNOWN_PROPERTY",
+    /** 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 | 'UNKNOWN_PROPERTY' | 'STANDARD' | 'WHEELCHAIR' | 'ACCESSIBLE' | 'COMPANION' | 'OBSTRUCTED' | 'DISCOUNT';
+/** Configuration options that control how an element can be reserved or booked. */
 interface ReservationOptions {
-    /** Indicates whether the entire element must be reserved */
+    /** 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;
-    /** @max 1000000 */
+    /**
+     * Width of the element in the coordinate system units.
+     * @max 1000000
+     */
     width?: number | null;
-    /** @max 1000000 */
+    /**
+     * 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;
-    /** @max 1000000 */
+    /**
+     * 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[];
-    /** @max 50 */
+    /**
+     * Number of empty spaces at the top of the seating arrangement for visual spacing.
+     * @max 50
+     */
     emptyTopSeatSpaces?: number | null;
     /**
-     * needs research
+     * Text content for TEXT type shape elements. Only applicable when shape_type is TEXT.
      * @minLength 1
      * @maxLength 10000
      */
     text?: string | null;
     /**
-     * #F0F0F0
+     * Primary color in hexadecimal format. For example, `#FF0000` for red.
      * @format COLOR_HEX
      */
     color?: string | null;
     /**
-     * #F0F0F0
+     * Fill color for shapes in hexadecimal format. For example, `#00FF00` for green.
      * @format COLOR_HEX
      */
     fillColor?: string | null;
     /**
-     * #F0F0F0
+     * Border color in hexadecimal format. For example, `#0000FF` for blue.
      * @format COLOR_HEX
      */
     strokeColor?: string | null;
     /**
-     * px
+     * Border width in pixels for shape outlines.
      * @min 1
      * @max 6
      */
     strokeWidth?: number | null;
-    /** @max 100 */
+    /**
+     * 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 {
-    /** WixMedia image ID. */
+    /** Image ID from Wix Media Manager. */
     id?: string;
     /**
-     * Original image height.
+     * Original image height in pixels.
      * @readonly
      */
     height?: number;
     /**
-     * Original image width.
+     * Original image width in pixels.
      * @readonly
      */
     width?: number;
     /**
-     * WixMedia image URI.
+     * 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 of the multi row element
+     * Individual rows within the multi-row element. Each row has its own capacity, sequencing, and category assignment.
      * @maxSize 1000
      */
     rows?: RowElement[];
-    /** Meta data for vertical labeling */
+    /** Configuration for labeling rows vertically (e.g., Row A, Row B, Row C). Defines how row labels are generated. */
     verticalSequencing?: VerticalSequencing;
     /**
-     * Row spacing
+     * Vertical spacing between rows in the multi-row element. Measured in coordinate system units.
      * @min 1
      * @max 60
      */
     rowSpacing?: number | null;
     /**
-     * Amount of seats in the row
+     * Number of seats per row in the multi-row element.
      * @max 50
      */
     seatAmount?: number | null;
 }
+/** An individual row within a multi-row element, with its own capacity, sequencing, and category assignment. */
 interface RowElement {
     /**
-     * Unique row id
+     * Row ID. Must be unique across all multi-row elements in the seating plan.
      * @min 1
      */
     id?: number;
     /**
-     * User friendly title/label of the row
+     * User-friendly title or label for this row. For example, `Row A` or `Front Row`.
      * @minLength 1
      * @maxLength 50
      */
     title?: string | null;
     /**
-     * Row capacity
+     * Number of seats in this row. Maximum 50,000 per row.
      * @min 1
      * @max 50000
      */
     capacity?: number | null;
-    /** Assigned to a category */
+    /** Category assignment for this row, which can override the parent element's category. References a category defined in the seating plan. */
     categoryId?: number | null;
-    /** A place numbering meta data for a single row */
+    /** Configuration for generating seat labels within this row. Defines numbering scheme and starting position. */
     sequencing?: Sequencing;
-    /** Row UI settings */
+    /** 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 {
     /**
-     * Relative x position to the parent element
+     * Horizontal position relative to the parent multi-row element's coordinate system.
      * @min -1000000
      * @max 1000000
      */
     relativeX?: number | null;
     /**
-     * Width of the row
+     * Width of this row in coordinate system units.
      * @max 1000000
      */
     width?: number | null;
     /**
-     * Amount of seats in the row
+     * Number of seats in this row. Overrides the capacity field when specified.
      * @max 50
      */
     seatAmount?: number | null;
     /**
-     * Seat spacing
+     * Spacing between seats in this row.
      * @min 1
      * @max 60
      */
     seatSpacing?: number | null;
-    /** Label position */
+    /** 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;
-    /** Seat numbering */
+    /** 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 {
     /**
-     * First seq element
+     * Starting value for row labeling. For example, `A` for alphabetical sequences or `1` for numeric sequences.
      * @minLength 1
      * @maxLength 4
      */
     startAt?: string;
-    /** Row numbering */
+    /** Numbering scheme for row labels (numeric, alphabetical, or odd/even). */
     rowNumbering?: NumberingWithLiterals;
-    /** If true - direction bottom to top. Otherwise top to bottom. */
+    /** 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 {
     /**
-     * Local category id within the seating plan
+     * Category ID. Must be unique within the seating plan.
      * @min 1
      */
     id?: number;
     /**
-     * A client defined external id for cross referencing.
-     * Can reference external entities.
-     * Format: "{entity_fqdn}:{entity_id}"
+     * Client-defined external ID for cross-referencing with pricing or ticketing systems. Format: `{entity_fqdn}:{entity_id}`.
      * @minLength 1
      * @maxLength 100
      */
     externalId?: string | null;
     /**
-     * Category label
+     * Human-readable category name, such as `VIP`, `General Admission`, or `Student Discount`.
      * @minLength 1
      * @maxLength 120
      */
     title?: string;
     /**
-     * Client configuration object
+     * Client configuration object for storing additional category metadata. Read-only field maintained for backward compatibility.
      * @readonly
      */
     config?: Record<string, any> | null;
     /**
-     * Total capacity
+     * Total capacity of all places assigned to this category. Automatically calculated by summing place capacities.
      * @readonly
      */
     totalCapacity?: number | null;
     /**
-     * Possible places
+     * All places that are assigned to this category. Populated when using the CATEGORIES fieldset.
      * @maxSize 50000
      * @readonly
      */
@@ -492,104 +571,124 @@ interface ExtendedFields {
      */
     namespaces?: Record<string, Record<string, any>>;
 }
+/** Visual styling properties for the overall seating plan background and appearance. */
 interface SeatingPlanUiProperties {
     /**
-     * #F0F0F0
+     * Background color in hexadecimal format. For example, `#F0F0F0` for light gray.
      * @format COLOR_HEX
      */
     backgroundColor?: string | null;
-    /** @max 100 */
+    /**
+     * 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 {
     /**
-     * Unique element group id
+     * Element group ID. Must be unique within the seating plan.
      * @min 1
      */
     id?: number;
-    /** Parent group id */
+    /** ID of the parent group for creating nested group hierarchies. References another ElementGroup in the same seating plan. */
     parentElementGroupId?: number | null;
-    /** Element group UI settings */
+    /** 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 {
     /**
-     * x position of the group
+     * Horizontal position coordinate of the group container.
      * @min -1000000
      * @max 1000000
      */
     x?: number | null;
     /**
-     * y position of the group
+     * Vertical position coordinate of the group container.
      * @min -1000000
      * @max 1000000
      */
     y?: number | null;
     /**
-     * width of the group
+     * Width of the group bounding box in coordinate system units.
      * @max 1000000
      */
     width?: number | null;
     /**
-     * height of the group
+     * Height of the group bounding box in coordinate system units.
      * @max 1000000
      */
     height?: number | null;
     /**
-     * rotation angle of the group
+     * Rotation angle of the group in degrees. Applied to all elements within the group.
      * @min -180
      * @max 180
      */
     rotationAngle?: number | null;
 }
+/** Request to create a new seating plan. */
 interface CreateSeatingPlanRequest {
-    /** A plan to be created */
+    /** Seating plan to create. Must include at least one section with `id = 0` as the default section. */
     plan: SeatingPlan;
 }
+/** Response containing the created seating plan. */
 interface CreateSeatingPlanResponse {
-    /** The created plan */
+    /** Created seating plan with generated ID, timestamps, and calculated totals. */
     plan?: SeatingPlan;
 }
+/** Error details when seating plan or element capacity limits are exceeded. */
+interface CapacityExceededViolation {
+    /** Maximum allowed capacity that was exceeded. Represents the system limit for the specific context. */
+    maxCapacity?: number;
+    /** Invalid capacity value that was provided in the request. */
+    capacity?: number;
+    /** ID of the element where the capacity violation occurred. Only present for element-level violations. */
+    elementId?: number | null;
+}
+/** Request to update an existing seating plan. */
 interface UpdateSeatingPlanRequest {
-    /** The plan updates */
+    /** Seating plan updates to apply. Must include the plan ID for identification. */
     plan?: SeatingPlan;
-    /** A set of field paths, specifying which parts of seating plan to update */
+    /** Field mask specifying which parts of the seating plan to update. For example, `sections.elements.ui_properties` to update only visual properties. */
     fields?: string[];
 }
+/** Response containing the updated seating plan. */
 interface UpdateSeatingPlanResponse {
-    /** The updated plan */
+    /** Updated seating plan with incremented version and recalculated totals. */
     plan?: SeatingPlan;
 }
 interface CopySeatingPlanRequest {
     /**
-     * The id of the plan to be copied
+     * ID of the seating plan to be copied.
      * @format GUID
      */
     id: string | null;
     /**
-     * New plan title
+     * Title for the new copied seating plan. Must be different from the original.
      * @minLength 1
      * @maxLength 120
      */
     title: string | null;
     /**
-     * Format: "{fqdn}:{entity guid}"
+     * External ID for the new copied seating plan. Format: `{fqdn}:{entity_guid}`. Must be unique.
      * @minLength 1
      * @maxLength 100
      */
     externalId: string | null;
 }
 interface CopySeatingPlanResponse {
-    /** The copied plan */
+    /** Copied seating plan with new ID, specified title, and all duplicated content. */
     plan?: SeatingPlan;
 }
+/** Request to query multiple seating plans with filtering and projection options. */
 interface QuerySeatingPlanRequest {
     /**
      * Generic query object
      * Possible fieldsets: "elements", "categories", "places", "config".
      */
     query: QueryV2;
-    /** A fieldset for the response */
+    /** Fieldsets to include in the response. Available options: ELEMENTS, CATEGORIES, PLACES, CONFIG, ELEMENT_GROUPS. */
     fieldset?: FieldsetWithLiterals[];
 }
 interface QueryV2 extends QueryV2PagingMethodOneOf {
@@ -657,27 +756,35 @@ interface CursorPaging {
      */
     cursor?: string | null;
 }
+/** Available fieldsets for seating plan projections. */
 declare enum Fieldset {
+    /** Include section elements with their configurations and generated places. */
     ELEMENTS = "ELEMENTS",
+    /** Include categories with their assigned places and capacity totals. */
     CATEGORIES = "CATEGORIES",
+    /** Include all generated places across all elements and sections. */
     PLACES = "PLACES",
+    /** Include legacy configuration objects for backward compatibility. */
     CONFIG = "CONFIG",
+    /** Include element groups for hierarchical organization and UI rendering. */
     ELEMENT_GROUPS = "ELEMENT_GROUPS"
 }
 /** @enumType */
 type FieldsetWithLiterals = Fieldset | 'ELEMENTS' | 'CATEGORIES' | 'PLACES' | 'CONFIG' | 'ELEMENT_GROUPS';
+/** Response containing matching seating plans. */
 interface QuerySeatingPlanResponse {
-    /** Plan results */
+    /** Seating plans matching the query criteria with requested fieldsets included. */
     plans?: SeatingPlan[];
 }
+/** Request to retrieve a specific seating plan by ID. */
 interface GetSeatingPlanRequest {
     /**
-     * The id of the plan
+     * Seating plan ID to retrieve.
      * @format GUID
      */
     id: string | null;
     /**
-     * A fieldset for the response
+     * Deprecated. Use `fieldsets` parameter instead.
      * @deprecated
      */
     fieldset?: FieldsetWithLiterals[];
@@ -686,26 +793,26 @@ interface GetSeatingPlanRequest {
      * Possible values: "elements", "categories", "places", "config".
      */
     fieldsets?: string[];
-    /** Seating Plan Mask */
+    /** Seating plan mask for filtering specific places by their IDs. Useful for retrieving only relevant places. */
     seatingPlanMask?: SeatingPlanMask;
 }
 interface SeatingPlanMask {
     /**
-     * Filter seating plan by place ids
+     * Filter seating plan by place IDs. For example, `0-1-A`, `0-2-B`. Use this to retrieve only specific places from large seating plans.
      * @minLength 5
      * @maxLength 11
      */
     placeId?: string[];
 }
 interface GetSeatingPlanResponse {
-    /** The plan */
+    /** Retrieved seating plan with requested fieldsets and filtered places. */
     plan?: SeatingPlan;
 }
 interface FindSeatingPlanRequest {
-    /** The filter of the plan */
+    /** Filter criteria for finding the seating plan. Use standard WQL filter format. */
     filter: Record<string, any> | null;
     /**
-     * A fieldset for the response
+     * Deprecated. Use `fieldsets` parameter instead.
      * @deprecated
      */
     fieldset?: FieldsetWithLiterals[];
@@ -714,48 +821,278 @@ interface FindSeatingPlanRequest {
      * Possible values: "elements", "categories", "places", "config".
      */
     fieldsets?: string[];
-    /** Seating Plan Mask */
+    /** Seating plan mask for filtering specific places by their IDs. */
     seatingPlanMask?: SeatingPlanMask;
 }
 interface FindSeatingPlanResponse {
-    /** The plan */
+    /** Found seating plan matching the filter criteria, or empty if no match found. */
     plan?: SeatingPlan;
 }
 interface DeleteSeatingPlanRequest {
     /**
-     * The id of the plan
+     * ID of the seating plan to delete.
      * @format GUID
      */
     id: string | null;
 }
 interface DeleteSeatingPlanResponse {
-    /** Deleted plan */
+    /** Deleted seating plan data for reference before deletion. */
+    plan?: SeatingPlan;
+}
+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 {
+    entityAsJson?: string;
+    /** Indicates the event was triggered by a restore-from-trashbin operation for a previously deleted entity */
+    restoreInfo?: RestoreInfo;
+}
+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.
+     */
+    currentEntityAsJson?: string;
+}
+interface EntityDeletedEvent {
+    /** Entity that was deleted. */
+    deletedEntityAsJson?: string | null;
+}
+interface ActionEvent {
+    bodyAsJson?: string;
+}
+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;
+}
+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 SaveSeatingPlanVersionRequest {
+    /** Seating plan version to be saved as a draft. Must include plan ID for existing plans. */
+    plan?: SeatingPlan;
+    /**
+     * Parent version of the plan. Use this field to override history of plan versions.
+     * @min 1
+     */
+    parentVersion?: string | null;
+}
+interface SaveSeatingPlanVersionResponse {
+    /** Saved seating plan version with incremented version number and updated timestamps. */
+    plan?: SeatingPlan;
+}
+interface QuerySeatingPlanVersionsRequest {
+    /** Query criteria for filtering seating plan versions. Supports standard WQL filtering, sorting, and paging. */
+    query?: QueryV2;
+}
+interface QuerySeatingPlanVersionsResponse {
+    /** Seating plan versions matching the query criteria, ordered by version number. */
+    plans?: SeatingPlan[];
+    /** Paging metadata for the query results including total count and cursor information. */
+    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;
+}
+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;
+}
+interface DiscardSeatingPlanVersionsRequest {
+    /**
+     * Seating plan ID to discard versions for.
+     * @format GUID
+     */
+    seatingPlanId?: string | null;
+    /** Version from which all higher versions will be discarded. This version and lower versions are preserved. */
+    version?: string | null;
+}
+interface DiscardSeatingPlanVersionsResponse {
+}
+interface RestoreSeatingPlanRequest {
+    /**
+     * Seating plan ID to restore.
+     * @format GUID
+     */
+    seatingPlanId?: string | null;
+    /** Version to which the seating plan should be restored. This becomes the basis for the new current version. */
+    version?: string | null;
+}
+interface RestoreSeatingPlanResponse {
+    /** Restored seating plan with the specified version as the new current version and incremented version number. */
     plan?: SeatingPlan;
 }
 interface UpdateSeatingPlanThumbnailRequest {
+    /** Thumbnail to update with new image data. */
     thumbnail: SeatingPlanThumbnail;
 }
+/** Thumbnail image data for a seating plan. */
 interface SeatingPlanThumbnail {
     /**
+     * Seating plan ID that this thumbnail represents.
      * @format GUID
      * @readonly
      */
     id?: string | null;
+    /** Thumbnail image data or reference. Format depends on implementation (base64, URL, or image ID). */
     img?: string | null;
 }
 interface UpdateSeatingPlanThumbnailResponse {
+    /** Updated thumbnail with confirmation of changes. */
     thumbnail?: SeatingPlanThumbnail;
 }
 interface GetSeatingPlanThumbnailRequest {
     /**
+     * Seating plan ID to retrieve thumbnail for.
      * @format GUID
      * @readonly
      */
     id: string | null;
 }
 interface GetSeatingPlanThumbnailResponse {
+    /** Retrieved thumbnail data, or empty if no thumbnail exists. */
     thumbnail?: SeatingPlanThumbnail;
 }
+/** @docsIgnore */
+type CreateSeatingPlanApplicationErrors = {
+    code?: 'PLAN_MAX_CAPACITY_EXCEEDED';
+    description?: string;
+    data?: CapacityExceededViolation;
+} | {
+    code?: 'ELEMENT_MAX_CAPACITY_EXCEEDED';
+    description?: string;
+    data?: CapacityExceededViolation;
+};
+/** @docsIgnore */
+type UpdateSeatingPlanApplicationErrors = {
+    code?: 'INVALID_FIELD_MASK';
+    description?: string;
+    data?: Record<string, any>;
+};
 
 type __PublicMethodMetaInfo<K = string, M = unknown, T = unknown, S = unknown, Q = unknown, R = unknown> = {
     getUrl: (context: any) => string;
@@ -781,4 +1118,4 @@ declare function deleteSeatingPlan(): __PublicMethodMetaInfo<'DELETE', {
 declare function updateSeatingPlanThumbnail(): __PublicMethodMetaInfo<'POST', {}, UpdateSeatingPlanThumbnailRequest$1, UpdateSeatingPlanThumbnailRequest, UpdateSeatingPlanThumbnailResponse$1, UpdateSeatingPlanThumbnailResponse>;
 declare function getSeatingPlanThumbnail(): __PublicMethodMetaInfo<'GET', {}, GetSeatingPlanThumbnailRequest$1, GetSeatingPlanThumbnailRequest, GetSeatingPlanThumbnailResponse$1, GetSeatingPlanThumbnailResponse>;
 
-export { type __PublicMethodMetaInfo, copySeatingPlan, createSeatingPlan, deleteSeatingPlan, findSeatingPlan, getSeatingPlan, getSeatingPlanThumbnail, querySeatingPlan, updateSeatingPlan, updateSeatingPlanThumbnail };
+export { type ActionEvent as ActionEventOriginal, type CapacityExceededViolation as CapacityExceededViolationOriginal, type Category as CategoryOriginal, type CopySeatingPlanRequest as CopySeatingPlanRequestOriginal, type CopySeatingPlanResponse as CopySeatingPlanResponseOriginal, type CreateSeatingPlanApplicationErrors as CreateSeatingPlanApplicationErrorsOriginal, type CreateSeatingPlanRequest as CreateSeatingPlanRequestOriginal, type CreateSeatingPlanResponse as CreateSeatingPlanResponseOriginal, type CursorPaging as CursorPagingOriginal, type Cursors as CursorsOriginal, type DeleteSeatingPlanRequest as DeleteSeatingPlanRequestOriginal, type DeleteSeatingPlanResponse as DeleteSeatingPlanResponseOriginal, type DiscardSeatingPlanVersionsRequest as DiscardSeatingPlanVersionsRequestOriginal, type DiscardSeatingPlanVersionsResponse as DiscardSeatingPlanVersionsResponseOriginal, type DomainEventBodyOneOf as DomainEventBodyOneOfOriginal, type DomainEvent as DomainEventOriginal, type ElementGroup as ElementGroupOriginal, type ElementGroupUiProperties as ElementGroupUiPropertiesOriginal, type Element as ElementOriginal, type ElementUiProperties as ElementUiPropertiesOriginal, type EntityCreatedEvent as EntityCreatedEventOriginal, type EntityDeletedEvent as EntityDeletedEventOriginal, type EntityUpdatedEvent as EntityUpdatedEventOriginal, type ExtendedFields as ExtendedFieldsOriginal, Fieldset as FieldsetOriginal, type FieldsetWithLiterals as FieldsetWithLiteralsOriginal, type FindSeatingPlanRequest as FindSeatingPlanRequestOriginal, type FindSeatingPlanResponse as FindSeatingPlanResponseOriginal, type GetSeatingPlanRequest as GetSeatingPlanRequestOriginal, type GetSeatingPlanResponse as GetSeatingPlanResponseOriginal, type GetSeatingPlanThumbnailRequest as GetSeatingPlanThumbnailRequestOriginal, type GetSeatingPlanThumbnailResponse as GetSeatingPlanThumbnailResponseOriginal, Icon as IconOriginal, type IconWithLiterals as IconWithLiteralsOriginal, type IdentificationDataIdOneOf as IdentificationDataIdOneOfOriginal, type IdentificationData as IdentificationDataOriginal, type Image as ImageOriginal, type MessageEnvelope as MessageEnvelopeOriginal, type MultiRowProperties as MultiRowPropertiesOriginal, Numbering as NumberingOriginal, type NumberingWithLiterals as NumberingWithLiteralsOriginal, type PagingMetadataV2 as PagingMetadataV2Original, type Paging as PagingOriginal, type Place as PlaceOriginal, PlaceTypeEnumType as PlaceTypeEnumTypeOriginal, type PlaceTypeEnumTypeWithLiterals as PlaceTypeEnumTypeWithLiteralsOriginal, Position as PositionOriginal, type PositionWithLiterals as PositionWithLiteralsOriginal, type QuerySeatingPlanRequest as QuerySeatingPlanRequestOriginal, type QuerySeatingPlanResponse as QuerySeatingPlanResponseOriginal, type QuerySeatingPlanVersionsRequest as QuerySeatingPlanVersionsRequestOriginal, type QuerySeatingPlanVersionsResponse as QuerySeatingPlanVersionsResponseOriginal, type QueryV2 as QueryV2Original, type QueryV2PagingMethodOneOf as QueryV2PagingMethodOneOfOriginal, type ReservationOptions as ReservationOptionsOriginal, type RestoreInfo as RestoreInfoOriginal, type RestoreSeatingPlanRequest as RestoreSeatingPlanRequestOriginal, type RestoreSeatingPlanResponse as RestoreSeatingPlanResponseOriginal, type RowElement as RowElementOriginal, type RowElementUiProperties as RowElementUiPropertiesOriginal, type SaveSeatingPlanVersionRequest as SaveSeatingPlanVersionRequestOriginal, type SaveSeatingPlanVersionResponse as SaveSeatingPlanVersionResponseOriginal, type SeatingPlanMask as SeatingPlanMaskOriginal, type SeatingPlan as SeatingPlanOriginal, type SeatingPlanThumbnail as SeatingPlanThumbnailOriginal, type SeatingPlanUiProperties as SeatingPlanUiPropertiesOriginal, type Section as SectionOriginal, type Sequencing as SequencingOriginal, ShapeTypeEnumType as ShapeTypeEnumTypeOriginal, type ShapeTypeEnumTypeWithLiterals as ShapeTypeEnumTypeWithLiteralsOriginal, SortOrder as SortOrderOriginal, type SortOrderWithLiterals as SortOrderWithLiteralsOriginal, type Sorting as SortingOriginal, Type as TypeOriginal, type TypeWithLiterals as TypeWithLiteralsOriginal, type UpdateSeatingPlanApplicationErrors as UpdateSeatingPlanApplicationErrorsOriginal, type UpdateSeatingPlanRequest as UpdateSeatingPlanRequestOriginal, type UpdateSeatingPlanResponse as UpdateSeatingPlanResponseOriginal, type UpdateSeatingPlanThumbnailRequest as UpdateSeatingPlanThumbnailRequestOriginal, type UpdateSeatingPlanThumbnailResponse as UpdateSeatingPlanThumbnailResponseOriginal, type VerticalSequencing as VerticalSequencingOriginal, WebhookIdentityType as WebhookIdentityTypeOriginal, type WebhookIdentityTypeWithLiterals as WebhookIdentityTypeWithLiteralsOriginal, type __PublicMethodMetaInfo, copySeatingPlan, createSeatingPlan, deleteSeatingPlan, findSeatingPlan, getSeatingPlan, getSeatingPlanThumbnail, querySeatingPlan, updateSeatingPlan, updateSeatingPlanThumbnail };