import { CreateSeatingReservationRequest as CreateSeatingReservationRequest$1, CreateSeatingReservationResponse as CreateSeatingReservationResponse$1, GetSeatingReservationRequest as GetSeatingReservationRequest$1, GetSeatingReservationResponse as GetSeatingReservationResponse$1, QuerySeatingReservationsRequest as QuerySeatingReservationsRequest$1, QuerySeatingReservationsResponse as QuerySeatingReservationsResponse$1, DeleteSeatingReservationRequest as DeleteSeatingReservationRequest$1, DeleteSeatingReservationResponse as DeleteSeatingReservationResponse$1, GetSeatingCategorySummaryByExternalIdRequest as GetSeatingCategorySummaryByExternalIdRequest$1, GetSeatingCategorySummaryByExternalIdResponse as GetSeatingCategorySummaryByExternalIdResponse$1, GetSeatingReservationSummaryByExternalIdRequest as GetSeatingReservationSummaryByExternalIdRequest$1, GetSeatingReservationSummaryByExternalIdResponse as GetSeatingReservationSummaryByExternalIdResponse$1 } from './index.typings.js';
import '@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<string, any> | 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;
}
declare enum SortOrder {
    ASC = "ASC",
    DESC = "DESC"
}
/** @enumType */
type SortOrderWithLiterals = SortOrder | 'ASC' | 'DESC';
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;
}
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;
}
/** 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;
}
/** 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;
    /**
     * 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;
    /**
     * 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 {
    /**
     * 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;
    /**
     * 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;
    /**
     * 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<string, Record<string, any>>;
}
/** 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;
}
/** 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 {
    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;
}
/** 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;
};

type __PublicMethodMetaInfo<K = string, M = unknown, T = unknown, S = unknown, Q = unknown, R = unknown> = {
    getUrl: (context: any) => string;
    httpMethod: K;
    path: string;
    pathParams: M;
    __requestType: T;
    __originalRequestType: S;
    __responseType: Q;
    __originalResponseType: R;
};
declare function createSeatingReservation(): __PublicMethodMetaInfo<'POST', {}, CreateSeatingReservationRequest$1, CreateSeatingReservationRequest, CreateSeatingReservationResponse$1, CreateSeatingReservationResponse>;
declare function getSeatingReservation(): __PublicMethodMetaInfo<'GET', {
    reservationId: string;
}, GetSeatingReservationRequest$1, GetSeatingReservationRequest, GetSeatingReservationResponse$1, GetSeatingReservationResponse>;
declare function querySeatingReservations(): __PublicMethodMetaInfo<'POST', {}, QuerySeatingReservationsRequest$1, QuerySeatingReservationsRequest, QuerySeatingReservationsResponse$1, QuerySeatingReservationsResponse>;
declare function deleteSeatingReservation(): __PublicMethodMetaInfo<'DELETE', {
    id: string;
}, DeleteSeatingReservationRequest$1, DeleteSeatingReservationRequest, DeleteSeatingReservationResponse$1, DeleteSeatingReservationResponse>;
declare function getSeatingCategorySummaryByExternalId(): __PublicMethodMetaInfo<'GET', {}, GetSeatingCategorySummaryByExternalIdRequest$1, GetSeatingCategorySummaryByExternalIdRequest, GetSeatingCategorySummaryByExternalIdResponse$1, GetSeatingCategorySummaryByExternalIdResponse>;
declare function getSeatingReservationSummaryByExternalId(): __PublicMethodMetaInfo<'GET', {
    externalId: string;
}, GetSeatingReservationSummaryByExternalIdRequest$1, GetSeatingReservationSummaryByExternalIdRequest, GetSeatingReservationSummaryByExternalIdResponse$1, GetSeatingReservationSummaryByExternalIdResponse>;

export { type AccountInfo as AccountInfoOriginal, type ActionEvent as ActionEventOriginal, type App as AppOriginal, type AvailablePlace as AvailablePlaceOriginal, type CancelSeatingPlaceReservationsRequest as CancelSeatingPlaceReservationsRequestOriginal, type CancelSeatingPlaceReservationsResponse as CancelSeatingPlaceReservationsResponseOriginal, type CategoryDetails as CategoryDetailsOriginal, type Category as CategoryOriginal, type CreateSeatingReservationApplicationErrors as CreateSeatingReservationApplicationErrorsOriginal, type CreateSeatingReservationRequest as CreateSeatingReservationRequestOriginal, type CreateSeatingReservationResponse as CreateSeatingReservationResponseOriginal, type CursorPaging as CursorPagingOriginal, type Cursors as CursorsOriginal, type CustomTag as CustomTagOriginal, type DeleteSeatingPlaceReservationRequest as DeleteSeatingPlaceReservationRequestOriginal, type DeleteSeatingReservationByExternalIdRequest as DeleteSeatingReservationByExternalIdRequestOriginal, type DeleteSeatingReservationByExternalIdResponse as DeleteSeatingReservationByExternalIdResponseOriginal, type DeleteSeatingReservationRequest as DeleteSeatingReservationRequestOriginal, type DeleteSeatingReservationResponse as DeleteSeatingReservationResponseOriginal, 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 Empty as EmptyOriginal, type EntityCreatedEvent as EntityCreatedEventOriginal, type EntityDeletedEvent as EntityDeletedEventOriginal, type EntityUpdatedEvent as EntityUpdatedEventOriginal, type ExtendedFields as ExtendedFieldsOriginal, type File as FileOriginal, type GetReservationRequest as GetReservationRequestOriginal, type GetReservationResponse as GetReservationResponseOriginal, type GetReservedPlacesRequest as GetReservedPlacesRequestOriginal, type GetReservedPlacesResponse as GetReservedPlacesResponseOriginal, type GetSeatingCategorySummaryByExternalIdRequest as GetSeatingCategorySummaryByExternalIdRequestOriginal, type GetSeatingCategorySummaryByExternalIdResponse as GetSeatingCategorySummaryByExternalIdResponseOriginal, type GetSeatingCategorySummaryRequest as GetSeatingCategorySummaryRequestOriginal, type GetSeatingCategorySummaryResponse as GetSeatingCategorySummaryResponseOriginal, type GetSeatingReservationRequest as GetSeatingReservationRequestOriginal, type GetSeatingReservationResponse as GetSeatingReservationResponseOriginal, type GetSeatingReservationSummaryByExternalIdRequest as GetSeatingReservationSummaryByExternalIdRequestOriginal, type GetSeatingReservationSummaryByExternalIdResponse as GetSeatingReservationSummaryByExternalIdResponseOriginal, type GetSeatingReservationSummaryRequest as GetSeatingReservationSummaryRequestOriginal, type GetSeatingReservationSummaryResponse as GetSeatingReservationSummaryResponseOriginal, Icon as IconOriginal, type IconWithLiterals as IconWithLiteralsOriginal, type IdentificationDataIdOneOf as IdentificationDataIdOneOfOriginal, type IdentificationData as IdentificationDataOriginal, type Image as ImageOriginal, type InvalidateCacheGetByOneOf as InvalidateCacheGetByOneOfOriginal, type InvalidateCache as InvalidateCacheOriginal, type ListAvailablePlacesRequest as ListAvailablePlacesRequestOriginal, type ListAvailablePlacesResponse as ListAvailablePlacesResponseOriginal, type ListReservedPlacesRequest as ListReservedPlacesRequestOriginal, type ListReservedPlacesResponse as ListReservedPlacesResponseOriginal, type MessageEnvelope as MessageEnvelopeOriginal, type MultiRowProperties as MultiRowPropertiesOriginal, Numbering as NumberingOriginal, type NumberingWithLiterals as NumberingWithLiteralsOriginal, type Page as PageOriginal, type Pages as PagesOriginal, type PagingMetadata as PagingMetadataOriginal, type PagingMetadataV2 as PagingMetadataV2Original, type Paging as PagingOriginal, type Place as PlaceOriginal, type PlaceReservationDetails as PlaceReservationDetailsOriginal, type PlaceReservation as PlaceReservationOriginal, PlaceTypeEnumType as PlaceTypeEnumTypeOriginal, type PlaceTypeEnumTypeWithLiterals as PlaceTypeEnumTypeWithLiteralsOriginal, type Places as PlacesOriginal, Position as PositionOriginal, type PositionWithLiterals as PositionWithLiteralsOriginal, type QuerySeatingReservationRequest as QuerySeatingReservationRequestOriginal, type QuerySeatingReservationResponse as QuerySeatingReservationResponseOriginal, type QuerySeatingReservationsRequest as QuerySeatingReservationsRequestOriginal, type QuerySeatingReservationsResponse as QuerySeatingReservationsResponseOriginal, type QueryV2 as QueryV2Original, type QueryV2PagingMethodOneOf as QueryV2PagingMethodOneOfOriginal, type RegenerateSummariesRequest as RegenerateSummariesRequestOriginal, type RegenerateSummariesResponse as RegenerateSummariesResponseOriginal, type ReservationErrorDetails as ReservationErrorDetailsOriginal, type ReservationOptions as ReservationOptionsOriginal, type ReservedPlace as ReservedPlaceOriginal, type RestoreInfo as RestoreInfoOriginal, type RowElement as RowElementOriginal, type RowElementUiProperties as RowElementUiPropertiesOriginal, type SeatReservation as SeatReservationOriginal, type SeatingPlanCategoriesSummaryUpdated as SeatingPlanCategoriesSummaryUpdatedOriginal, type SeatingPlan as SeatingPlanOriginal, type SeatingPlanUiProperties as SeatingPlanUiPropertiesOriginal, type SeatingReservation as SeatingReservationOriginal, type SeatingReservationsSummary as SeatingReservationsSummaryOriginal, 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 URI as URIOriginal, type URIs as URIsOriginal, type UnavailablePlaces as UnavailablePlacesOriginal, type UpdateSeatingReservationRequest as UpdateSeatingReservationRequestOriginal, type UpdateSeatingReservationResponse as UpdateSeatingReservationResponseOriginal, type VerticalSequencing as VerticalSequencingOriginal, WebhookIdentityType as WebhookIdentityTypeOriginal, type WebhookIdentityTypeWithLiterals as WebhookIdentityTypeWithLiteralsOriginal, type __PublicMethodMetaInfo, createSeatingReservation, deleteSeatingReservation, getSeatingCategorySummaryByExternalId, getSeatingReservation, getSeatingReservationSummaryByExternalId, querySeatingReservations };