Reference

BackstageClient.occurrenceSeating

BackstageClient.occurrenceSeating in @ticketlayer/backstage.

@ticketlayer/backstage / BackstageClient / occurrenceSeating

occurrenceSeating: {
  bestAvailable: (occurrenceId: string, request: {
     accessible?: number;
     aisle?: boolean;
     areas?: string[];
     categories?: string[];
     maxPriceEach?: number;
     maxTotal?: number;
     options?: number;
     priceHard?: boolean;
     quantity: number;
     sections?: string[];
     sessionId?: string;
     tickets?: {
        quantity: number;
        ticketTypeId: string;
     }[];
     together?: "row" | "rows" | "any";
     withinHard?: boolean;
   } & {
     excludeSeats?: number[];
   }, requestOptions?: RequestOptions) => Promise<{
     options: {
        aisle: boolean;
        areaId: string;
        categoryId: string | null;
        currency: string | null;
        distance: number;
        each: number;
        facet: string;
        facts: {
           closerBy?: number;
           furtherBy?: number;
           savingEach?: number;
        };
        reasons: string[];
        rows: string[];
        seats: {
           label: string;
           number: string;
           row: string;
           seat: number;
           section: string;
           ticketTypeId: string | null;
        }[];
        sectionId: string;
        sectionName: string;
        split: number;
        total: number;
     }[];
     planVersion: string | null;
     statusVersion: number;
  }>;
  createAllocation: (occurrenceId: string, request: {
     holderType: "agent" | "promoter";
     name: string;
     notes?: any;
     releaseAt?: any;
     salesChannelId?: any;
     seats: number[];
   }, requestOptions?: RequestOptions) => Promise<{
     createdAt: string;
     createdBy: string | null;
     holderType: "agent" | "promoter";
     id: string;
     name: string;
     notes: string | null;
     releaseAt: string | null;
     releasedAt: string | null;
     releasedBy: string | null;
     releaseReason: "scheduled" | "staff" | null;
     salesChannelId: string | null;
     seats: number[];
     sold: number[];
  }>;
  createHold: (occurrenceId: string, request: {
     name: string;
     reason?: any;
     seats: number[];
   }, requestOptions?: RequestOptions) => Promise<{
     createdAt: string;
     createdBy: string | null;
     id: string;
     name: string;
     reason: string | null;
     releasedAt: string | null;
     seats: number[];
  }>;
  createSeatmapToken: (occurrenceId: string, requestOptions?: RequestOptions) => Promise<{
     base: string | null;
     channelId: string;
     expiresAt: string;
     planVersion: string;
     scopes: string[];
     token: string;
  }>;
  getSeatmap: (occurrenceId: string, requestOptions?: RequestOptions) => Promise<{
     eventPlanId: string;
     hasModel: boolean;
     hasStills: boolean;
     hasViews: boolean;
     maxTickets: number;
     overlay: string;
     overview: string;
     planVersion: string;
     seatCount: number;
     singleSeatGap: "warn" | "confirm";
     venuePlanVersionId: string;
  }>;
  getState: (occurrenceId: string, options?: {
     cartId?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     allocations: {
        holderType: "agent" | "promoter";
        id: string;
        name: string;
        releaseAt: string | null;
        salesChannelId: string | null;
        seats: number[];
     }[];
     comp: number[];
     eventPlanId: string;
     holds: {
        id: string;
        name: string;
        seats: number[];
     }[];
     killed: number[];
     killsReleased: number[];
     notOnPlan: number[];
     occurrenceId: string;
     reserved: {
        mine: number[];
        others: number[];
     };
     seatCount: number;
     sold: number[];
     statusVersion: number;
     venuePlanVersionId: string;
  }>;
  listAllocations: (occurrenceId: string, options?: {
     includeReleased?: "true" | "false";
   }, requestOptions?: RequestOptions) => Promise<{
     createdAt: string;
     createdBy: string | null;
     holderType: "agent" | "promoter";
     id: string;
     name: string;
     notes: string | null;
     releaseAt: string | null;
     releasedAt: string | null;
     releasedBy: string | null;
     releaseReason: "scheduled" | "staff" | null;
     salesChannelId: string | null;
     seats: number[];
     sold: number[];
  }[]>;
  listHolds: (occurrenceId: string, requestOptions?: RequestOptions) => Promise<{
     createdAt: string;
     createdBy: string | null;
     id: string;
     name: string;
     reason: string | null;
     releasedAt: string | null;
     seats: number[];
  }[]>;
  releaseAllocation: (occurrenceId: string, allocationId: string, request: {
     seats?: number[];
   }, requestOptions?: RequestOptions) => Promise<{
     createdAt: string;
     createdBy: string | null;
     holderType: "agent" | "promoter";
     id: string;
     name: string;
     notes: string | null;
     releaseAt: string | null;
     releasedAt: string | null;
     releasedBy: string | null;
     releaseReason: "scheduled" | "staff" | null;
     salesChannelId: string | null;
     seats: number[];
     sold: number[];
  }>;
  releaseHold: (occurrenceId: string, holdId: string, request: {
     seats?: number[];
   }, requestOptions?: RequestOptions) => Promise<{
     createdAt: string;
     createdBy: string | null;
     id: string;
     name: string;
     reason: string | null;
     releasedAt: string | null;
     seats: number[];
  }>;
  releaseKills: (occurrenceId: string, request: {
     reason?: any;
     seats: number[];
   }, requestOptions?: RequestOptions) => Promise<{
     eventPlanId: string;
     killsReleased: number[];
     occurrenceId: string;
  }>;
  restoreKills: (occurrenceId: string, request: {
     seats: number[];
   }, requestOptions?: RequestOptions) => Promise<{
     eventPlanId: string;
     killsReleased: number[];
     occurrenceId: string;
  }>;
  updateAllocation: (occurrenceId: string, allocationId: string, request: {
     name?: string;
     notes?: any;
     releaseAt?: any;
     salesChannelId?: any;
   }, requestOptions?: RequestOptions) => Promise<{
     createdAt: string;
     createdBy: string | null;
     holderType: "agent" | "promoter";
     id: string;
     name: string;
     notes: string | null;
     releaseAt: string | null;
     releasedAt: string | null;
     releasedBy: string | null;
     releaseReason: "scheduled" | "staff" | null;
     salesChannelId: string | null;
     seats: number[];
     sold: number[];
  }>;
};

Defined in: client.ts:4438

Occurrence Seating methods

bestAvailable()#

bestAvailable: (occurrenceId: string, request: {
  accessible?: number;
  aisle?: boolean;
  areas?: string[];
  categories?: string[];
  maxPriceEach?: number;
  maxTotal?: number;
  options?: number;
  priceHard?: boolean;
  quantity: number;
  sections?: string[];
  sessionId?: string;
  tickets?: {
     quantity: number;
     ticketTypeId: string;
  }[];
  together?: "row" | "rows" | "any";
  withinHard?: boolean;
} & {
  excludeSeats?: number[];
}, requestOptions?: RequestOptions) => Promise<{
  options: {
     aisle: boolean;
     areaId: string;
     categoryId: string | null;
     currency: string | null;
     distance: number;
     each: number;
     facet: string;
     facts: {
        closerBy?: number;
        furtherBy?: number;
        savingEach?: number;
     };
     reasons: string[];
     rows: string[];
     seats: {
        label: string;
        number: string;
        row: string;
        seat: number;
        section: string;
        ticketTypeId: string | null;
     }[];
     sectionId: string;
     sectionName: string;
     split: number;
     total: number;
  }[];
  planVersion: string | null;
  statusVersion: number;
}>;

Find the best available seats (staff) Best available for the box office: the same engine and request as the sales surface, on the channel X-Ticketlayer-Channel names, else the box office channel listing the event, with that channel's selling rules (the box office sees five options by default). Nothing is held: reserve an option through the staff cart's POST /cart/{cartId}/seats. excludeSeats (staff only) treats the seats it names as taken for this request alone, and such an answer is never cached; 400 for an index outside the version. 422 SEAT_LIMIT over the channel's maxTickets.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`request`	{ `accessible?`: `number`; `aisle?`: `boolean`; `areas?`: `string`[]; `categories?`: `string`[]; `maxPriceEach?`: `number`; `maxTotal?`: `number`; `options?`: `number`; `priceHard?`: `boolean`; `quantity`: `number`; `sections?`: `string`[]; `sessionId?`: `string`; `tickets?`: { `quantity`: `number`; `ticketTypeId`: `string`; }[]; `together?`: `"row"` \| `"rows"` \| `"any"`; `withinHard?`: `boolean`; } & { `excludeSeats?`: `number`[]; }
`requestOptions?`	`RequestOptions`

Returns#

Promise<{ options: { aisle: boolean; areaId: string; categoryId: string | null; currency: string | null; distance: number; each: number; facet: string; facts: { closerBy?: number; furtherBy?: number; savingEach?: number; }; reasons: string[]; rows: string[]; seats: { label: string; number: string; row: string; seat: number; section: string; ticketTypeId: string | null; }[]; sectionId: string; sectionName: string; split: number; total: number; }[]; planVersion: string | null; statusVersion: number; }>

Operation Id#

getOccurrenceBestAvailable

createAllocation()#

createAllocation: (occurrenceId: string, request: {
  holderType: "agent" | "promoter";
  name: string;
  notes?: any;
  releaseAt?: any;
  salesChannelId?: any;
  seats: number[];
}, requestOptions?: RequestOptions) => Promise<{
  createdAt: string;
  createdBy: string | null;
  holderType: "agent" | "promoter";
  id: string;
  name: string;
  notes: string | null;
  releaseAt: string | null;
  releasedAt: string | null;
  releasedBy: string | null;
  releaseReason: "scheduled" | "staff" | null;
  salesChannelId: string | null;
  seats: number[];
  sold: number[];
}>;

Allocate seats to an agent or a promoter Give a block of seats (by seat index) to an agent or a promoter under a name, all or none: each must be a seat the event plan sells, not killed here, and free now (409 SEAT_UNAVAILABLE lists the others). An allocated seat is sellable only on salesChannelId (none: on no channel) until released, by staff or at releaseAt; a reservation of one that lapses returns it to the allocation. Gated as a hold is.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`request`	{ `holderType`: `"agent"` \| `"promoter"`; `name`: `string`; `notes?`: `any`; `releaseAt?`: `any`; `salesChannelId?`: `any`; `seats`: `number`[]; }
`request.holderType`	`"agent"` \| `"promoter"`
`request.name?`	`string`
`request.notes?`	`any`
`request.releaseAt?`	`any`
`request.salesChannelId?`	`any`
`request.seats?`	`number`[]
`requestOptions?`	`RequestOptions`

Returns#

Promise<{ createdAt: string; createdBy: string | null; holderType: "agent" | "promoter"; id: string; name: string; notes: string | null; releaseAt: string | null; releasedAt: string | null; releasedBy: string | null; releaseReason: "scheduled" | "staff" | null; salesChannelId: string | null; seats: number[]; sold: number[]; }>

Operation Id#

createOccurrenceSeatAllocation

createHold()#

createHold: (occurrenceId: string, request: {
  name: string;
  reason?: any;
  seats: number[];
}, requestOptions?: RequestOptions) => Promise<{
  createdAt: string;
  createdBy: string | null;
  id: string;
  name: string;
  reason: string | null;
  releasedAt: string | null;
  seats: number[];
}>;

Hold seats under a name Hold seats of the occurrence (by seat index) under a name, all or none: each must be a seat of the plan, not killed, and free now (409 SEAT_UNAVAILABLE lists the others). A held seat is not sold on any channel until released.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`request`	{ `name`: `string`; `reason?`: `any`; `seats`: `number`[]; }
`request.name`	`string`
`request.reason?`	`any`
`request.seats?`	`number`[]
`requestOptions?`	`RequestOptions`

Returns#

Promise<{ createdAt: string; createdBy: string | null; id: string; name: string; reason: string | null; releasedAt: string | null; seats: number[]; }>

Operation Id#

createOccurrenceSeatHold

createSeatmapToken()#

createSeatmapToken: (occurrenceId: string, requestOptions?: RequestOptions) => Promise<{
  base: string | null;
  channelId: string;
  expiresAt: string;
  planVersion: string;
  scopes: string[];
  token: string;
}>;

Mint a staff seat map token The seat map token Box Office reads the seat map with (seated selling contract v1, sections 4 and 6.3): every scope and stf: true, for the occurrence's current seat map (its pv) and a channel: the one X-Ticketlayer-Channel names, else the organisation's box office channel listing the event. Fifteen minutes; no Origin binding (a server-side mint). 404 SEATMAP_NOT_PUBLISHED before the seat map is published, 503 SEATMAP_UNAVAILABLE when the deployment has no SEATMAP_TOKEN_KEYS.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`requestOptions?`	`RequestOptions`

Returns#

Promise<{ base: string | null; channelId: string; expiresAt: string; planVersion: string; scopes: string[]; token: string; }>

Operation Id#

createOccurrenceSeatmapToken

getSeatmap()#

getSeatmap: (occurrenceId: string, requestOptions?: RequestOptions) => Promise<{
  eventPlanId: string;
  hasModel: boolean;
  hasStills: boolean;
  hasViews: boolean;
  maxTickets: number;
  overlay: string;
  overview: string;
  planVersion: string;
  seatCount: number;
  singleSeatGap: "warn" | "confirm";
  venuePlanVersionId: string;
}>;

Get an occurrence's seat map pointer (staff) The sales surface's seat map pointer for Box Office (seated selling contract v1, 6.1), with the same body: which published seat map the occurrence sells from (planVersion, the overview and the event plan's overlay, relative to <pv>/), the seat count, which media exist, and the maxTickets and singleSeatGap rule of the channel X-Ticketlayer-Channel names, else the box office channel listing the event. Gated as the staff seat map token is, so whoever can sell at the box office can read it. 404 OCCURRENCE_NOT_SEATED when the event is not sold seated; 404 SEATMAP_NOT_PUBLISHED until the seat map has been published.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`requestOptions?`	`RequestOptions`

Returns#

Promise<{ eventPlanId: string; hasModel: boolean; hasStills: boolean; hasViews: boolean; maxTickets: number; overlay: string; overview: string; planVersion: string; seatCount: number; singleSeatGap: "warn" | "confirm"; venuePlanVersionId: string; }>

Operation Id#

getOccurrenceSeatmap

getState()#

getState: (occurrenceId: string, options?: {
  cartId?: string;
}, requestOptions?: RequestOptions) => Promise<{
  allocations: {
     holderType: "agent" | "promoter";
     id: string;
     name: string;
     releaseAt: string | null;
     salesChannelId: string | null;
     seats: number[];
  }[];
  comp: number[];
  eventPlanId: string;
  holds: {
     id: string;
     name: string;
     seats: number[];
  }[];
  killed: number[];
  killsReleased: number[];
  notOnPlan: number[];
  occurrenceId: string;
  reserved: {
     mine: number[];
     others: number[];
  };
  seatCount: number;
  sold: number[];
  statusVersion: number;
  venuePlanVersionId: string;
}>;

Get the staff seat state Every seat of the occurrence that is not available, by what it is: not on the event plan, killed, reserved (in the cart named by cartId, mine, or another), sold, comp, held under a named hold, or idle in an allocation (available only on the channel it names). killsReleased lists the production kills released for sale here. A seat listed nowhere is available. Read directly, not edge cached; statusVersion moves with every seat change. 404 OCCURRENCE_NOT_SEATED when the event is not sold seated.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`options?`	{ `cartId?`: `string`; }
`options.cartId?`	`string`
`requestOptions?`	`RequestOptions`

Returns#

Promise<{ allocations: { holderType: "agent" | "promoter"; id: string; name: string; releaseAt: string | null; salesChannelId: string | null; seats: number[]; }[]; comp: number[]; eventPlanId: string; holds: { id: string; name: string; seats: number[]; }[]; killed: number[]; killsReleased: number[]; notOnPlan: number[]; occurrenceId: string; reserved: { mine: number[]; others: number[]; }; seatCount: number; sold: number[]; statusVersion: number; venuePlanVersionId: string; }>

Operation Id#

getOccurrenceSeatingState

listAllocations()#

listAllocations: (occurrenceId: string, options?: {
  includeReleased?: "true" | "false";
}, requestOptions?: RequestOptions) => Promise<{
  createdAt: string;
  createdBy: string | null;
  holderType: "agent" | "promoter";
  id: string;
  name: string;
  notes: string | null;
  releaseAt: string | null;
  releasedAt: string | null;
  releasedBy: string | null;
  releaseReason: "scheduled" | "staff" | null;
  salesChannelId: string | null;
  seats: number[];
  sold: number[];
}[]>;

List an occurrence's seat allocations The open allocations (with includeReleased=true, the released ones too), each with the seats still in it and the seats sold through it.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`options?`	{ `includeReleased?`: `"true"` \| `"false"`; }
`options.includeReleased?`	`"true"` \| `"false"`
`requestOptions?`	`RequestOptions`

Returns#

Operation Id#

listOccurrenceSeatAllocations

listHolds()#

listHolds: (occurrenceId: string, requestOptions?: RequestOptions) => Promise<{
  createdAt: string;
  createdBy: string | null;
  id: string;
  name: string;
  reason: string | null;
  releasedAt: string | null;
  seats: number[];
}[]>;

List an occurrence's seat holds The open named holds, each with the seats it still holds.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`requestOptions?`	`RequestOptions`

Returns#

Promise<{ createdAt: string; createdBy: string | null; id: string; name: string; reason: string | null; releasedAt: string | null; seats: number[]; }[]>

Operation Id#

listOccurrenceSeatHolds

releaseAllocation()#

releaseAllocation: (occurrenceId: string, allocationId: string, request: {
  seats?: number[];
}, requestOptions?: RequestOptions) => Promise<{
  createdAt: string;
  createdBy: string | null;
  holderType: "agent" | "promoter";
  id: string;
  name: string;
  notes: string | null;
  releaseAt: string | null;
  releasedAt: string | null;
  releasedBy: string | null;
  releaseReason: "scheduled" | "staff" | null;
  salesChannelId: string | null;
  seats: number[];
  sold: number[];
}>;

Release allocated seats Give some of an allocation's seats back to general sale, or all of them with no seats named. Idle seats are available at once; a seat a buyer has reserved through it stays theirs and, if the reservation lapses, goes to general sale. Sold seats are not touched. An allocation with no unsold seat left is closed.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`allocationId`	`string`
`request`	{ `seats?`: `number`[]; }
`request.seats?`	`number`[]
`requestOptions?`	`RequestOptions`

Returns#

Operation Id#

releaseOccurrenceSeatAllocation

releaseHold()#

releaseHold: (occurrenceId: string, holdId: string, request: {
  seats?: number[];
}, requestOptions?: RequestOptions) => Promise<{
  createdAt: string;
  createdBy: string | null;
  id: string;
  name: string;
  reason: string | null;
  releasedAt: string | null;
  seats: number[];
}>;

Release held seats Release some of a hold's seats, or all of them with no seats named. A hold with no seat left is closed.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`holdId`	`string`
`request`	{ `seats?`: `number`[]; }
`request.seats?`	`number`[]
`requestOptions?`	`RequestOptions`

Returns#

Promise<{ createdAt: string; createdBy: string | null; id: string; name: string; reason: string | null; releasedAt: string | null; seats: number[]; }>

Operation Id#

releaseOccurrenceSeatHold

releaseKills()#

releaseKills: (occurrenceId: string, request: {
  reason?: any;
  seats: number[];
}, requestOptions?: RequestOptions) => Promise<{
  eventPlanId: string;
  killsReleased: number[];
  occurrenceId: string;
}>;

Release production kills for sale on this occurrence Late kill release: seats production killed on the event plan go on sale on this occurrence only, in their categories. The kill stands everywhere else. 400 VALIDATION_ERROR names a seat the event plan has not killed. Gated as releasing a hold is.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`request`	{ `reason?`: `any`; `seats`: `number`[]; }
`request.reason?`	`any`
`request.seats?`	`number`[]
`requestOptions?`	`RequestOptions`

Returns#

Promise<{ eventPlanId: string; killsReleased: number[]; occurrenceId: string; }>

Operation Id#

releaseOccurrenceKills

restoreKills()#

restoreKills: (occurrenceId: string, request: {
  seats: number[];
}, requestOptions?: RequestOptions) => Promise<{
  eventPlanId: string;
  killsReleased: number[];
  occurrenceId: string;
}>;

Restore released kills on this occurrence Put kills released on this occurrence back, all or none: refused with 409 SEAT_UNAVAILABLE for a seat in use here (reserved, sold, held or allocated), as a kill is. Gated as making a hold is.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`request`	{ `seats`: `number`[]; }
`request.seats`	`number`[]
`requestOptions?`	`RequestOptions`

Returns#

Promise<{ eventPlanId: string; killsReleased: number[]; occurrenceId: string; }>

Operation Id#

restoreOccurrenceKills

updateAllocation()#

updateAllocation: (occurrenceId: string, allocationId: string, request: {
  name?: string;
  notes?: any;
  releaseAt?: any;
  salesChannelId?: any;
}, requestOptions?: RequestOptions) => Promise<{
  createdAt: string;
  createdBy: string | null;
  holderType: "agent" | "promoter";
  id: string;
  name: string;
  notes: string | null;
  releaseAt: string | null;
  releasedAt: string | null;
  releasedBy: string | null;
  releaseReason: "scheduled" | "staff" | null;
  salesChannelId: string | null;
  seats: number[];
  sold: number[];
}>;

Change a seat allocation Rename an open allocation, change the channel that may sell its seats (null: none), its release time (null: only staff release it) or its notes. 404 SEAT_ALLOCATION_NOT_FOUND once released.

Parameters#

Parameter	Type
`occurrenceId`	`string`
`allocationId`	`string`
`request`	{ `name?`: `string`; `notes?`: `any`; `releaseAt?`: `any`; `salesChannelId?`: `any`; }
`request.name?`	`string`
`request.notes?`	`any`
`request.releaseAt?`	`any`
`request.salesChannelId?`	`any`
`requestOptions?`	`RequestOptions`

Returns#

Operation Id#

updateOccurrenceSeatAllocation