Skip to content
Docs
Open Backstage
Reference

Class: LiveClient

Class: LiveClient in @ticketlayer/live.

@ticketlayer/live

@ticketlayer/live / index / LiveClient

Defined in: client.ts:312

Generated Live client. Mirrors the sales surface (byte-for-byte views) plus the Live-only /session and /queue operations. Auth is the Live session (cookie on hosted web; X-Live-Session header elsewhere) + the channel publishable key for embeds. Browser ergonomics live in createLiveClient.

Constructors#

Constructor#

new LiveClient(config: LiveClientConfig): LiveClient;

Defined in: client.ts:320

Parameters#

ParameterType
configLiveClientConfig

Returns#

LiveClient

Methods#

clearSession()#

clearSession(): Promise<void>;

Defined in: client.ts:339

Returns#

Promise<void>

getSessionToken()#

getSessionToken(): Promise<string | null>;

Defined in: client.ts:335

The current session token (token mode), if any - used for embed handoff.

Returns#

Promise<string | null>

setSessionToken()#

setSessionToken(token: string): Promise<void>;

Defined in: client.ts:330

Store the Live session id (token mode). Called after POST /session.

Parameters#

ParameterType
tokenstring

Returns#

Promise<void>

Properties#

concierge#

concierge: {
  closeConversation: (conversationId: string, request: ConciergeEmptyBody, requestOptions?: RequestOptions) => Promise<any>;
  completeVerification: (request: {
     code: string;
     email?: string;
     phone?: string;
  }, requestOptions?: RequestOptions) => Promise<any>;
  config: (requestOptions?: RequestOptions) => Promise<any>;
  confirmProposal: (proposalId: string, request: ConciergeEmptyBody, requestOptions?: RequestOptions) => Promise<any>;
  contact: (requestOptions?: RequestOptions) => Promise<any>;
  getArticle: (articleId: string, options?: {
     eventId?: string;
     language?: string;
     occurrenceId?: string;
     venueId?: string;
  }, requestOptions?: RequestOptions) => Promise<any>;
  listArticles: (options?: {
     category?: string;
     eventId?: string;
     language?: string;
     occurrenceId?: string;
     venueId?: string;
  }, requestOptions?: RequestOptions) => Promise<any>;
  refundPolicy: (options?: {
     eventId?: string;
  }, requestOptions?: RequestOptions) => Promise<any>;
  search: (options?: {
     eventId?: string;
     q: string;
  }, requestOptions?: RequestOptions) => Promise<any>;
  startVerification: (request: {
     email?: string;
     phone?: string;
  }, requestOptions?: RequestOptions) => Promise<any>;
  turn: (request: {
     context?: {
        eventId?: string;
        occurrenceId?: string;
        orderId?: string;
     };
     message: string;
  }, requestOptions?: RequestOptions) => Promise<any>;
};

Defined in: client.ts:514

Concierge methods

closeConversation#

closeConversation: (conversationId: string, request: ConciergeEmptyBody, requestOptions?: RequestOptions) => Promise<any>;

Close the conversation The visitor closed the conversation. Only the session's own conversation. Live tells the AI, which reports how the conversation ended, and the next turn starts a new conversation. Live does the same, best effort, when the session ends (DELETE /session). The id is the one the turn stream names in its first event, conversation {conversationId}.

Parameters
ParameterType
conversationIdstring
requestConciergeEmptyBody
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

closeConciergeConversation

completeVerification#

completeVerification: (request: {
  code: string;
  email?: string;
  phone?: string;
}, requestOptions?: RequestOptions) => Promise<any>;

Verify with the code Exchanges the code for a customer token, which Live keeps in the session and never returns. The session is then verified, and for ten minutes stepped up. The code goes to backstage-api and nowhere else.

Parameters
ParameterTypeDescription
request{ code: string; email?: string; phone?: string; }-
request.codestringDescription The 6-digit code the customer received. Example 123456
request.email?stringExample fan@example.com
request.phone?string-
requestOptions?RequestOptions-
Returns

Promise<any>

Operation Id

completeConciergeVerification

config#

config: (requestOptions?: RequestOptions) => Promise<any>;

Get the channel's Concierge configuration What the Concierge widget renders from. Session-less: the session or a publishable key identifies the channel. A channel with no Concierge configuration reads as disabled.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

getConciergeConfig

confirmProposal#

confirmProposal: (proposalId: string, request: ConciergeEmptyBody, requestOptions?: RequestOptions) => Promise<any>;

Confirm a proposal The customer pressed a confirm card's button. The browser names the proposal and sends nothing else: Live holds the card's confirmation token in the session (it took it out of the turn stream), mints a fresh turn credential for the same conversation at the session's level now, and confirms with backstage-api, whose refusal codes are passed through. The token is used once: after any answer from backstage-api it is gone, and pressing again is 404 PROPOSAL_NOT_FOUND. Only a failure to reach backstage-api (502 UPSTREAM_UNAVAILABLE) keeps it. Only from the session and conversation the card was shown in. Behind the same switches as a turn.

Parameters
ParameterType
proposalIdstring
requestConciergeEmptyBody
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

confirmConciergeProposal

contact#

contact: (requestOptions?: RequestOptions) => Promise<any>;

Send the contact form Opens a case with the organiser. Not available yet: answers 501 until cases exist.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

contactConcierge

getArticle#

getArticle: (articleId: string, options?: {
  eventId?: string;
  language?: string;
  occurrenceId?: string;
  venueId?: string;
}, requestOptions?: RequestOptions) => Promise<any>;

Get a help article One public article, rendered, if it applies on this channel (and to the event, when given). Session-less.

Parameters
ParameterType
articleIdstring
options?{ eventId?: string; language?: string; occurrenceId?: string; venueId?: string; }
options.eventId?string
options.language?string
options.occurrenceId?string
options.venueId?string
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

getConciergeArticle

listArticles#

listArticles: (options?: {
  category?: string;
  eventId?: string;
  language?: string;
  occurrenceId?: string;
  venueId?: string;
}, requestOptions?: RequestOptions) => Promise<any>;

List the channel's help articles The published public articles that apply on this channel (and to the event, when given), most specific first, with placeholders rendered from the facts. backstage-api's answer, narrowed to one category when asked. Session-less.

Parameters
ParameterType
options?{ category?: string; eventId?: string; language?: string; occurrenceId?: string; venueId?: string; }
options.category?string
options.eventId?string
options.language?string
options.occurrenceId?string
options.venueId?string
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

listConciergeArticles

refundPolicy#

refundPolicy: (options?: {
  eventId?: string;
}, requestOptions?: RequestOptions) => Promise<any>;

Get the refund and exchange policy text Generated from the policy enforced on an order on this channel (for the event, when given), with the organisation's own message. Never written by hand. Session-less.

Parameters
ParameterType
options?{ eventId?: string; }
options.eventId?string
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

getConciergeRefundPolicy

search: (options?: {
  eventId?: string;
  q: string;
}, requestOptions?: RequestOptions) => Promise<any>;

Search the knowledge base Searches the channel's public knowledge base, with no AI involved. The answer is backstage-api's, unchanged.

Parameters
ParameterType
options?{ eventId?: string; q: string; }
options.eventId?string
options.q?string
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

searchConcierge

startVerification#

startVerification: (request: {
  email?: string;
  phone?: string;
}, requestOptions?: RequestOptions) => Promise<any>;

Send a verification code Sends a 6-digit sign-in code to the email or phone, through the channel's customer sign-in. The answer is the same whether or not the contact is a customer.

Parameters
ParameterTypeDescription
request{ email?: string; phone?: string; }-
request.email?stringExample fan@example.com
request.phone?string-
requestOptions?RequestOptions-
Returns

Promise<any>

Operation Id

startConciergeVerification

turn#

turn: (request: {
  context?: {
     eventId?: string;
     occurrenceId?: string;
     orderId?: string;
  };
  message: string;
}, requestOptions?: RequestOptions) => Promise<any>;

Take an AI turn Sends the customer's message to the Concierge AI and streams its answer back as server-sent events: conversation {conversationId} first (Live's own: the conversation the turn belongs to), then the AI's token {text}, tool {name, status}, card {kind, ...}, citation {kind, ...}, handover {caseId?}, done {usage}, error {code, message}. Every AI event is passed through as the AI sent it, except that a card never carries a confirmationToken: Live keeps it in the session, and the Confirm button names only the proposal (POST /v1/concierge/proposals/{proposalId}/confirm). Off unless the deployment and the channel both turn AI on. At most 40 turns a conversation.

Parameters
ParameterTypeDescription
request{ context?: { eventId?: string; occurrenceId?: string; orderId?: string; }; message: string; }-
request.context?{ eventId?: string; occurrenceId?: string; orderId?: string; }Description Where the widget is. Page context only; it grants nothing.
request.context.eventId?string-
request.context.occurrenceId?string-
request.context.orderId?string-
request.message?stringDescription What the customer typed, at most 4000 characters.
requestOptions?RequestOptions-
Returns

Promise<any>

Operation Id

createConciergeTurn

queue#

queue: {
  join: (requestOptions?: RequestOptions) => Promise<any>;
  status: (requestOptions?: RequestOptions) => Promise<any>;
};

Defined in: client.ts:461

Queue methods

join#

join: (requestOptions?: RequestOptions) => Promise<any>;

Join the waiting room Joins the current session to the waiting room. While the queue is disabled this is a no-op that reports immediate admission.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

joinLiveQueue

status#

status: (requestOptions?: RequestOptions) => Promise<any>;

Get waiting-room status Returns the waiting-room status for the current session. The waiting room lives only in Live; when disabled the queue is transparent and every session is admitted.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

getLiveQueueStatus

sales#

sales: {
  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;
   }, 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;
  }>;
  get: (eventId: string, requestOptions?: RequestOptions) => Promise<{
     availability:   | {
        opensAt: string | null;
        state:   | "on_sale"
           | "not_yet_on_sale"
           | "off_sale"
           | "sold_out"
           | "locked"
           | "hidden"
           | null;
      }
        | null;
     currency: string | null;
     description: string | null;
     heroImageUrl: string | null;
     id: string;
     imageUrl: string | null;
     listing: {
        closesAt: string | null;
        opensAt: string | null;
        sellable: boolean;
     };
     name: string;
     occurrences: {
        availability: {
           closesAt: string | null;
           opensAt: string | null;
           reason:   | "SALE_CLOSED"
              | "NOT_AVAILABLE"
              | "SOLD_OUT"
              | "SALE_NOT_OPEN"
              | "TAG_REQUIRED"
              | null;
           state:   | "on_sale"
              | "not_yet_on_sale"
              | "off_sale"
              | "sold_out"
              | "locked"
              | "hidden";
        };
        endDate: string;
        endsAt: string | null;
        endTime: string;
        id: string;
        lockedTicketTypes: {
           availability: {
              closesAt: string | null;
              opensAt: string | null;
              reason:   | "SALE_CLOSED"
                 | "NOT_AVAILABLE"
                 | "SOLD_OUT"
                 | "SALE_NOT_OPEN"
                 | "TAG_REQUIRED"
                 | null;
              state:   | "on_sale"
                 | "not_yet_on_sale"
                 | "off_sale"
                 | "sold_out"
                 | "locked"
                 | "hidden";
           };
           categoryId: string;
           categoryName: string;
           currency: string;
           description: string | null;
           limits: {
              maxPerOrder: number;
              minPerOrder: number;
           };
           price: {
              currency: string;
              faceValue: number;
              fees: {
                 amount: ...;
                 basis: ...;
                 code: ...;
                 label: ...;
                 rate: ...;
              }[];
              headline: {
                 allIn: boolean;
                 amount: number;
              };
              total: number;
           };
           remaining: {
              bucket: "none" | "available" | "limited" | "few" | null;
           };
           ticketTypeId: string;
           ticketTypeName: string;
           unitPrice: number;
           unlock:   | {
              code: boolean;
              howTo: {
                 products: ...;
              };
              tags: ...[];
              unlocked: boolean;
              visibility: ... | ...;
            }
              | null;
        }[];
        startDate: string;
        startsAt: string | null;
        startTime: string;
        status: string;
        ticketTypes: {
           availability: {
              closesAt: string | null;
              opensAt: string | null;
              reason:   | "SALE_CLOSED"
                 | "NOT_AVAILABLE"
                 | "SOLD_OUT"
                 | "SALE_NOT_OPEN"
                 | "TAG_REQUIRED"
                 | null;
              state:   | "on_sale"
                 | "not_yet_on_sale"
                 | "off_sale"
                 | "sold_out"
                 | "locked"
                 | "hidden";
           };
           categoryId: string;
           categoryName: string;
           currency: string;
           description: string | null;
           limits: {
              maxPerOrder: number;
              minPerOrder: number;
           };
           price: {
              currency: string;
              faceValue: number;
              fees: {
                 amount: ...;
                 basis: ...;
                 code: ...;
                 label: ...;
                 rate: ...;
              }[];
              headline: {
                 allIn: boolean;
                 amount: number;
              };
              total: number;
           };
           remaining: {
              bucket: "none" | "available" | "limited" | "few" | null;
           };
           ticketTypeId: string;
           ticketTypeName: string;
           unitPrice: number;
           unlock:   | {
              code: boolean;
              howTo: {
                 products: ...;
              };
              tags: ...[];
              unlocked: boolean;
              visibility: ... | ...;
            }
              | null;
        }[];
        timezone: string;
     }[];
     presentation:   | {
        buttonSize?: "small" | "medium" | "large";
        cinemaGradient?: {
           position: "bottom" | "center";
           strength: 20 | 50 | 70;
        };
        heroLayout?: {
           size: "small" | "medium" | "large";
           type: "hero" | "cinema";
        };
        navbar?: {
           transparent?: boolean;
        };
        twoColumnSplit?: [number, number];
      }
        | null;
     priceFrom: number | null;
     prices:   | {
        currency: string | null;
        feesIncluded: true;
        from: number | null;
        to: number | null;
      }
        | null;
     shortDescription: string | null;
     status: string;
     subtitle: string | null;
     timezone: string;
     venueCity: string | null;
     venueId: string | null;
     venueName: string | null;
  }>;
  getConciergeConfig: (requestOptions?: RequestOptions) => Promise<{
     ai: {
        enabled: boolean;
        tier: "answer" | "integrated" | "actions";
     };
     allowedLinkHosts: string[];
     allowedOrigins: string[];
     channelId: string;
     enabled: boolean;
     features: {
        chat: boolean;
        contact: boolean;
        myOrders: boolean;
        search: boolean;
     };
     openingHours:   | {
        timezone: string;
        weekly: {
           fri?: {
              closes: string;
              opens: string;
           }[];
           mon?: {
              closes: string;
              opens: string;
           }[];
           sat?: {
              closes: string;
              opens: string;
           }[];
           sun?: {
              closes: string;
              opens: string;
           }[];
           thu?: {
              closes: string;
              opens: string;
           }[];
           tue?: {
              closes: string;
              opens: string;
           }[];
           wed?: {
              closes: string;
              opens: string;
           }[];
        };
      }
        | null;
     organisationId: string;
     persona: {
        avatarUrl: string | null;
        greeting: string | null;
        name: string;
     };
     placements: {
        embedded: {
           buyTickets: boolean;
           checkout: boolean;
           confirmation: boolean;
           myOrders: boolean;
        };
        inline: boolean;
        launcher: boolean;
        page: boolean;
     };
  }>;
  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;
  }>;
  getTheme: (requestOptions?: RequestOptions) => Promise<{
     brand: {
        displayName?: string;
        faviconUrl?: string;
        fontStylesheetUrl?: string;
        logoDarkUrl?: string;
        logoUrl?: string;
     };
     colors: {
        accent?: string;
        accentForeground?: string;
        background?: string;
        border?: string;
        destructive?: string;
        destructiveForeground?: string;
        foreground?: string;
        input?: string;
        muted?: string;
        mutedForeground?: string;
        primary?: string;
        primaryForeground?: string;
        ring?: string;
        secondary?: string;
        secondaryForeground?: string;
        success?: string;
        successForeground?: string;
        warning?: string;
        warningForeground?: string;
     };
     design?:   | {
        buttonSize?: "small" | "medium" | "large";
        cinemaGradient?: {
           position: "bottom" | "center";
           strength: 20 | 50 | 70;
        };
        heroLayout?: {
           size: "small" | "medium" | "large";
           type: "hero" | "cinema";
        };
        modalHeader?: {
           channel?: "hidden" | "blurred" | "plain";
           event?: "blurred" | "plain";
        };
        navbar?: {
           transparent?: boolean;
        };
        twoColumnSplit?: [number, number];
      }
        | null;
     id: string;
     name: string;
     shape: {
        radiusFull?: string;
        radiusLg?: string;
        radiusMd?: string;
        radiusNone?: string;
        radiusSm?: string;
     };
     typography: {
        baseSize?: string;
        fontFamily?: string;
        fontFamilyMono?: string;
        headingFontFamily?: string;
        headingFontWeight?: number;
        scaleRatio?: number;
     };
  }>;
  resolveChannel: (options?: {
     domain?: string;
     key?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     allowedOrigins?: string[];
     cacheVersion: string;
     channel: {
        id: string;
        name: string;
        slug: string;
     };
     publishableKey: string | null;
     storefrontOrigins?: string[];
  }>;
};

Defined in: client.ts:706

Sales 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;
}, 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 A few options that differ for a party (3dvenue best-available.md): quantity, an optional ticket mix, category or price filters, areas or sections, an aisle, wheelchair spaces, and how together. Each option names its seats by index with their labels, its category, the fee-inclusive price each and in total, and public reason codes (best_available, cheaper, closer, fills_gap...); the rank is never in it. sessionId spreads concurrent buyers across equally good blocks. Nothing is held: reserve an option by passing its seats to POST /carts/{cartId}/seats. 422 SEAT_LIMIT over the channel's maxTickets; 404 OCCURRENCE_NOT_SEATED when the occurrence is not sold seated or not on this channel.

Parameters
ParameterTypeDescription
occurrenceIdstring-
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; }-
request.accessible?numberDescription Wheelchair spaces needed; companions become eligible beside them
request.aisle?booleanDescription An end seat of the block on an aisle
request.areas?string[]-
request.categories?string[]Description Seat category ids: only these
request.maxPriceEach?numberDescription Fee-inclusive minor units per ticket
request.maxTotal?numberDescription Fee-inclusive minor units for the whole block
request.options?number-
request.priceHard?booleanDescription false: maxPriceEach is a preference, not a filter
request.quantity?numberExample 2
request.sections?string[]-
request.sessionId?stringDescription The buyer's session (the seat map token's sid, or any stable id): spreads concurrent buyers across equally good blocks
request.tickets?{ quantity: number; ticketTypeId: string; }[]Description The ticket mix, adding up to quantity. Absent: each seat at its category default type
request.together?"row" | "rows" | "any"-
request.withinHard?boolean-
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

getSalesOccurrenceBestAvailable

get#

get: (eventId: string, requestOptions?: RequestOptions) => Promise<{
  availability:   | {
     opensAt: string | null;
     state:   | "on_sale"
        | "not_yet_on_sale"
        | "off_sale"
        | "sold_out"
        | "locked"
        | "hidden"
        | null;
   }
     | null;
  currency: string | null;
  description: string | null;
  heroImageUrl: string | null;
  id: string;
  imageUrl: string | null;
  listing: {
     closesAt: string | null;
     opensAt: string | null;
     sellable: boolean;
  };
  name: string;
  occurrences: {
     availability: {
        closesAt: string | null;
        opensAt: string | null;
        reason:   | "SALE_CLOSED"
           | "NOT_AVAILABLE"
           | "SOLD_OUT"
           | "SALE_NOT_OPEN"
           | "TAG_REQUIRED"
           | null;
        state:   | "on_sale"
           | "not_yet_on_sale"
           | "off_sale"
           | "sold_out"
           | "locked"
           | "hidden";
     };
     endDate: string;
     endsAt: string | null;
     endTime: string;
     id: string;
     lockedTicketTypes: {
        availability: {
           closesAt: string | null;
           opensAt: string | null;
           reason:   | "SALE_CLOSED"
              | "NOT_AVAILABLE"
              | "SOLD_OUT"
              | "SALE_NOT_OPEN"
              | "TAG_REQUIRED"
              | null;
           state:   | "on_sale"
              | "not_yet_on_sale"
              | "off_sale"
              | "sold_out"
              | "locked"
              | "hidden";
        };
        categoryId: string;
        categoryName: string;
        currency: string;
        description: string | null;
        limits: {
           maxPerOrder: number;
           minPerOrder: number;
        };
        price: {
           currency: string;
           faceValue: number;
           fees: {
              amount: ...;
              basis: ...;
              code: ...;
              label: ...;
              rate: ...;
           }[];
           headline: {
              allIn: boolean;
              amount: number;
           };
           total: number;
        };
        remaining: {
           bucket: "none" | "available" | "limited" | "few" | null;
        };
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
        unlock:   | {
           code: boolean;
           howTo: {
              products: ...;
           };
           tags: ...[];
           unlocked: boolean;
           visibility: ... | ...;
         }
           | null;
     }[];
     startDate: string;
     startsAt: string | null;
     startTime: string;
     status: string;
     ticketTypes: {
        availability: {
           closesAt: string | null;
           opensAt: string | null;
           reason:   | "SALE_CLOSED"
              | "NOT_AVAILABLE"
              | "SOLD_OUT"
              | "SALE_NOT_OPEN"
              | "TAG_REQUIRED"
              | null;
           state:   | "on_sale"
              | "not_yet_on_sale"
              | "off_sale"
              | "sold_out"
              | "locked"
              | "hidden";
        };
        categoryId: string;
        categoryName: string;
        currency: string;
        description: string | null;
        limits: {
           maxPerOrder: number;
           minPerOrder: number;
        };
        price: {
           currency: string;
           faceValue: number;
           fees: {
              amount: ...;
              basis: ...;
              code: ...;
              label: ...;
              rate: ...;
           }[];
           headline: {
              allIn: boolean;
              amount: number;
           };
           total: number;
        };
        remaining: {
           bucket: "none" | "available" | "limited" | "few" | null;
        };
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
        unlock:   | {
           code: boolean;
           howTo: {
              products: ...;
           };
           tags: ...[];
           unlocked: boolean;
           visibility: ... | ...;
         }
           | null;
     }[];
     timezone: string;
  }[];
  presentation:   | {
     buttonSize?: "small" | "medium" | "large";
     cinemaGradient?: {
        position: "bottom" | "center";
        strength: 20 | 50 | 70;
     };
     heroLayout?: {
        size: "small" | "medium" | "large";
        type: "hero" | "cinema";
     };
     navbar?: {
        transparent?: boolean;
     };
     twoColumnSplit?: [number, number];
   }
     | null;
  priceFrom: number | null;
  prices:   | {
     currency: string | null;
     feesIncluded: true;
     from: number | null;
     to: number | null;
   }
     | null;
  shortDescription: string | null;
  status: string;
  subtitle: string | null;
  timezone: string;
  venueCity: string | null;
  venueId: string | null;
  venueName: string | null;
}>;

Get event catalogue detail Catalogue detail for an event listed on this channel: occurrences with their ticket-type offers, each evaluated by the offers engine exactly as GET /events/{eventId}/offers?view=buyer evaluates it for the same channel, customer and instant: price with its fee lines and total, availability with the buyer's reason, a capacity remaining.bucket and limits. ticketTypes holds what this buyer may buy as far as price visibility goes; lockedTicketTypes holds locked prices with how to unlock them (the tags' labels and whether a code could, unless the channel withholds unlock hints). A hidden price is listed only once the customer token unlocks it. unitPrice and priceFrom keep their face-value meaning and are deprecated. Returns 404 if the event is not listed on this channel.

Parameters
ParameterType
eventIdstring
requestOptions?RequestOptions
Returns

Promise<{ availability: | { opensAt: string | null; state: | "on_sale" | "not_yet_on_sale" | "off_sale" | "sold_out" | "locked" | "hidden" | null; } | null; currency: string | null; description: string | null; heroImageUrl: string | null; id: string; imageUrl: string | null; listing: { closesAt: string | null; opensAt: string | null; sellable: boolean; }; name: string; occurrences: { availability: { closesAt: string | null; opensAt: string | null; reason: | "SALE_CLOSED" | "NOT_AVAILABLE" | "SOLD_OUT" | "SALE_NOT_OPEN" | "TAG_REQUIRED" | null; state: | "on_sale" | "not_yet_on_sale" | "off_sale" | "sold_out" | "locked" | "hidden"; }; endDate: string; endsAt: string | null; endTime: string; id: string; lockedTicketTypes: { availability: { closesAt: string | null; opensAt: string | null; reason: | "SALE_CLOSED" | "NOT_AVAILABLE" | "SOLD_OUT" | "SALE_NOT_OPEN" | "TAG_REQUIRED" | null; state: | "on_sale" | "not_yet_on_sale" | "off_sale" | "sold_out" | "locked" | "hidden"; }; categoryId: string; categoryName: string; currency: string; description: string | null; limits: { maxPerOrder: number; minPerOrder: number; }; price: { currency: string; faceValue: number; fees: { amount: ...; basis: ...; code: ...; label: ...; rate: ...; }[]; headline: { allIn: boolean; amount: number; }; total: number; }; remaining: { bucket: "none" | "available" | "limited" | "few" | null; }; ticketTypeId: string; ticketTypeName: string; unitPrice: number; unlock: | { code: boolean; howTo: { products: ...; }; tags: ...[]; unlocked: boolean; visibility: ... | ...; } | null; }[]; startDate: string; startsAt: string | null; startTime: string; status: string; ticketTypes: { availability: { closesAt: string | null; opensAt: string | null; reason: | "SALE_CLOSED" | "NOT_AVAILABLE" | "SOLD_OUT" | "SALE_NOT_OPEN" | "TAG_REQUIRED" | null; state: | "on_sale" | "not_yet_on_sale" | "off_sale" | "sold_out" | "locked" | "hidden"; }; categoryId: string; categoryName: string; currency: string; description: string | null; limits: { maxPerOrder: number; minPerOrder: number; }; price: { currency: string; faceValue: number; fees: { amount: ...; basis: ...; code: ...; label: ...; rate: ...; }[]; headline: { allIn: boolean; amount: number; }; total: number; }; remaining: { bucket: "none" | "available" | "limited" | "few" | null; }; ticketTypeId: string; ticketTypeName: string; unitPrice: number; unlock: | { code: boolean; howTo: { products: ...; }; tags: ...[]; unlocked: boolean; visibility: ... | ...; } | null; }[]; timezone: string; }[]; presentation: | { buttonSize?: "small" | "medium" | "large"; cinemaGradient?: { position: "bottom" | "center"; strength: 20 | 50 | 70; }; heroLayout?: { size: "small" | "medium" | "large"; type: "hero" | "cinema"; }; navbar?: { transparent?: boolean; }; twoColumnSplit?: [number, number]; } | null; priceFrom: number | null; prices: | { currency: string | null; feesIncluded: true; from: number | null; to: number | null; } | null; shortDescription: string | null; status: string; subtitle: string | null; timezone: string; venueCity: string | null; venueId: string | null; venueName: string | null; }>

Operation Id

getSalesEvent

getConciergeConfig#

getConciergeConfig: (requestOptions?: RequestOptions) => Promise<{
  ai: {
     enabled: boolean;
     tier: "answer" | "integrated" | "actions";
  };
  allowedLinkHosts: string[];
  allowedOrigins: string[];
  channelId: string;
  enabled: boolean;
  features: {
     chat: boolean;
     contact: boolean;
     myOrders: boolean;
     search: boolean;
  };
  openingHours:   | {
     timezone: string;
     weekly: {
        fri?: {
           closes: string;
           opens: string;
        }[];
        mon?: {
           closes: string;
           opens: string;
        }[];
        sat?: {
           closes: string;
           opens: string;
        }[];
        sun?: {
           closes: string;
           opens: string;
        }[];
        thu?: {
           closes: string;
           opens: string;
        }[];
        tue?: {
           closes: string;
           opens: string;
        }[];
        wed?: {
           closes: string;
           opens: string;
        }[];
     };
   }
     | null;
  organisationId: string;
  persona: {
     avatarUrl: string | null;
     greeting: string | null;
     name: string;
  };
  placements: {
     embedded: {
        buyTickets: boolean;
        checkout: boolean;
        confirmation: boolean;
        myOrders: boolean;
     };
     inline: boolean;
     launcher: boolean;
     page: boolean;
  };
}>;

Get the channel's Concierge config The Concierge widget's config for the channel the key belongs to: on or off, placements, features, the AI switch and tier, the persona (resolved through the channel's brand, with the avatar's URL), opening hours, the origins allowed to host it and the hosts it may link to. Public-safe: no contact queue, no tool names, no account or brand ids. A channel with Concierge off answers enabled false. Theme is the brand's, from GET /theme.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<{ ai: { enabled: boolean; tier: "answer" | "integrated" | "actions"; }; allowedLinkHosts: string[]; allowedOrigins: string[]; channelId: string; enabled: boolean; features: { chat: boolean; contact: boolean; myOrders: boolean; search: boolean; }; openingHours: | { timezone: string; weekly: { fri?: { closes: string; opens: string; }[]; mon?: { closes: string; opens: string; }[]; sat?: { closes: string; opens: string; }[]; sun?: { closes: string; opens: string; }[]; thu?: { closes: string; opens: string; }[]; tue?: { closes: string; opens: string; }[]; wed?: { closes: string; opens: string; }[]; }; } | null; organisationId: string; persona: { avatarUrl: string | null; greeting: string | null; name: string; }; placements: { embedded: { buyTickets: boolean; checkout: boolean; confirmation: boolean; myOrders: boolean; }; inline: boolean; launcher: boolean; page: boolean; }; }>

Operation Id

getSalesConciergeConfig

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 Which published seat map the occurrence sells from on this channel: its publish key (planVersion), the overview and the event plan's overlay (paths relative to <pv>/), the seat count, which media exist, and the channel's maxTickets and singleSeatGap rule. Cache it like the event detail read, under the channel's storefront cache version: a publish, a change to the event plan and a change to the channel's rules each move it. 404 OCCURRENCE_NOT_SEATED when the occurrence is not sold seated or not on this channel; 404 SEATMAP_NOT_PUBLISHED until the seat map has been published.

Parameters
ParameterType
occurrenceIdstring
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

getSalesOccurrenceSeatmap

getTheme#

getTheme: (requestOptions?: RequestOptions) => Promise<{
  brand: {
     displayName?: string;
     faviconUrl?: string;
     fontStylesheetUrl?: string;
     logoDarkUrl?: string;
     logoUrl?: string;
  };
  colors: {
     accent?: string;
     accentForeground?: string;
     background?: string;
     border?: string;
     destructive?: string;
     destructiveForeground?: string;
     foreground?: string;
     input?: string;
     muted?: string;
     mutedForeground?: string;
     primary?: string;
     primaryForeground?: string;
     ring?: string;
     secondary?: string;
     secondaryForeground?: string;
     success?: string;
     successForeground?: string;
     warning?: string;
     warningForeground?: string;
  };
  design?:   | {
     buttonSize?: "small" | "medium" | "large";
     cinemaGradient?: {
        position: "bottom" | "center";
        strength: 20 | 50 | 70;
     };
     heroLayout?: {
        size: "small" | "medium" | "large";
        type: "hero" | "cinema";
     };
     modalHeader?: {
        channel?: "hidden" | "blurred" | "plain";
        event?: "blurred" | "plain";
     };
     navbar?: {
        transparent?: boolean;
     };
     twoColumnSplit?: [number, number];
   }
     | null;
  id: string;
  name: string;
  shape: {
     radiusFull?: string;
     radiusLg?: string;
     radiusMd?: string;
     radiusNone?: string;
     radiusSm?: string;
  };
  typography: {
     baseSize?: string;
     fontFamily?: string;
     fontFamilyMono?: string;
     headingFontFamily?: string;
     headingFontWeight?: number;
     scaleRatio?: number;
  };
}>;

Get channel theme The channel's resolved (inheritance-merged) theme for SSR injection. Returns 404 if the channel has neither its own theme nor an organisation base theme.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<{ brand: { displayName?: string; faviconUrl?: string; fontStylesheetUrl?: string; logoDarkUrl?: string; logoUrl?: string; }; colors: { accent?: string; accentForeground?: string; background?: string; border?: string; destructive?: string; destructiveForeground?: string; foreground?: string; input?: string; muted?: string; mutedForeground?: string; primary?: string; primaryForeground?: string; ring?: string; secondary?: string; secondaryForeground?: string; success?: string; successForeground?: string; warning?: string; warningForeground?: string; }; design?: | { buttonSize?: "small" | "medium" | "large"; cinemaGradient?: { position: "bottom" | "center"; strength: 20 | 50 | 70; }; heroLayout?: { size: "small" | "medium" | "large"; type: "hero" | "cinema"; }; modalHeader?: { channel?: "hidden" | "blurred" | "plain"; event?: "blurred" | "plain"; }; navbar?: { transparent?: boolean; }; twoColumnSplit?: [number, number]; } | null; id: string; name: string; shape: { radiusFull?: string; radiusLg?: string; radiusMd?: string; radiusNone?: string; radiusSm?: string; }; typography: { baseSize?: string; fontFamily?: string; fontFamilyMono?: string; headingFontFamily?: string; headingFontWeight?: number; scaleRatio?: number; }; }>

Operation Id

getSalesTheme

resolveChannel#

resolveChannel: (options?: {
  domain?: string;
  key?: string;
}, requestOptions?: RequestOptions) => Promise<{
  allowedOrigins?: string[];
  cacheVersion: string;
  channel: {
     id: string;
     name: string;
     slug: string;
  };
  publishableKey: string | null;
  storefrontOrigins?: string[];
}>;

Resolve a channel by domain or publishable key Public tenant resolution for hosted surfaces: maps a hostname (the channel's configured subdomain or custom domain), or a publishable key the caller already holds, to its channel summary, publishable key and storefront cache version. Exactly one of domain or key is required. No authentication; rate-limited.

Parameters
ParameterType
options?{ domain?: string; key?: string; }
options.domain?string
options.key?string
requestOptions?RequestOptions
Returns

Promise<{ allowedOrigins?: string[]; cacheVersion: string; channel: { id: string; name: string; slug: string; }; publishableKey: string | null; storefrontOrigins?: string[]; }>

Operation Id

resolveSalesChannel

salesCarts#

salesCarts: {
  abandon: (cartId: string, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  addGiftCard: (cartId: string, request: {
     amount?: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     productId: string;
   }, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  addItem: (cartId: string, request: {
     categoryId: string;
     eventLayoutAreaId?: string;
     eventLayoutSeatIds?: string[];
     eventOccurrenceId: string;
     quantity?: number;
     ticketTypeId: string;
   }, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  applyCode: (cartId: string, request: {
     code: string;
   }, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  attachCustomer: (cartId: string, requestOptions?: RequestOptions) => Promise<{
     cart: {
        codes: {
           code: string;
           codeId: string;
           label: string;
        }[];
        currency: string | null;
        expiresAt: string;
        giftCards: {
           amount: number;
           delivery: {
              message?: string | null;
              method: "email" | "post" | "box_office_print";
              recipientEmail?: string | null;
              recipientName?: string | null;
           };
           id: string;
           productId: string;
        }[];
        id: string;
        items: {
           categoryName: string;
           currency: string;
           eventName: string;
           eventOccurrenceId: string;
           expiresAt?: string | null;
           id: string;
           label?: string;
           number?: string;
           priceCategoryId: string;
           quantity: number;
           row?: string;
           seat?: number;
           section?: string;
           subtotal: number;
           ticketTypeId: string;
           ticketTypeName: string;
           unitPrice: number;
        }[];
        itemsSubtotal: number;
        orderId: string | null;
        status: string;
     };
     lines: {
        itemId: string;
        previousUnitPrice: number | null;
        reason:   | "SALE_CLOSED"
           | "NOT_AVAILABLE"
           | "SOLD_OUT"
           | "SALE_NOT_OPEN"
           | "TAG_REQUIRED"
           | null;
        status: "ok" | "repriced" | "unavailable";
        unitPrice: number;
     }[];
  }>;
  changeSeat: (cartId: string, occurrenceId: string, seat: string, request: {
     ticketTypeId: string;
   }, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  checkout: (cartId: string, request: {
     customer?: {
        email: string;
        firstName?: string;
        lastName?: string;
        marketingConsent?: boolean;
        phone?: string;
     };
     customerNotes?: string;
     formResponses?: Record<string, any>;
     metadata?: Record<string, any>;
     returnUrl?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     cart: {
        codes: {
           code: string;
           codeId: string;
           label: string;
        }[];
        currency: string | null;
        expiresAt: string;
        giftCards: {
           amount: number;
           delivery: {
              message?: string | null;
              method: "email" | "post" | "box_office_print";
              recipientEmail?: string | null;
              recipientName?: string | null;
           };
           id: string;
           productId: string;
        }[];
        id: string;
        items: {
           categoryName: string;
           currency: string;
           eventName: string;
           eventOccurrenceId: string;
           expiresAt?: string | null;
           id: string;
           label?: string;
           number?: string;
           priceCategoryId: string;
           quantity: number;
           row?: string;
           seat?: number;
           section?: string;
           subtotal: number;
           ticketTypeId: string;
           ticketTypeName: string;
           unitPrice: number;
        }[];
        itemsSubtotal: number;
        orderId: string | null;
        status: string;
     };
     checkout: {
        capabilitiesApplied: ("redirect" | "complete_form" | "await_approval")[];
        deferred: {
           fallback: string;
           key: string;
           requirement: string;
        }[];
        expiresAt: string | null;
        nextAction:   | {
           awaitApproval:   | {
              expiresAt: string | null;
              message: string;
              orderId: string;
              pollAfterSeconds: number;
              taskId: string | null;
            }
              | null;
           completeForm:   | {
              errors: {
                 code: ...;
                 index: ...;
                 key: ...;
                 lineId: ...;
                 message: ...;
                 source: ...;
              }[];
              form: {
                 id: string;
                 questions: ...[];
                 version: number;
              };
            }
              | null;
           payment:   | {
              amount: number;
              connectedAccountId: string | null;
              currency: string;
              externalPaymentUrl: string | null;
              orderId: string;
              paymentId: string | null;
              paymentType: string | null;
              providerClientSecret: string | null;
              providerType: string | null;
              publishableKey: string | null;
              status: string | null;
            }
              | null;
           redirect:   | {
              expiresAt: string;
              reason: "complete_form" | "await_approval" | "payment" | "hook_input";
              returnUrl: string;
              url: string;
            }
              | null;
           type: "redirect" | "complete_form" | "await_approval" | "payment";
         }
           | null;
        status:   | "requires_input"
           | "requires_approval"
           | "requires_payment"
           | "processing"
           | "complete";
     };
     order:   | {
        createdAt: string;
        currency: string;
        expiresAt: string | null;
        id: string;
        isTest: boolean;
        items: {
           description: string | null;
           name: string;
           quantity: number;
           subtotal: number;
           type: string;
           unitPrice: number;
        }[];
        orderNumber: string;
        paymentStatus: string;
        refundToCreditOffered: boolean;
        status: string;
        subtotal: number;
        tickets: {
           admissionStatus: string;
           barcode: string | null;
           bookingPass: boolean;
           codeReleasesAt: string | null;
           entitlementId: string;
           eventOccurrenceId: string | null;
           holderName: string | null;
           id: string;
           mediaType: string | null;
           name: string;
           seatLabel: string | null;
           security: "open" | "protected";
           slotId: string | null;
           status: string;
           type: string;
        }[];
        total: number;
        totalFees: number;
        totalTax: number;
      }
        | null;
     orderAccessToken: string | null;
  }>;
  choose: (cartId: string, request: {
     cardFunding?: "credit" | "debit" | "prepaid" | null;
     deliveryMethod?: string | null;
     paymentMethod?: string | null;
     shipTo?:   | {
        city: string;
        country: string;
        line1: string;
        line2?: string | null;
        name: string;
        phone?: string | null;
        postalCode: string;
        region?: string | null;
      }
        | null;
   }, requestOptions?: RequestOptions) => Promise<{
     cartId: string;
     choices: {
        cardFunding?: "credit" | "debit" | "prepaid" | null;
        deliveryMethod?: string | null;
        paymentMethod?: string | null;
     };
     currency: string | null;
     fees: {
        amount: number;
        basis: "per_ticket" | "per_order";
        code: string;
        display: "included" | "separate";
        kind: string;
        label: string;
        optional: boolean;
        refundable: "always" | "never" | "until_fulfilled" | null;
        taxCategory: string | null;
        waivedFrom: number | null;
     }[];
     headline: {
        allIn: boolean;
        amount: number;
     };
     lines: {
        discount: number;
        fees: number;
        itemId: string;
        quantity: number;
        tax: number;
        total: number;
        unitPrice: number;
     }[];
     shipTo: {
        city: string;
        country: string;
        line1: string;
        line2?: string | null;
        name: string;
        phone?: string | null;
        postalCode: string;
        region?: string | null;
     } & Record<string, never>;
     taxes: {
        category: string;
        inclusive: boolean;
        jurisdiction: string;
        rate: string | null;
        supplier: string;
        tax: number;
        taxable: number;
        treatment: "standard" | "reduced" | "zero" | "exempt" | "outside_scope";
     }[];
     totals: {
        discounts: number;
        fees: number;
        giftCards: number;
        tax: number;
        tickets: number;
        total: number;
     };
  }>;
  create: (request: {
     metadata?: Record<string, any>;
   }, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  get: (cartId: string, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  getCheckout: (cartId: string, options?: {
     returnUrl?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     cart: {
        codes: {
           code: string;
           codeId: string;
           label: string;
        }[];
        currency: string | null;
        expiresAt: string;
        giftCards: {
           amount: number;
           delivery: {
              message?: string | null;
              method: "email" | "post" | "box_office_print";
              recipientEmail?: string | null;
              recipientName?: string | null;
           };
           id: string;
           productId: string;
        }[];
        id: string;
        items: {
           categoryName: string;
           currency: string;
           eventName: string;
           eventOccurrenceId: string;
           expiresAt?: string | null;
           id: string;
           label?: string;
           number?: string;
           priceCategoryId: string;
           quantity: number;
           row?: string;
           seat?: number;
           section?: string;
           subtotal: number;
           ticketTypeId: string;
           ticketTypeName: string;
           unitPrice: number;
        }[];
        itemsSubtotal: number;
        orderId: string | null;
        status: string;
     };
     checkout: {
        capabilitiesApplied: ("redirect" | "complete_form" | "await_approval")[];
        deferred: {
           fallback: string;
           key: string;
           requirement: string;
        }[];
        expiresAt: string | null;
        nextAction:   | {
           awaitApproval:   | {
              expiresAt: string | null;
              message: string;
              orderId: string;
              pollAfterSeconds: number;
              taskId: string | null;
            }
              | null;
           completeForm:   | {
              errors: {
                 code: ...;
                 index: ...;
                 key: ...;
                 lineId: ...;
                 message: ...;
                 source: ...;
              }[];
              form: {
                 id: string;
                 questions: ...[];
                 version: number;
              };
            }
              | null;
           payment:   | {
              amount: number;
              connectedAccountId: string | null;
              currency: string;
              externalPaymentUrl: string | null;
              orderId: string;
              paymentId: string | null;
              paymentType: string | null;
              providerClientSecret: string | null;
              providerType: string | null;
              publishableKey: string | null;
              status: string | null;
            }
              | null;
           redirect:   | {
              expiresAt: string;
              reason: "complete_form" | "await_approval" | "payment" | "hook_input";
              returnUrl: string;
              url: string;
            }
              | null;
           type: "redirect" | "complete_form" | "await_approval" | "payment";
         }
           | null;
        status:   | "requires_input"
           | "requires_approval"
           | "requires_payment"
           | "processing"
           | "complete";
     };
     order:   | {
        createdAt: string;
        currency: string;
        expiresAt: string | null;
        id: string;
        isTest: boolean;
        items: {
           description: string | null;
           name: string;
           quantity: number;
           subtotal: number;
           type: string;
           unitPrice: number;
        }[];
        orderNumber: string;
        paymentStatus: string;
        refundToCreditOffered: boolean;
        status: string;
        subtotal: number;
        tickets: {
           admissionStatus: string;
           barcode: string | null;
           bookingPass: boolean;
           codeReleasesAt: string | null;
           entitlementId: string;
           eventOccurrenceId: string | null;
           holderName: string | null;
           id: string;
           mediaType: string | null;
           name: string;
           seatLabel: string | null;
           security: "open" | "protected";
           slotId: string | null;
           status: string;
           type: string;
        }[];
        total: number;
        totalFees: number;
        totalTax: number;
      }
        | null;
     orderAccessToken: string | null;
  }>;
  holders: (cartId: string, requestOptions?: RequestOptions) => Promise<{
     addOns: {
        cartItemId: string;
        eligibleHolders: {
           holder:   | {
              cartItemId: string;
              unitIndex: number;
            }
              | {
              slotId: string;
            };
           kind: "person" | "vehicle" | "group";
           label: string | null;
           remaining: number | null;
        }[];
        holder:   | {
           cartItemId: string;
           unitIndex: number;
         }
           | {
           slotId: string;
         }
           | null;
        how: "explicit" | "automatic" | "unassigned";
        ticketTypeId: string;
        unitIndex: number;
     }[];
     existingHolders: {
        eventId: string;
        kind: "person" | "vehicle" | "group";
        label: string;
        orderId: string;
        slotId: string;
     }[];
     holders: {
        cartItemId: string;
        email: string | null;
        kind: "person" | "vehicle" | "group";
        label: string;
        name: string | null;
        naming: {
           changesCloseAt: string | null;
           maxNameChanges: number | null;
           nameChangesAllowed: boolean;
           namesCloseAt: string | null;
           policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
           required: boolean;
           transfersAllowed: boolean;
        };
        ticketTypeId: string;
        unitIndex: number;
     }[];
  }>;
  options: (cartId: string, requestOptions?: RequestOptions) => Promise<{
     cartId: string;
     delivery: {
        available: boolean;
        chosen: boolean;
        closesAt: string | null;
        default: boolean;
        fee: number;
        kind: "digital" | "physical";
        label: string;
        method: string;
        needsAddress: boolean;
        passId: string | null;
        reason: string | null;
     }[];
     payment: {
        available: boolean;
        chosen: boolean;
        closesAt: string | null;
        fee: number;
        label: string;
        method: string;
        pending: boolean;
        reason: string | null;
     }[];
     shipTo: {
        city: string;
        country: string;
        line1: string;
        line2?: string | null;
        name: string;
        phone?: string | null;
        postalCode: string;
        region?: string | null;
     } & Record<string, never>;
     surface: "online" | "box_office";
     total: number;
  }>;
  quote: (cartId: string, requestOptions?: RequestOptions) => Promise<{
     cartId: string;
     choices: {
        cardFunding?: "credit" | "debit" | "prepaid" | null;
        deliveryMethod?: string | null;
        paymentMethod?: string | null;
     };
     currency: string | null;
     fees: {
        amount: number;
        basis: "per_ticket" | "per_order";
        code: string;
        display: "included" | "separate";
        kind: string;
        label: string;
        optional: boolean;
        refundable: "always" | "never" | "until_fulfilled" | null;
        taxCategory: string | null;
        waivedFrom: number | null;
     }[];
     headline: {
        allIn: boolean;
        amount: number;
     };
     lines: {
        discount: number;
        fees: number;
        itemId: string;
        quantity: number;
        tax: number;
        total: number;
        unitPrice: number;
     }[];
     shipTo: {
        city: string;
        country: string;
        line1: string;
        line2?: string | null;
        name: string;
        phone?: string | null;
        postalCode: string;
        region?: string | null;
     } & Record<string, never>;
     taxes: {
        category: string;
        inclusive: boolean;
        jurisdiction: string;
        rate: string | null;
        supplier: string;
        tax: number;
        taxable: number;
        treatment: "standard" | "reduced" | "zero" | "exempt" | "outside_scope";
     }[];
     totals: {
        discounts: number;
        fees: number;
        giftCards: number;
        tax: number;
        tickets: number;
        total: number;
     };
  }>;
  releaseSeat: (cartId: string, occurrenceId: string, seat: string, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  removeCode: (cartId: string, codeId: string, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  removeGiftCard: (cartId: string, giftCardId: string, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  removeItem: (cartId: string, itemId: string, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  reserveSeats: (cartId: string, request: {
     eventOccurrenceId: string;
     planVersion?: string;
     seats: number[];
     ticketTypeId?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  }>;
  setHolders: (cartId: string, request: {
     addOns?: {
        cartItemId: string;
        holder:   | {
           cartItemId: string;
           unitIndex: number;
         }
           | {
           slotId: string;
         }
           | null;
        unitIndex: number;
     }[];
     holders?: {
        cartItemId: string;
        email?: string | null;
        name?: string | null;
        unitIndex: number;
     }[];
   }, requestOptions?: RequestOptions) => Promise<{
     addOns: {
        cartItemId: string;
        eligibleHolders: {
           holder:   | {
              cartItemId: string;
              unitIndex: number;
            }
              | {
              slotId: string;
            };
           kind: "person" | "vehicle" | "group";
           label: string | null;
           remaining: number | null;
        }[];
        holder:   | {
           cartItemId: string;
           unitIndex: number;
         }
           | {
           slotId: string;
         }
           | null;
        how: "explicit" | "automatic" | "unassigned";
        ticketTypeId: string;
        unitIndex: number;
     }[];
     existingHolders: {
        eventId: string;
        kind: "person" | "vehicle" | "group";
        label: string;
        orderId: string;
        slotId: string;
     }[];
     holders: {
        cartItemId: string;
        email: string | null;
        kind: "person" | "vehicle" | "group";
        label: string;
        name: string | null;
        naming: {
           changesCloseAt: string | null;
           maxNameChanges: number | null;
           nameChangesAllowed: boolean;
           namesCloseAt: string | null;
           policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
           required: boolean;
           transfersAllowed: boolean;
        };
        ticketTypeId: string;
        unitIndex: number;
     }[];
  }>;
};

Defined in: client.ts:875

Sales Carts methods

abandon#

abandon: (cartId: string, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Abandon cart Drop the cart: it becomes abandoned and every inventory hold it has is released now, rather than when it expires. Live calls this when a buyer signs out, so a cart never outlives the identity it was built under. A checked-out cart is refused (CART_NOT_ACTIVE); one already abandoned or expired is returned as it is.

Parameters
ParameterType
cartIdstring
requestOptions?RequestOptions
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

abandonSalesCart

addGiftCard#

addGiftCard: (cartId: string, request: {
  amount?: number;
  delivery: {
     message?: string | null;
     method: "email" | "post" | "box_office_print";
     recipientEmail?: string | null;
     recipientName?: string | null;
  };
  productId: string;
}, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Add a gift card to the cart Puts a gift card in the cart: a product, an amount it sells (GIFT_CARD_AMOUNT_INVALID otherwise), and how it goes - by email to its recipient (the buyer when no recipient is given), or by post with an order that is posted (GIFT_CARD_DELIVERY_NOT_ALLOWED otherwise). At checkout it becomes a gift card on the order, loaded once the order is paid and emailed with its code then. A gift card takes no discount and no fee; the cart's quote counts it under giftCards. At most ten per cart.

Parameters
ParameterTypeDescription
cartIdstring-
request{ amount?: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; productId: string; }-
request.amount?numberDescription Minor units: one of the product's amounts, or within its range Example 5000
request.delivery?{ message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }-
request.delivery.message?string | null-
request.delivery.method?"email" | "post" | "box_office_print"-
request.delivery.recipientEmail?string | nullFormat: email Description Where an emailed card goes; the buyer when left out
request.delivery.recipientName?string | null-
request.productId?string-
requestOptions?RequestOptions-
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

addSalesCartGiftCard

addItem#

addItem: (cartId: string, request: {
  categoryId: string;
  eventLayoutAreaId?: string;
  eventLayoutSeatIds?: string[];
  eventOccurrenceId: string;
  quantity?: number;
  ticketTypeId: string;
}, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Add cart item Add an item to the cart, taking a real inventory reservation with the channel's TTL

Parameters
ParameterType
cartIdstring
request{ categoryId: string; eventLayoutAreaId?: string; eventLayoutSeatIds?: string[]; eventOccurrenceId: string; quantity?: number; ticketTypeId: string; }
request.categoryIdstring
request.eventLayoutAreaId?string
request.eventLayoutSeatIds?string[]
request.eventOccurrenceId?string
request.quantity?number
request.ticketTypeId?string
requestOptions?RequestOptions
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

addSalesCartItem

applyCode#

applyCode: (cartId: string, request: {
  code: string;
}, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Apply a code to the cart Apply a code (TKT-343), by the text the buyer typed, to their cart: its effects - prices it unlocks, tags it acts as, its discount and its fee waiver - apply to this cart and the order it becomes, and to nothing else; nothing is granted to any customer, signed in or not. Every attempt counts against the code attempt limits (10 per cart and 30 per buyer per channel in 15 minutes, the buyer being the signed-in customer or else the address Live relays; 429 CODE_ATTEMPTS_EXCEEDED, also when the attempt cannot be counted). The code must be usable on this channel now (404 CODE_NOT_FOUND, 400 CODE_NOT_YET_VALID or CODE_EXPIRED, 409 CODE_EXHAUSTED) and not already on the cart (409 CODE_ALREADY_APPLIED); the cart must be open (409 CART_NOT_ACTIVE). Its use is counted when the order is made. The cart's codes lists what is applied.

Parameters
ParameterTypeDescription
cartIdstring-
request{ code: string; }-
request.codestringDescription The text the buyer typed. Matched case-insensitively, and counted against the code attempt limits Example BEST2FORYOU
requestOptions?RequestOptions-
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

applySalesCartCode

attachCustomer#

attachCustomer: (cartId: string, requestOptions?: RequestOptions) => Promise<{
  cart: {
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  };
  lines: {
     itemId: string;
     previousUnitPrice: number | null;
     reason:   | "SALE_CLOSED"
        | "NOT_AVAILABLE"
        | "SOLD_OUT"
        | "SALE_NOT_OPEN"
        | "TAG_REQUIRED"
        | null;
     status: "ok" | "repriced" | "unavailable";
     unitPrice: number;
  }[];
}>;

Attach the signed-in customer to a cart Link the customer named by the customer token (X-Customer-Token, never a body field) to this open cart, then re-evaluate every line through the offers engine for them: member prices open, and a line they cannot buy is reported in lines with the buyer's reason, never dropped. The cart must be on this channel, open, and nobody's or already this customer's (409 CART_CUSTOMER_MISMATCH otherwise); the customer must be one this channel may sell to (404 CUSTOMER_NOT_FOUND otherwise). Nothing is merged: a customer's other open cart on the channel is left to expire. Staff unlocks and everything else the cart holds stay with it. Live calls this right after a buyer signs in.

Parameters
ParameterType
cartIdstring
requestOptions?RequestOptions
Returns

Promise<{ cart: { codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }; lines: { itemId: string; previousUnitPrice: number | null; reason: | "SALE_CLOSED" | "NOT_AVAILABLE" | "SOLD_OUT" | "SALE_NOT_OPEN" | "TAG_REQUIRED" | null; status: "ok" | "repriced" | "unavailable"; unitPrice: number; }[]; }>

Operation Id

attachSalesCartCustomer

changeSeat#

changeSeat: (cartId: string, occurrenceId: string, seat: string, request: {
  ticketTypeId: string;
}, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Change a seat's ticket type Change the ticket type of a seat line, repriced; the reservation is untouched. The type must be on offer for the seat's category on this channel (422 TICKET_TYPE_NOT_FOR_SEAT). 404 CART_ITEM_NOT_FOUND when the seat is not in the cart.

Parameters
ParameterType
cartIdstring
occurrenceIdstring
seatstring
request{ ticketTypeId: string; }
request.ticketTypeIdstring
requestOptions?RequestOptions
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

changeSalesCartSeat

checkout#

checkout: (cartId: string, request: {
  customer?: {
     email: string;
     firstName?: string;
     lastName?: string;
     marketingConsent?: boolean;
     phone?: string;
  };
  customerNotes?: string;
  formResponses?: Record<string, any>;
  metadata?: Record<string, any>;
  returnUrl?: string;
}, requestOptions?: RequestOptions) => Promise<{
  cart: {
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  };
  checkout: {
     capabilitiesApplied: ("redirect" | "complete_form" | "await_approval")[];
     deferred: {
        fallback: string;
        key: string;
        requirement: string;
     }[];
     expiresAt: string | null;
     nextAction:   | {
        awaitApproval:   | {
           expiresAt: string | null;
           message: string;
           orderId: string;
           pollAfterSeconds: number;
           taskId: string | null;
         }
           | null;
        completeForm:   | {
           errors: {
              code: ...;
              index: ...;
              key: ...;
              lineId: ...;
              message: ...;
              source: ...;
           }[];
           form: {
              id: string;
              questions: ...[];
              version: number;
           };
         }
           | null;
        payment:   | {
           amount: number;
           connectedAccountId: string | null;
           currency: string;
           externalPaymentUrl: string | null;
           orderId: string;
           paymentId: string | null;
           paymentType: string | null;
           providerClientSecret: string | null;
           providerType: string | null;
           publishableKey: string | null;
           status: string | null;
         }
           | null;
        redirect:   | {
           expiresAt: string;
           reason: "complete_form" | "await_approval" | "payment" | "hook_input";
           returnUrl: string;
           url: string;
         }
           | null;
        type: "redirect" | "complete_form" | "await_approval" | "payment";
      }
        | null;
     status:   | "requires_input"
        | "requires_approval"
        | "requires_payment"
        | "processing"
        | "complete";
  };
  order:   | {
     createdAt: string;
     currency: string;
     expiresAt: string | null;
     id: string;
     isTest: boolean;
     items: {
        description: string | null;
        name: string;
        quantity: number;
        subtotal: number;
        type: string;
        unitPrice: number;
     }[];
     orderNumber: string;
     paymentStatus: string;
     refundToCreditOffered: boolean;
     status: string;
     subtotal: number;
     tickets: {
        admissionStatus: string;
        barcode: string | null;
        bookingPass: boolean;
        codeReleasesAt: string | null;
        entitlementId: string;
        eventOccurrenceId: string | null;
        holderName: string | null;
        id: string;
        mediaType: string | null;
        name: string;
        seatLabel: string | null;
        security: "open" | "protected";
        slotId: string | null;
        status: string;
        type: string;
     }[];
     total: number;
     totalFees: number;
     totalTax: number;
   }
     | null;
  orderAccessToken: string | null;
}>;

Checkout cart Check the cart out. From API version 2026-10-02 this is a loop: the answer's checkout says where the checkout is (requires_input, requires_approval, requires_payment, processing, complete) and what the client does next (nextAction), and the client does it and calls again until complete. A requirement the client cannot handle (TL-Client-Capabilities) is sent to the hosted completion page if the client declared redirect, and otherwise takes its fallback; a block fallback answers 422 REQUIREMENTS_NOT_MET. Safe to repeat: a cart already checked out answers its checkout as it stands, and an expired or cancelled order answers 409 CHECKOUT_CLOSED. Earlier versions answer as before, without checkout. Returns an order access token for possession-based guest access (confirmation page, payment status polling).

Parameters
ParameterType
cartIdstring
request{ customer?: { email: string; firstName?: string; lastName?: string; marketingConsent?: boolean; phone?: string; }; customerNotes?: string; formResponses?: Record<string, any>; metadata?: Record<string, any>; returnUrl?: string; }
request.customer?{ email: string; firstName?: string; lastName?: string; marketingConsent?: boolean; phone?: string; }
request.customer.email?string
request.customer.firstName?string
request.customer.lastName?string
request.customer.marketingConsent?boolean
request.customer.phone?string
request.customerNotes?string
request.formResponses?Record<string, any>
request.metadata?Record<string, any>
request.returnUrl?string
requestOptions?RequestOptions
Returns

Promise<{ cart: { codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }; checkout: { capabilitiesApplied: ("redirect" | "complete_form" | "await_approval")[]; deferred: { fallback: string; key: string; requirement: string; }[]; expiresAt: string | null; nextAction: | { awaitApproval: | { expiresAt: string | null; message: string; orderId: string; pollAfterSeconds: number; taskId: string | null; } | null; completeForm: | { errors: { code: ...; index: ...; key: ...; lineId: ...; message: ...; source: ...; }[]; form: { id: string; questions: ...[]; version: number; }; } | null; payment: | { amount: number; connectedAccountId: string | null; currency: string; externalPaymentUrl: string | null; orderId: string; paymentId: string | null; paymentType: string | null; providerClientSecret: string | null; providerType: string | null; publishableKey: string | null; status: string | null; } | null; redirect: | { expiresAt: string; reason: "complete_form" | "await_approval" | "payment" | "hook_input"; returnUrl: string; url: string; } | null; type: "redirect" | "complete_form" | "await_approval" | "payment"; } | null; status: | "requires_input" | "requires_approval" | "requires_payment" | "processing" | "complete"; }; order: | { createdAt: string; currency: string; expiresAt: string | null; id: string; isTest: boolean; items: { description: string | null; name: string; quantity: number; subtotal: number; type: string; unitPrice: number; }[]; orderNumber: string; paymentStatus: string; refundToCreditOffered: boolean; status: string; subtotal: number; tickets: { admissionStatus: string; barcode: string | null; bookingPass: boolean; codeReleasesAt: string | null; entitlementId: string; eventOccurrenceId: string | null; holderName: string | null; id: string; mediaType: string | null; name: string; seatLabel: string | null; security: "open" | "protected"; slotId: string | null; status: string; type: string; }[]; total: number; totalFees: number; totalTax: number; } | null; orderAccessToken: string | null; }>

Operation Id

checkoutSalesCart

choose#

choose: (cartId: string, request: {
  cardFunding?: "credit" | "debit" | "prepaid" | null;
  deliveryMethod?: string | null;
  paymentMethod?: string | null;
  shipTo?:   | {
     city: string;
     country: string;
     line1: string;
     line2?: string | null;
     name: string;
     phone?: string | null;
     postalCode: string;
     region?: string | null;
   }
     | null;
}, requestOptions?: RequestOptions) => Promise<{
  cartId: string;
  choices: {
     cardFunding?: "credit" | "debit" | "prepaid" | null;
     deliveryMethod?: string | null;
     paymentMethod?: string | null;
  };
  currency: string | null;
  fees: {
     amount: number;
     basis: "per_ticket" | "per_order";
     code: string;
     display: "included" | "separate";
     kind: string;
     label: string;
     optional: boolean;
     refundable: "always" | "never" | "until_fulfilled" | null;
     taxCategory: string | null;
     waivedFrom: number | null;
  }[];
  headline: {
     allIn: boolean;
     amount: number;
  };
  lines: {
     discount: number;
     fees: number;
     itemId: string;
     quantity: number;
     tax: number;
     total: number;
     unitPrice: number;
  }[];
  shipTo: {
     city: string;
     country: string;
     line1: string;
     line2?: string | null;
     name: string;
     phone?: string | null;
     postalCode: string;
     region?: string | null;
  } & Record<string, never>;
  taxes: {
     category: string;
     inclusive: boolean;
     jurisdiction: string;
     rate: string | null;
     supplier: string;
     tax: number;
     taxable: number;
     treatment: "standard" | "reduced" | "zero" | "exempt" | "outside_scope";
  }[];
  totals: {
     discounts: number;
     fees: number;
     giftCards: number;
     tax: number;
     tickets: number;
     total: number;
  };
}>;

Choose delivery and payment Set the cart's delivery method, payment method, and the card's funding once known; the quote re-prices and is returned. A payment method the cart is not offered gets 409 PAYMENT_METHOD_NOT_OFFERED, and so do invoice and bank transfer, which are staff-only; a delivery method 409 DELIVERY_METHOD_NOT_OFFERED; an unknown method 400.

Parameters
ParameterTypeDescription
cartIdstring-
request{ cardFunding?: "credit" | "debit" | "prepaid" | null; deliveryMethod?: string | null; paymentMethod?: string | null; shipTo?: | { city: string; country: string; line1: string; line2?: string | null; name: string; phone?: string | null; postalCode: string; region?: string | null; } | null; }-
request.cardFunding?"credit" | "debit" | "prepaid" | nullDescription The card's funding, once the processor reports it after card entry; a credit-only surcharge waits for it
request.deliveryMethod?string | nullDescription How the tickets reach the buyer: one of the options' available delivery methods. A delivery fee, where one applies, follows it; none chosen is the options' default (email) Example email
request.paymentMethod?string | nullDescription How the buyer will pay: one of the options' available payment methods. A surcharge, where one applies, follows it Example card
request.shipTo?| { city: string; country: string; line1: string; line2?: string | null; name: string; phone?: string | null; postalCode: string; region?: string | null; } | nullDescription Where a physical method (post) sends to. Checkout needs one when the delivery method needs an address (409 SHIP_TO_REQUIRED), and post to a country the policies exclude is not offered. Null clears it
requestOptions?RequestOptions-
Returns

Promise<{ cartId: string; choices: { cardFunding?: "credit" | "debit" | "prepaid" | null; deliveryMethod?: string | null; paymentMethod?: string | null; }; currency: string | null; fees: { amount: number; basis: "per_ticket" | "per_order"; code: string; display: "included" | "separate"; kind: string; label: string; optional: boolean; refundable: "always" | "never" | "until_fulfilled" | null; taxCategory: string | null; waivedFrom: number | null; }[]; headline: { allIn: boolean; amount: number; }; lines: { discount: number; fees: number; itemId: string; quantity: number; tax: number; total: number; unitPrice: number; }[]; shipTo: { city: string; country: string; line1: string; line2?: string | null; name: string; phone?: string | null; postalCode: string; region?: string | null; } & Record<string, never>; taxes: { category: string; inclusive: boolean; jurisdiction: string; rate: string | null; supplier: string; tax: number; taxable: number; treatment: "standard" | "reduced" | "zero" | "exempt" | "outside_scope"; }[]; totals: { discounts: number; fees: number; giftCards: number; tax: number; tickets: number; total: number; }; }>

Operation Id

setSalesCartChoices

create#

create: (request: {
  metadata?: Record<string, any>;
}, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Create cart Create a cart on this channel. Customer identity comes only from a verified customer token, never from the body.

Parameters
ParameterType
request{ metadata?: Record<string, any>; }
request.metadata?Record<string, any>
requestOptions?RequestOptions
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

createSalesCart

get#

get: (cartId: string, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Get cart Get a cart with its items

Parameters
ParameterType
cartIdstring
requestOptions?RequestOptions
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

getSalesCart

getCheckout#

getCheckout: (cartId: string, options?: {
  returnUrl?: string;
}, requestOptions?: RequestOptions) => Promise<{
  cart: {
     codes: {
        code: string;
        codeId: string;
        label: string;
     }[];
     currency: string | null;
     expiresAt: string;
     giftCards: {
        amount: number;
        delivery: {
           message?: string | null;
           method: "email" | "post" | "box_office_print";
           recipientEmail?: string | null;
           recipientName?: string | null;
        };
        id: string;
        productId: string;
     }[];
     id: string;
     items: {
        categoryName: string;
        currency: string;
        eventName: string;
        eventOccurrenceId: string;
        expiresAt?: string | null;
        id: string;
        label?: string;
        number?: string;
        priceCategoryId: string;
        quantity: number;
        row?: string;
        seat?: number;
        section?: string;
        subtotal: number;
        ticketTypeId: string;
        ticketTypeName: string;
        unitPrice: number;
     }[];
     itemsSubtotal: number;
     orderId: string | null;
     status: string;
  };
  checkout: {
     capabilitiesApplied: ("redirect" | "complete_form" | "await_approval")[];
     deferred: {
        fallback: string;
        key: string;
        requirement: string;
     }[];
     expiresAt: string | null;
     nextAction:   | {
        awaitApproval:   | {
           expiresAt: string | null;
           message: string;
           orderId: string;
           pollAfterSeconds: number;
           taskId: string | null;
         }
           | null;
        completeForm:   | {
           errors: {
              code: ...;
              index: ...;
              key: ...;
              lineId: ...;
              message: ...;
              source: ...;
           }[];
           form: {
              id: string;
              questions: ...[];
              version: number;
           };
         }
           | null;
        payment:   | {
           amount: number;
           connectedAccountId: string | null;
           currency: string;
           externalPaymentUrl: string | null;
           orderId: string;
           paymentId: string | null;
           paymentType: string | null;
           providerClientSecret: string | null;
           providerType: string | null;
           publishableKey: string | null;
           status: string | null;
         }
           | null;
        redirect:   | {
           expiresAt: string;
           reason: "complete_form" | "await_approval" | "payment" | "hook_input";
           returnUrl: string;
           url: string;
         }
           | null;
        type: "redirect" | "complete_form" | "await_approval" | "payment";
      }
        | null;
     status:   | "requires_input"
        | "requires_approval"
        | "requires_payment"
        | "processing"
        | "complete";
  };
  order:   | {
     createdAt: string;
     currency: string;
     expiresAt: string | null;
     id: string;
     isTest: boolean;
     items: {
        description: string | null;
        name: string;
        quantity: number;
        subtotal: number;
        type: string;
        unitPrice: number;
     }[];
     orderNumber: string;
     paymentStatus: string;
     refundToCreditOffered: boolean;
     status: string;
     subtotal: number;
     tickets: {
        admissionStatus: string;
        barcode: string | null;
        bookingPass: boolean;
        codeReleasesAt: string | null;
        entitlementId: string;
        eventOccurrenceId: string | null;
        holderName: string | null;
        id: string;
        mediaType: string | null;
        name: string;
        seatLabel: string | null;
        security: "open" | "protected";
        slotId: string | null;
        status: string;
        type: string;
     }[];
     total: number;
     totalFees: number;
     totalTax: number;
   }
     | null;
  orderAccessToken: string | null;
}>;

Get cart checkout The cart's checkout as it stands, in the same shape POST .../checkout answers: what a client reads after the hosted completion page returns the buyer, and what it polls while an approval or a payment is awaited. It changes nothing, except that a redirect it answers makes a fresh completion link. Once the cart has an order, the same access rule as reading the order applies (the order access token, or the verified customer), or the one-time code the hosted page returned the buyer with (TL-Checkout-Code), which is exchanged for the order access token; otherwise it is 404 ORDER_NOT_FOUND, whatever state the order is in. 409 CHECKOUT_NOT_STARTED for a cart that has not been checked out and has nothing to answer first.

Parameters
ParameterType
cartIdstring
options?{ returnUrl?: string; }
options.returnUrl?string
requestOptions?RequestOptions
Returns

Promise<{ cart: { codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }; checkout: { capabilitiesApplied: ("redirect" | "complete_form" | "await_approval")[]; deferred: { fallback: string; key: string; requirement: string; }[]; expiresAt: string | null; nextAction: | { awaitApproval: | { expiresAt: string | null; message: string; orderId: string; pollAfterSeconds: number; taskId: string | null; } | null; completeForm: | { errors: { code: ...; index: ...; key: ...; lineId: ...; message: ...; source: ...; }[]; form: { id: string; questions: ...[]; version: number; }; } | null; payment: | { amount: number; connectedAccountId: string | null; currency: string; externalPaymentUrl: string | null; orderId: string; paymentId: string | null; paymentType: string | null; providerClientSecret: string | null; providerType: string | null; publishableKey: string | null; status: string | null; } | null; redirect: | { expiresAt: string; reason: "complete_form" | "await_approval" | "payment" | "hook_input"; returnUrl: string; url: string; } | null; type: "redirect" | "complete_form" | "await_approval" | "payment"; } | null; status: | "requires_input" | "requires_approval" | "requires_payment" | "processing" | "complete"; }; order: | { createdAt: string; currency: string; expiresAt: string | null; id: string; isTest: boolean; items: { description: string | null; name: string; quantity: number; subtotal: number; type: string; unitPrice: number; }[]; orderNumber: string; paymentStatus: string; refundToCreditOffered: boolean; status: string; subtotal: number; tickets: { admissionStatus: string; barcode: string | null; bookingPass: boolean; codeReleasesAt: string | null; entitlementId: string; eventOccurrenceId: string | null; holderName: string | null; id: string; mediaType: string | null; name: string; seatLabel: string | null; security: "open" | "protected"; slotId: string | null; status: string; type: string; }[]; total: number; totalFees: number; totalTax: number; } | null; orderAccessToken: string | null; }>

Operation Id

getSalesCartCheckout

holders#

holders: (cartId: string, requestOptions?: RequestOptions) => Promise<{
  addOns: {
     cartItemId: string;
     eligibleHolders: {
        holder:   | {
           cartItemId: string;
           unitIndex: number;
         }
           | {
           slotId: string;
         };
        kind: "person" | "vehicle" | "group";
        label: string | null;
        remaining: number | null;
     }[];
     holder:   | {
        cartItemId: string;
        unitIndex: number;
      }
        | {
        slotId: string;
      }
        | null;
     how: "explicit" | "automatic" | "unassigned";
     ticketTypeId: string;
     unitIndex: number;
  }[];
  existingHolders: {
     eventId: string;
     kind: "person" | "vehicle" | "group";
     label: string;
     orderId: string;
     slotId: string;
  }[];
  holders: {
     cartItemId: string;
     email: string | null;
     kind: "person" | "vehicle" | "group";
     label: string;
     name: string | null;
     naming: {
        changesCloseAt: string | null;
        maxNameChanges: number | null;
        nameChangesAllowed: boolean;
        namesCloseAt: string | null;
        policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
        required: boolean;
        transfersAllowed: boolean;
     };
     ticketTypeId: string;
     unitIndex: number;
  }[];
}>;

Holders and add-ons Who each unit is for before checkout: a holder ("Guest 1" until named) per unit of a ticket type that creates one, and where each add-on goes, placed by the buyer, automatically (one holder, or one each) or not yet. Render the "who is this for?" picker from this. Lists the signed-in buyer's holders from earlier bookings that add-ons can also go to.

Parameters
ParameterType
cartIdstring
requestOptions?RequestOptions
Returns

Promise<{ addOns: { cartItemId: string; eligibleHolders: { holder: | { cartItemId: string; unitIndex: number; } | { slotId: string; }; kind: "person" | "vehicle" | "group"; label: string | null; remaining: number | null; }[]; holder: | { cartItemId: string; unitIndex: number; } | { slotId: string; } | null; how: "explicit" | "automatic" | "unassigned"; ticketTypeId: string; unitIndex: number; }[]; existingHolders: { eventId: string; kind: "person" | "vehicle" | "group"; label: string; orderId: string; slotId: string; }[]; holders: { cartItemId: string; email: string | null; kind: "person" | "vehicle" | "group"; label: string; name: string | null; naming: { changesCloseAt: string | null; maxNameChanges: number | null; nameChangesAllowed: boolean; namesCloseAt: string | null; policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate"; required: boolean; transfersAllowed: boolean; }; ticketTypeId: string; unitIndex: number; }[]; }>

Operation Id

getSalesCartHolders

options#

options: (cartId: string, requestOptions?: RequestOptions) => Promise<{
  cartId: string;
  delivery: {
     available: boolean;
     chosen: boolean;
     closesAt: string | null;
     default: boolean;
     fee: number;
     kind: "digital" | "physical";
     label: string;
     method: string;
     needsAddress: boolean;
     passId: string | null;
     reason: string | null;
  }[];
  payment: {
     available: boolean;
     chosen: boolean;
     closesAt: string | null;
     fee: number;
     label: string;
     method: string;
     pending: boolean;
     reason: string | null;
  }[];
  shipTo: {
     city: string;
     country: string;
     line1: string;
     line2?: string | null;
     name: string;
     phone?: string | null;
     postalCode: string;
     region?: string | null;
  } & Record<string, never>;
  surface: "online" | "box_office";
  total: number;
}>;

Delivery and payment options The delivery and payment methods this cart can choose, each with what choosing it adds to the total (a delivery fee, a surcharge where one applies), and why an unavailable one is not. A method closed by its cut-off before the event is still listed, unavailable, with its reason and closesAt, so the picker can show it greyed out. Invoice and bank transfer are staff-only and never listed here. Render the pickers from this; never hard-code a list.

Parameters
ParameterType
cartIdstring
requestOptions?RequestOptions
Returns

Promise<{ cartId: string; delivery: { available: boolean; chosen: boolean; closesAt: string | null; default: boolean; fee: number; kind: "digital" | "physical"; label: string; method: string; needsAddress: boolean; passId: string | null; reason: string | null; }[]; payment: { available: boolean; chosen: boolean; closesAt: string | null; fee: number; label: string; method: string; pending: boolean; reason: string | null; }[]; shipTo: { city: string; country: string; line1: string; line2?: string | null; name: string; phone?: string | null; postalCode: string; region?: string | null; } & Record<string, never>; surface: "online" | "box_office"; total: number; }>

Operation Id

getSalesCartOptions

quote#

quote: (cartId: string, requestOptions?: RequestOptions) => Promise<{
  cartId: string;
  choices: {
     cardFunding?: "credit" | "debit" | "prepaid" | null;
     deliveryMethod?: string | null;
     paymentMethod?: string | null;
  };
  currency: string | null;
  fees: {
     amount: number;
     basis: "per_ticket" | "per_order";
     code: string;
     display: "included" | "separate";
     kind: string;
     label: string;
     optional: boolean;
     refundable: "always" | "never" | "until_fulfilled" | null;
     taxCategory: string | null;
     waivedFrom: number | null;
  }[];
  headline: {
     allIn: boolean;
     amount: number;
  };
  lines: {
     discount: number;
     fees: number;
     itemId: string;
     quantity: number;
     tax: number;
     total: number;
     unitPrice: number;
  }[];
  shipTo: {
     city: string;
     country: string;
     line1: string;
     line2?: string | null;
     name: string;
     phone?: string | null;
     postalCode: string;
     region?: string | null;
  } & Record<string, never>;
  taxes: {
     category: string;
     inclusive: boolean;
     jurisdiction: string;
     rate: string | null;
     supplier: string;
     tax: number;
     taxable: number;
     treatment: "standard" | "reduced" | "zero" | "exempt" | "outside_scope";
  }[];
  totals: {
     discounts: number;
     fees: number;
     giftCards: number;
     tax: number;
     tickets: number;
     total: number;
  };
}>;

Quote the cart The cart priced with the choices made so far: each line, every fee with its kind, whether it is optional and how it is displayed, the totals, and the headline. Checkout charges exactly this total for the same cart and choices.

Parameters
ParameterType
cartIdstring
requestOptions?RequestOptions
Returns

Promise<{ cartId: string; choices: { cardFunding?: "credit" | "debit" | "prepaid" | null; deliveryMethod?: string | null; paymentMethod?: string | null; }; currency: string | null; fees: { amount: number; basis: "per_ticket" | "per_order"; code: string; display: "included" | "separate"; kind: string; label: string; optional: boolean; refundable: "always" | "never" | "until_fulfilled" | null; taxCategory: string | null; waivedFrom: number | null; }[]; headline: { allIn: boolean; amount: number; }; lines: { discount: number; fees: number; itemId: string; quantity: number; tax: number; total: number; unitPrice: number; }[]; shipTo: { city: string; country: string; line1: string; line2?: string | null; name: string; phone?: string | null; postalCode: string; region?: string | null; } & Record<string, never>; taxes: { category: string; inclusive: boolean; jurisdiction: string; rate: string | null; supplier: string; tax: number; taxable: number; treatment: "standard" | "reduced" | "zero" | "exempt" | "outside_scope"; }[]; totals: { discounts: number; fees: number; giftCards: number; tax: number; tickets: number; total: number; }; }>

Operation Id

getSalesCartQuote

releaseSeat#

releaseSeat: (cartId: string, occurrenceId: string, seat: string, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Give a seat back Release a seat now and remove its line from the cart. 404 CART_ITEM_NOT_FOUND when the seat is not in the cart.

Parameters
ParameterType
cartIdstring
occurrenceIdstring
seatstring
requestOptions?RequestOptions
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

releaseSalesCartSeat

removeCode#

removeCode: (cartId: string, codeId: string, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Remove a code from the cart Take a code off the buyer's cart, by the codeId the cart's codes lists. Its discount and fee waiver stop applying; a line it unlocked stays in the cart and is refused at checkout (TAG_REQUIRED), as offers would report it. 404 CODE_NOT_APPLIED when the cart does not hold it.

Parameters
ParameterType
cartIdstring
codeIdstring
requestOptions?RequestOptions
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

removeSalesCartCode

removeGiftCard#

removeGiftCard: (cartId: string, giftCardId: string, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Remove a gift card from the cart Takes a gift card out of the cart.

Parameters
ParameterType
cartIdstring
giftCardIdstring
requestOptions?RequestOptions
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

removeSalesCartGiftCard

removeItem#

removeItem: (cartId: string, itemId: string, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Remove cart item Remove an item from the cart, releasing its reservation

Parameters
ParameterType
cartIdstring
itemIdstring
requestOptions?RequestOptions
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

removeSalesCartItem

reserveSeats#

reserveSeats: (cartId: string, request: {
  eventOccurrenceId: string;
  planVersion?: string;
  seats: number[];
  ticketTypeId?: string;
}, requestOptions?: RequestOptions) => Promise<{
  codes: {
     code: string;
     codeId: string;
     label: string;
  }[];
  currency: string | null;
  expiresAt: string;
  giftCards: {
     amount: number;
     delivery: {
        message?: string | null;
        method: "email" | "post" | "box_office_print";
        recipientEmail?: string | null;
        recipientName?: string | null;
     };
     id: string;
     productId: string;
  }[];
  id: string;
  items: {
     categoryName: string;
     currency: string;
     eventName: string;
     eventOccurrenceId: string;
     expiresAt?: string | null;
     id: string;
     label?: string;
     number?: string;
     priceCategoryId: string;
     quantity: number;
     row?: string;
     seat?: number;
     section?: string;
     subtotal: number;
     ticketTypeId: string;
     ticketTypeName: string;
     unitPrice: number;
  }[];
  itemsSubtotal: number;
  orderId: string | null;
  status: string;
}>;

Reserve seats Reserve seats by index into the cart: tapping a seat reserves it. Each seat becomes its own cart line, at the ticket type named or, with none, its category's default type, and its reservation ends with the cart's. All or none, in one transaction. A seat that cannot be had answers 409 SEAT_UNAVAILABLE with unavailable and alternatives (blocks of the same size, all free, in the same row first and then the rows either side); a choice that would leave one empty seat between taken seats, or against a row end or an aisle, is 409 SINGLE_SEAT_GAP with strands and a shifted suggestion of the same size, which cannot be overridden here; a stale seat map is 409 PLAN_VERSION_CHANGED. 422 SEAT_LIMIT over the channel's maxTickets for this occurrence in this cart; 422 TICKET_TYPE_NOT_FOR_SEAT when the type is not on offer for a seat's category on this channel. 429 RATE_LIMITED past 30 reserve calls a minute for this buyer, or for ten minutes after their seats expired unbought three times within an hour. A seat already in the cart is left as it is. 404 OCCURRENCE_NOT_SEATED when the occurrence is not sold seated.

Parameters
ParameterType
cartIdstring
request{ eventOccurrenceId: string; planVersion?: string; seats: number[]; ticketTypeId?: string; }
request.eventOccurrenceIdstring
request.planVersion?string
request.seats?number[]
request.ticketTypeId?string
requestOptions?RequestOptions
Returns

Promise<{ codes: { code: string; codeId: string; label: string; }[]; currency: string | null; expiresAt: string; giftCards: { amount: number; delivery: { message?: string | null; method: "email" | "post" | "box_office_print"; recipientEmail?: string | null; recipientName?: string | null; }; id: string; productId: string; }[]; id: string; items: { categoryName: string; currency: string; eventName: string; eventOccurrenceId: string; expiresAt?: string | null; id: string; label?: string; number?: string; priceCategoryId: string; quantity: number; row?: string; seat?: number; section?: string; subtotal: number; ticketTypeId: string; ticketTypeName: string; unitPrice: number; }[]; itemsSubtotal: number; orderId: string | null; status: string; }>

Operation Id

reserveSalesCartSeats

setHolders#

setHolders: (cartId: string, request: {
  addOns?: {
     cartItemId: string;
     holder:   | {
        cartItemId: string;
        unitIndex: number;
      }
        | {
        slotId: string;
      }
        | null;
     unitIndex: number;
  }[];
  holders?: {
     cartItemId: string;
     email?: string | null;
     name?: string | null;
     unitIndex: number;
  }[];
}, requestOptions?: RequestOptions) => Promise<{
  addOns: {
     cartItemId: string;
     eligibleHolders: {
        holder:   | {
           cartItemId: string;
           unitIndex: number;
         }
           | {
           slotId: string;
         };
        kind: "person" | "vehicle" | "group";
        label: string | null;
        remaining: number | null;
     }[];
     holder:   | {
        cartItemId: string;
        unitIndex: number;
      }
        | {
        slotId: string;
      }
        | null;
     how: "explicit" | "automatic" | "unassigned";
     ticketTypeId: string;
     unitIndex: number;
  }[];
  existingHolders: {
     eventId: string;
     kind: "person" | "vehicle" | "group";
     label: string;
     orderId: string;
     slotId: string;
  }[];
  holders: {
     cartItemId: string;
     email: string | null;
     kind: "person" | "vehicle" | "group";
     label: string;
     name: string | null;
     naming: {
        changesCloseAt: string | null;
        maxNameChanges: number | null;
        nameChangesAllowed: boolean;
        namesCloseAt: string | null;
        policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
        required: boolean;
        transfersAllowed: boolean;
     };
     ticketTypeId: string;
     unitIndex: number;
  }[];
}>;

Name holders and place add-ons Replace the cart's holder names and add-on choices; checkout writes them as the order's holders. 409 ADD_ON_HOLDER_MISMATCH, ADD_ON_LIMIT_REACHED or ADD_ON_PARENT_REQUIRED, as checkout would refuse them; 400 for a unit not in the cart.

Parameters
ParameterTypeDescription
cartIdstring-
request{ addOns?: { cartItemId: string; holder: | { cartItemId: string; unitIndex: number; } | { slotId: string; } | null; unitIndex: number; }[]; holders?: { cartItemId: string; email?: string | null; name?: string | null; unitIndex: number; }[]; }-
request.addOns?{ cartItemId: string; holder: | { cartItemId: string; unitIndex: number; } | { slotId: string; } | null; unitIndex: number; }[]Description Where each add-on unit goes. One left out is placed automatically when that is unambiguous (one holder, or one each), else left for later
request.holders?{ cartItemId: string; email?: string | null; name?: string | null; unitIndex: number; }[]Description A name (and optionally an email) for units that make a holder; a unit left out stays "Guest N" until named
requestOptions?RequestOptions-
Returns

Promise<{ addOns: { cartItemId: string; eligibleHolders: { holder: | { cartItemId: string; unitIndex: number; } | { slotId: string; }; kind: "person" | "vehicle" | "group"; label: string | null; remaining: number | null; }[]; holder: | { cartItemId: string; unitIndex: number; } | { slotId: string; } | null; how: "explicit" | "automatic" | "unassigned"; ticketTypeId: string; unitIndex: number; }[]; existingHolders: { eventId: string; kind: "person" | "vehicle" | "group"; label: string; orderId: string; slotId: string; }[]; holders: { cartItemId: string; email: string | null; kind: "person" | "vehicle" | "group"; label: string; name: string | null; naming: { changesCloseAt: string | null; maxNameChanges: number | null; nameChangesAllowed: boolean; namesCloseAt: string | null; policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate"; required: boolean; transfersAllowed: boolean; }; ticketTypeId: string; unitIndex: number; }[]; }>

Operation Id

setSalesCartHolders

salesCustomerAuth#

salesCustomerAuth: {
  magicLink: (request: {
     email?: string;
     phone?: string;
  }, requestOptions?: RequestOptions) => Promise<boolean>;
};

Defined in: client.ts:802

Sales Customer Auth methods

magicLink: (request: {
  email?: string;
  phone?: string;
}, requestOptions?: RequestOptions) => Promise<boolean>;

Request magic link Start a sign-in for a customer. An email gets a 6-digit code, and a sign-in link carrying a separate long token when the channel has a magicLinkBaseUrl; a phone gets a 6-digit code by SMS. Both expire in 15 minutes. Always reports success with the same body - whether the contact is known is never revealed, and neither is whether the request was over its limit: at most 5 codes an hour per email or phone on a channel, and a request over that sends nothing. A new code replaces any earlier one for the same contact. Requesting a code creates no customer: an email that is not yet a customer becomes one when its code is redeemed.

Parameters
ParameterType
request{ email?: string; phone?: string; }
request.email?string
request.phone?string
requestOptions?RequestOptions
Returns

Promise<boolean>

Operation Id

requestSalesMagicLink

salesCustomers#

salesCustomers: {
  create: (request: {
     email: string;
     firstName?: string;
     lastName?: string;
     marketingConsent?: boolean;
     phone?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     email: string;
     firstName: string | null;
     id: string;
     lastName: string | null;
  }>;
  get: (customerId: string, requestOptions?: RequestOptions) => Promise<{
     email: string;
     firstName: string | null;
     id: string;
     lastName: string | null;
  }>;
  update: (customerId: string, request: {
     firstName?: string;
     lastName?: string;
     phone?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     email: string;
     firstName: string | null;
     id: string;
     lastName: string | null;
  }>;
};

Defined in: client.ts:1542

Sales Customers methods

create#

create: (request: {
  email: string;
  firstName?: string;
  lastName?: string;
  marketingConsent?: boolean;
  phone?: string;
}, requestOptions?: RequestOptions) => Promise<{
  email: string;
  firstName: string | null;
  id: string;
  lastName: string | null;
}>;

Create customer Provenance-scoped channel CRM (secret keys only). Reuses the org's existing record for the email and grants the channel access; there is no list or search.

Parameters
ParameterType
request{ email: string; firstName?: string; lastName?: string; marketingConsent?: boolean; phone?: string; }
request.emailstring
request.firstName?string
request.lastName?string
request.marketingConsent?boolean
request.phone?string
requestOptions?RequestOptions
Returns

Promise<{ email: string; firstName: string | null; id: string; lastName: string | null; }>

Operation Id

createSalesCustomer

get#

get: (customerId: string, requestOptions?: RequestOptions) => Promise<{
  email: string;
  firstName: string | null;
  id: string;
  lastName: string | null;
}>;

Get customer Get a customer the channel holds an access grant for (created through it, or who bought through it)

Parameters
ParameterType
customerIdstring
requestOptions?RequestOptions
Returns

Promise<{ email: string; firstName: string | null; id: string; lastName: string | null; }>

Operation Id

getSalesCustomer

update#

update: (customerId: string, request: {
  firstName?: string;
  lastName?: string;
  phone?: string;
}, requestOptions?: RequestOptions) => Promise<{
  email: string;
  firstName: string | null;
  id: string;
  lastName: string | null;
}>;

Update customer Update a customer the channel holds an access grant for. The update surface is deliberately small - email changes go through the org's staff.

Parameters
ParameterType
customerIdstring
request{ firstName?: string; lastName?: string; phone?: string; }
request.firstName?string
request.lastName?string
request.phone?string
requestOptions?RequestOptions
Returns

Promise<{ email: string; firstName: string | null; id: string; lastName: string | null; }>

Operation Id

updateSalesCustomer

salesCustomerTokens#

salesCustomerTokens: {
  create: (request: {
     proof: any;
   }, requestOptions?: RequestOptions) => Promise<{
     customer: {
        email: string;
        firstName: string | null;
        id: string;
        lastName: string | null;
     };
     customerToken: string;
     expiresIn: number;
  }>;
  refresh: (requestOptions?: RequestOptions) => Promise<{
     customer: {
        email: string;
        firstName: string | null;
        id: string;
        lastName: string | null;
     };
     customerToken: string;
     expiresIn: number;
  }>;
};

Defined in: client.ts:822

Sales Customer Tokens methods

create#

create: (request: {
  proof: any;
}, requestOptions?: RequestOptions) => Promise<{
  customer: {
     email: string;
     firstName: string | null;
     id: string;
     lastName: string | null;
  };
  customerToken: string;
  expiresIn: number;
}>;

Exchange identity proof for customer token Exchange an identity proof (magic-link code or partner assertion) for a short-lived customer token bound to this channel. Identity is exchanged, never asserted. A sign-in link token redeems on its own. A 6-digit code must name the email or phone it was sent to, and is checked against the newest code for it: a code allows 5 guesses and is then burned, and a contact allows 20 guesses an hour across its codes. Every failed code answers the same 401 INVALID_AUTH_CODE. A partner assertion must be signed with the channel's partnerIdentity key and carry iss, aud (this channel's id), iat (at most five minutes old), a jti not exchanged before, and email; sub, when present, is the partner's own id for the buyer and is matched before the email.

Parameters
ParameterType
request{ proof: any; }
request.proofany
requestOptions?RequestOptions
Returns

Promise<{ customer: { email: string; firstName: string | null; id: string; lastName: string | null; }; customerToken: string; expiresIn: number; }>

Operation Id

createSalesCustomerToken

refresh#

refresh: (requestOptions?: RequestOptions) => Promise<{
  customer: {
     email: string;
     firstName: string | null;
     id: string;
     lastName: string | null;
  };
  customerToken: string;
  expiresIn: number;
}>;

Refresh a customer token Re-signs a still-valid customer token (presented via X-Customer-Token) for a fresh 30 minutes, carrying the original 24-hour absolute ceiling forward. Once the ceiling passes the customer must re-authenticate.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<{ customer: { email: string; firstName: string | null; id: string; lastName: string | null; }; customerToken: string; expiresIn: number; }>

Operation Id

refreshSalesCustomerToken

salesGiftCards#

salesGiftCards: {
  balance: (request: {
     code: string;
   }, requestOptions?: RequestOptions) => Promise<{
     balance: number;
     currency: string;
     expiresAt: string | null;
     last4: string | null;
     status: "pending" | "active" | "frozen" | "void" | "expired";
  }>;
  list: (requestOptions?: RequestOptions) => Promise<{
     accountId: string | null;
     currency: string;
     deliveryMethods: ("email" | "post" | "box_office_print")[];
     description: string | null;
     eventId: string | null;
     fixedAmounts: number[] | null;
     id: string;
     maxAmount: number | null;
     minAmount: number | null;
     name: string;
     status: "active" | "archived";
  }[]>;
};

Defined in: client.ts:1227

Sales Gift Cards methods

balance#

balance: (request: {
  code: string;
}, requestOptions?: RequestOptions) => Promise<{
  balance: number;
  currency: string;
  expiresAt: string | null;
  last4: string | null;
  status: "pending" | "active" | "frozen" | "void" | "expired";
}>;

Check a gift card's balance What is on a gift card, by its code (in the body, never the URL: it is a bearer secret). Spend it on an order with POST /orders/{orderId}/stored-value-payments and code. STORED_VALUE_CODE_NOT_FOUND for a code that names none; rate limited.

Parameters
ParameterTypeDescription
request{ code: string; }-
request.codestringExample 7KQ2-MZ9X-LP3R-TV8W
requestOptions?RequestOptions-
Returns

Promise<{ balance: number; currency: string; expiresAt: string | null; last4: string | null; status: "pending" | "active" | "frozen" | "void" | "expired"; }>

Operation Id

getSalesGiftCardBalance

list#

list: (requestOptions?: RequestOptions) => Promise<{
  accountId: string | null;
  currency: string;
  deliveryMethods: ("email" | "post" | "box_office_print")[];
  description: string | null;
  eventId: string | null;
  fixedAmounts: number[] | null;
  id: string;
  maxAmount: number | null;
  minAmount: number | null;
  name: string;
  status: "active" | "archived";
}[]>;

List gift cards on sale The gift cards this organisation sells: fixed amounts or a range, the currency, and how each may be delivered. Add one to a cart with POST /carts/{cartId}/gift-cards.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<{ accountId: string | null; currency: string; deliveryMethods: ("email" | "post" | "box_office_print")[]; description: string | null; eventId: string | null; fixedAmounts: number[] | null; id: string; maxAmount: number | null; minAmount: number | null; name: string; status: "active" | "archived"; }[]>

Operation Id

listSalesGiftCardProducts

salesKnowledge#

salesKnowledge: {
  facts: (options?: {
     eventId?: string;
     language?: string;
     occurrenceId?: string;
     venueId?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     key:   | "doors_open"
        | "start_time"
        | "running_time"
        | "interval"
        | "age_guidance"
        | "event_name"
        | "venue_name"
        | "address"
        | "access_features"
        | "parking"
        | "bag_policy"
        | "public_transport"
        | "food_and_drink"
        | "cloakroom";
     label: string;
     text: string;
     value?: unknown;
  }[]>;
  getArticle: (articleId: string, options?: {
     eventId?: string;
     language?: string;
     occurrenceId?: string;
     venueId?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     body: string;
     category: string | null;
     id: string;
     language: string;
     scopeType:   | "platform"
        | "organisation"
        | "account"
        | "venue"
        | "sales_channel"
        | "event"
        | "occurrence";
     slug: string;
     tags: string[];
     title: string;
     updatedAt: string;
  }>;
  listArticles: (options?: {
     eventId?: string;
     language?: string;
     occurrenceId?: string;
     venueId?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     body: string;
     category: string | null;
     id: string;
     language: string;
     scopeType:   | "platform"
        | "organisation"
        | "account"
        | "venue"
        | "sales_channel"
        | "event"
        | "occurrence";
     slug: string;
     tags: string[];
     title: string;
     updatedAt: string;
  }[]>;
  refundPolicy: (options?: {
     eventId?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     customerMessage: string | null;
     exchanges: string;
     refunds: string;
     source: "organisation" | "account" | "event" | "default";
     text: string;
  }>;
  search: (options?: {
     eventId?: string;
     limit?: number;
     q: string;
   }, requestOptions?: RequestOptions) => Promise<{
     category: string | null;
     id: string;
     rank: number;
     scopeType:   | "platform"
        | "organisation"
        | "account"
        | "venue"
        | "sales_channel"
        | "event"
        | "occurrence";
     slug: string;
     snippet: string;
     title: string;
  }[]>;
};

Defined in: client.ts:1591

Sales Knowledge methods

facts#

facts: (options?: {
  eventId?: string;
  language?: string;
  occurrenceId?: string;
  venueId?: string;
}, requestOptions?: RequestOptions) => Promise<{
  key:   | "doors_open"
     | "start_time"
     | "running_time"
     | "interval"
     | "age_guidance"
     | "event_name"
     | "venue_name"
     | "address"
     | "access_features"
     | "parking"
     | "bag_policy"
     | "public_transport"
     | "food_and_drink"
     | "cloakroom";
  label: string;
  text: string;
  value?: unknown;
}[]>;

Get the resolved facts Door times, running time, age guidance, access, parking and the rest, resolved for this channel and the event, occurrence or venue given; where the system holds the field (an occurrence's start, a venue's address) the fact is that field.

Parameters
ParameterType
options?{ eventId?: string; language?: string; occurrenceId?: string; venueId?: string; }
options.eventId?string
options.language?string
options.occurrenceId?string
options.venueId?string
requestOptions?RequestOptions
Returns

Promise<{ key: | "doors_open" | "start_time" | "running_time" | "interval" | "age_guidance" | "event_name" | "venue_name" | "address" | "access_features" | "parking" | "bag_policy" | "public_transport" | "food_and_drink" | "cloakroom"; label: string; text: string; value?: unknown; }[]>

Operation Id

getSalesKnowledgeFacts

getArticle#

getArticle: (articleId: string, options?: {
  eventId?: string;
  language?: string;
  occurrenceId?: string;
  venueId?: string;
}, requestOptions?: RequestOptions) => Promise<{
  body: string;
  category: string | null;
  id: string;
  language: string;
  scopeType:   | "platform"
     | "organisation"
     | "account"
     | "venue"
     | "sales_channel"
     | "event"
     | "occurrence";
  slug: string;
  tags: string[];
  title: string;
  updatedAt: string;
}>;

Get a help article One public article, rendered, if it applies on this channel (and to the event, when given); 404 otherwise, including when a more specific article replaced it.

Parameters
ParameterType
articleIdstring
options?{ eventId?: string; language?: string; occurrenceId?: string; venueId?: string; }
options.eventId?string
options.language?string
options.occurrenceId?string
options.venueId?string
requestOptions?RequestOptions
Returns

Promise<{ body: string; category: string | null; id: string; language: string; scopeType: | "platform" | "organisation" | "account" | "venue" | "sales_channel" | "event" | "occurrence"; slug: string; tags: string[]; title: string; updatedAt: string; }>

Operation Id

getSalesKnowledgeArticle

listArticles#

listArticles: (options?: {
  eventId?: string;
  language?: string;
  occurrenceId?: string;
  venueId?: string;
}, requestOptions?: RequestOptions) => Promise<{
  body: string;
  category: string | null;
  id: string;
  language: string;
  scopeType:   | "platform"
     | "organisation"
     | "account"
     | "venue"
     | "sales_channel"
     | "event"
     | "occurrence";
  slug: string;
  tags: string[];
  title: string;
  updatedAt: string;
}[]>;

List the channel's help articles The published public articles that apply on this channel (and to an event listed on it, when given), most specific first, with placeholders rendered from the facts. Below Platform (an organisation whose plan has no support.knowledgeBase) only the platform's default articles apply, and the facts are the event's, the occurrence's and the venue's.

Parameters
ParameterType
options?{ eventId?: string; language?: string; occurrenceId?: string; venueId?: string; }
options.eventId?string
options.language?string
options.occurrenceId?string
options.venueId?string
requestOptions?RequestOptions
Returns

Promise<{ body: string; category: string | null; id: string; language: string; scopeType: | "platform" | "organisation" | "account" | "venue" | "sales_channel" | "event" | "occurrence"; slug: string; tags: string[]; title: string; updatedAt: string; }[]>

Operation Id

listSalesKnowledgeArticles

refundPolicy#

refundPolicy: (options?: {
  eventId?: string;
}, requestOptions?: RequestOptions) => Promise<{
  customerMessage: string | null;
  exchanges: string;
  refunds: string;
  source: "organisation" | "account" | "event" | "default";
  text: string;
}>;

Get the refund and exchange policy text Generated from the policy enforced on an order placed on this channel (for this event, when given), plus the organisation's customerMessage. Never written by hand.

Parameters
ParameterType
options?{ eventId?: string; }
options.eventId?string
requestOptions?RequestOptions
Returns

Promise<{ customerMessage: string | null; exchanges: string; refunds: string; source: "organisation" | "account" | "event" | "default"; text: string; }>

Operation Id

getSalesRefundPolicyText

search#

search: (options?: {
  eventId?: string;
  limit?: number;
  q: string;
}, requestOptions?: RequestOptions) => Promise<{
  category: string | null;
  id: string;
  rank: number;
  scopeType:   | "platform"
     | "organisation"
     | "account"
     | "venue"
     | "sales_channel"
     | "event"
     | "occurrence";
  slug: string;
  snippet: string;
  title: string;
}[]>;

Search the channel's help articles Full-text search over the public articles that apply on this channel, ranked (below Platform, the platform's default articles only). No search reaches beyond them.

Parameters
ParameterType
options?{ eventId?: string; limit?: number; q: string; }
options.eventId?string
options.limit?number
options.q?string
requestOptions?RequestOptions
Returns

Promise<{ category: string | null; id: string; rank: number; scopeType: | "platform" | "organisation" | "account" | "venue" | "sales_channel" | "event" | "occurrence"; slug: string; snippet: string; title: string; }[]>

Operation Id

searchSalesKnowledge

salesListings#

salesListings: {
  list: (requestOptions?: RequestOptions) => Promise<{
     channel: {
        id: string;
        name: string;
        slug: string;
     };
     listings: {
        availability:   | {
           opensAt: string | null;
           state:   | "on_sale"
              | "not_yet_on_sale"
              | "off_sale"
              | "sold_out"
              | "locked"
              | "hidden"
              | null;
         }
           | null;
        closesAt: string | null;
        currency: string | null;
        eventId: string;
        id: string;
        imageUrl: string | null;
        name: string | null;
        nextOccurrenceAt: string | null;
        opensAt: string | null;
        priceFrom: number | null;
        prices:   | {
           currency: string | null;
           feesIncluded: true;
           from: number | null;
           to: number | null;
         }
           | null;
        sellable: boolean;
        shortDescription: string | null;
        subtitle: string | null;
        venueCity: string | null;
        venueName: string | null;
     }[];
  }>;
};

Defined in: client.ts:856

Sales Listings methods

list#

list: (requestOptions?: RequestOptions) => Promise<{
  channel: {
     id: string;
     name: string;
     slug: string;
  };
  listings: {
     availability:   | {
        opensAt: string | null;
        state:   | "on_sale"
           | "not_yet_on_sale"
           | "off_sale"
           | "sold_out"
           | "locked"
           | "hidden"
           | null;
      }
        | null;
     closesAt: string | null;
     currency: string | null;
     eventId: string;
     id: string;
     imageUrl: string | null;
     name: string | null;
     nextOccurrenceAt: string | null;
     opensAt: string | null;
     priceFrom: number | null;
     prices:   | {
        currency: string | null;
        feesIncluded: true;
        from: number | null;
        to: number | null;
      }
        | null;
     sellable: boolean;
     shortDescription: string | null;
     subtitle: string | null;
     venueCity: string | null;
     venueName: string | null;
  }[];
}>;

List active listings What is on sale through this channel right now. The channel is resolved from the key, never from a parameter. Each listing carries the offers engine's summary for this buyer (one evaluation for the whole list): prices, what one ticket costs with fees from the cheapest offer to the dearest, and availability, the event's best state. priceFrom is the older face value, fees excluded, and is deprecated.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<{ channel: { id: string; name: string; slug: string; }; listings: { availability: | { opensAt: string | null; state: | "on_sale" | "not_yet_on_sale" | "off_sale" | "sold_out" | "locked" | "hidden" | null; } | null; closesAt: string | null; currency: string | null; eventId: string; id: string; imageUrl: string | null; name: string | null; nextOccurrenceAt: string | null; opensAt: string | null; priceFrom: number | null; prices: | { currency: string | null; feesIncluded: true; from: number | null; to: number | null; } | null; sellable: boolean; shortDescription: string | null; subtitle: string | null; venueCity: string | null; venueName: string | null; }[]; }>

Operation Id

listSalesListings

salesMyOrders#

salesMyOrders: {
  credit: (requestOptions?: RequestOptions) => Promise<{
     accountId: string | null;
     balance: number;
     currency: string;
     eventId: string | null;
     expiresAt: string | null;
     id: string;
     status: "active" | "frozen";
  }[]>;
  creditActivity: (storedValueAccountId: string, options?: {
     cursor?: string;
     limit?: number;
   }, requestOptions?: RequestOptions) => Promise<{
     credit: {
        balance: number;
        currency: string;
        expiresAt: string | null;
        id: string;
        status: "pending" | "active" | "frozen" | "void" | "expired";
     };
     movements: {
        amount: number;
        kind:   | "credit"
           | "refund"
           | "redeem"
           | "adjust"
           | "expire"
           | "dormancy_fee"
           | "reversal"
           | "other";
        occurredAt: string;
        orderId: string | null;
        orderNumber: string | null;
     }[];
     nextCursor: string | null;
  }>;
  list: (requestOptions?: RequestOptions) => Promise<{
     createdAt: string;
     currency: string;
     expiresAt: string | null;
     id: string;
     isTest: boolean;
     items: {
        description: string | null;
        name: string;
        quantity: number;
        subtotal: number;
        type: string;
        unitPrice: number;
     }[];
     orderNumber: string;
     paymentStatus: string;
     refundToCreditOffered: boolean;
     status: string;
     subtotal: number;
     tickets: {
        admissionStatus: string;
        barcode: string | null;
        bookingPass: boolean;
        codeReleasesAt: string | null;
        entitlementId: string;
        eventOccurrenceId: string | null;
        holderName: string | null;
        id: string;
        mediaType: string | null;
        name: string;
        seatLabel: string | null;
        security: "open" | "protected";
        slotId: string | null;
        status: string;
        type: string;
     }[];
     total: number;
     totalFees: number;
     totalTax: number;
  }[]>;
};

Defined in: client.ts:1174

Sales My Orders methods

credit#

credit: (requestOptions?: RequestOptions) => Promise<{
  accountId: string | null;
  balance: number;
  currency: string;
  eventId: string | null;
  expiresAt: string | null;
  id: string;
  status: "active" | "frozen";
}[]>;

Get my account credit The verified customer's account credit with this organisation: each open balance and what is on it. Spend it on an order with POST /orders/{orderId}/stored-value-payments. Requires a customer token.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<{ accountId: string | null; balance: number; currency: string; eventId: string | null; expiresAt: string | null; id: string; status: "active" | "frozen"; }[]>

Operation Id

getMySalesCredit

creditActivity#

creditActivity: (storedValueAccountId: string, options?: {
  cursor?: string;
  limit?: number;
}, requestOptions?: RequestOptions) => Promise<{
  credit: {
     balance: number;
     currency: string;
     expiresAt: string | null;
     id: string;
     status: "pending" | "active" | "frozen" | "void" | "expired";
  };
  movements: {
     amount: number;
     kind:   | "credit"
        | "refund"
        | "redeem"
        | "adjust"
        | "expire"
        | "dormancy_fee"
        | "reversal"
        | "other";
     occurredAt: string;
     orderId: string | null;
     orderNumber: string | null;
  }[];
  nextCursor: string | null;
}>;

Get my account credit activity What has moved on one of the verified customer's own credit balances, newest first: each amount, what it was, when, and the order it belongs to. Never who made a change or the organisation's notes on it. A balance that is not the customer's own account credit is STORED_VALUE_ACCOUNT_NOT_FOUND. Requires a customer token.

Parameters
ParameterType
storedValueAccountIdstring
options?{ cursor?: string; limit?: number; }
options.cursor?string
options.limit?number
requestOptions?RequestOptions
Returns

Promise<{ credit: { balance: number; currency: string; expiresAt: string | null; id: string; status: "pending" | "active" | "frozen" | "void" | "expired"; }; movements: { amount: number; kind: | "credit" | "refund" | "redeem" | "adjust" | "expire" | "dormancy_fee" | "reversal" | "other"; occurredAt: string; orderId: string | null; orderNumber: string | null; }[]; nextCursor: string | null; }>

Operation Id

getMySalesCreditActivity

list#

list: (requestOptions?: RequestOptions) => Promise<{
  createdAt: string;
  currency: string;
  expiresAt: string | null;
  id: string;
  isTest: boolean;
  items: {
     description: string | null;
     name: string;
     quantity: number;
     subtotal: number;
     type: string;
     unitPrice: number;
  }[];
  orderNumber: string;
  paymentStatus: string;
  refundToCreditOffered: boolean;
  status: string;
  subtotal: number;
  tickets: {
     admissionStatus: string;
     barcode: string | null;
     bookingPass: boolean;
     codeReleasesAt: string | null;
     entitlementId: string;
     eventOccurrenceId: string | null;
     holderName: string | null;
     id: string;
     mediaType: string | null;
     name: string;
     seatLabel: string | null;
     security: "open" | "protected";
     slotId: string | null;
     status: string;
     type: string;
  }[];
  total: number;
  totalFees: number;
  totalTax: number;
}[]>;

List my orders The verified customer's own orders. Requires a customer token - orders cannot be listed with key or possession credentials alone.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<{ createdAt: string; currency: string; expiresAt: string | null; id: string; isTest: boolean; items: { description: string | null; name: string; quantity: number; subtotal: number; type: string; unitPrice: number; }[]; orderNumber: string; paymentStatus: string; refundToCreditOffered: boolean; status: string; subtotal: number; tickets: { admissionStatus: string; barcode: string | null; bookingPass: boolean; codeReleasesAt: string | null; entitlementId: string; eventOccurrenceId: string | null; holderName: string | null; id: string; mediaType: string | null; name: string; seatLabel: string | null; security: "open" | "protected"; slotId: string | null; status: string; type: string; }[]; total: number; totalFees: number; totalTax: number; }[]>

Operation Id

listMySalesOrders

salesOrderPayments#

salesOrderPayments: {
  capturePaypal: (orderId: string, paymentId: string, requestOptions?: RequestOptions) => Promise<{
     captureId: string | null;
     orderId: string;
     orderStatus: string | null;
     paymentId: string;
     reason: string | null;
     status: "pending" | "succeeded" | "failed";
  }>;
  confirmSandbox: (orderId: string, paymentId: string, request: {
     token?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     failureCode: string | null;
     failureMessage: string | null;
     ingestStatus: "received" | "duplicate";
     outcome: "succeeded" | "failed";
     paymentId: string;
  }>;
  create: (orderId: string, request: {
     paymentType?: "online_card" | "online_bank_transfer" | "online_wallet";
     returnUrl?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     adyen:   | {
        clientKey: string;
        environment: "test" | "live";
        sessionData: string;
        sessionId: string;
      }
        | null;
     amount: number;
     connectedAccountId: string | null;
     currency: string;
     externalPaymentUrl: string | null;
     id: string;
     orderId: string;
     paymentType: string;
     providerClientSecret: string | null;
     providerType: string | null;
     publishableKey: string | null;
     status: string;
  }>;
  createPaypal: (orderId: string, request: {
     returnUrl?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     payment: {
        adyen:   | {
           clientKey: string;
           environment: "test" | "live";
           sessionData: string;
           sessionId: string;
         }
           | null;
        amount: number;
        connectedAccountId: string | null;
        currency: string;
        externalPaymentUrl: string | null;
        id: string;
        orderId: string;
        paymentType: string;
        providerClientSecret: string | null;
        providerType: string | null;
        publishableKey: string | null;
        status: string;
     };
     paypal: {
        approveUrl: string | null;
        clientId: string;
        currency: string;
        environment: "live" | "sandbox";
        intent: "capture";
        merchantId: string | null;
        orderId: string;
     };
  }>;
  readAdyenSessionResult: (orderId: string, paymentId: string, request: {
     sessionResult: string;
   }, requestOptions?: RequestOptions) => Promise<{
     outcome: "pending" | "active" | "expired" | "refused" | "confirming" | "cancelled";
     paymentId: string;
     paymentStatus: string;
     sessionStatus:   | "active"
        | "expired"
        | "completed"
        | "paymentPending"
        | "refused"
        | "canceled";
  }>;
  spendStoredValue: (orderId: string, request: {
     amount?: number;
     code?: string;
     storedValueAccountId?: string;
   }, requestOptions?: RequestOptions) => Promise<{
     order: {
        id: string;
        paymentStatus: string;
        status: string;
        stillDue: number;
        total: number;
        totalPaid: number;
     };
     payment: {
        amount: number;
        currency: string;
        paymentId: string;
        status: "succeeded";
     };
     storedValue: {
        balance: number;
        id: string;
        instrument: "gift_card" | "account_credit" | "pass_balance";
     };
  }>;
};

Defined in: client.ts:1261

Sales Order Payments methods

capturePaypal#

capturePaypal: (orderId: string, paymentId: string, requestOptions?: RequestOptions) => Promise<{
  captureId: string | null;
  orderId: string;
  orderStatus: string | null;
  paymentId: string;
  reason: string | null;
  status: "pending" | "succeeded" | "failed";
}>;

Capture an approved PayPal payment The PayPal JS SDK's onApprove step: captures the approved PayPal order, and a capture PayPal completes pays the order. 'pending' when PayPal holds the capture (it settles when PayPal releases it); 'failed' when PayPal declines it. Capturing twice is safe. When PayPal declines the funding source the buyer chose, the answer is 400 PAYPAL_INSTRUMENT_DECLINED: restart the buttons (actions.restart()). The same access rule as reading the order applies, and the payment must belong to it.

Parameters
ParameterType
orderIdstring
paymentIdstring
requestOptions?RequestOptions
Returns

Promise<{ captureId: string | null; orderId: string; orderStatus: string | null; paymentId: string; reason: string | null; status: "pending" | "succeeded" | "failed"; }>

Operation Id

captureSalesOrderPaypalPayment

confirmSandbox#

confirmSandbox: (orderId: string, paymentId: string, request: {
  token?: string;
}, requestOptions?: RequestOptions) => Promise<{
  failureCode: string | null;
  failureMessage: string | null;
  ingestStatus: "received" | "duplicate";
  outcome: "succeeded" | "failed";
  paymentId: string;
}>;

Confirm a sandbox payment The sandbox PSP's checkout page, on the surface the buyer is already on. Confirms a payment taken on a 'sandbox' provider for a TEST order: the test token decides the outcome, and the sandbox raises its signed webhook into the same ingress a real PSP posts to, so the order confirms and issues tickets - or declines - down the real path. 'tl_test_pm_success' captures, 'tl_test_pm_decline', 'tl_test_pm_insufficient_funds' and 'tl_test_pm_expired_card' decline with that failure code; the default is 'tl_test_pm_success'. Confirming the same token twice is a no-op, reported as ingestStatus 'duplicate'. The same access rule as reading the order applies, and the payment must belong to it.

Parameters
ParameterType
orderIdstring
paymentIdstring
request{ token?: string; }
request.token?string
requestOptions?RequestOptions
Returns

Promise<{ failureCode: string | null; failureMessage: string | null; ingestStatus: "received" | "duplicate"; outcome: "succeeded" | "failed"; paymentId: string; }>

Operation Id

confirmSalesOrderSandboxPayment

create#

create: (orderId: string, request: {
  paymentType?: "online_card" | "online_bank_transfer" | "online_wallet";
  returnUrl?: string;
}, requestOptions?: RequestOptions) => Promise<{
  adyen:   | {
     clientKey: string;
     environment: "test" | "live";
     sessionData: string;
     sessionId: string;
   }
     | null;
  amount: number;
  connectedAccountId: string | null;
  currency: string;
  externalPaymentUrl: string | null;
  id: string;
  orderId: string;
  paymentType: string;
  providerClientSecret: string | null;
  providerType: string | null;
  publishableKey: string | null;
  status: string;
}>;

Create order payment Initiate payment for the order's outstanding balance through the channel's payment provider

Parameters
ParameterType
orderIdstring
request{ paymentType?: "online_card" | "online_bank_transfer" | "online_wallet"; returnUrl?: string; }
request.paymentType?"online_card" | "online_bank_transfer" | "online_wallet"
request.returnUrl?string
requestOptions?RequestOptions
Returns

Promise<{ adyen: | { clientKey: string; environment: "test" | "live"; sessionData: string; sessionId: string; } | null; amount: number; connectedAccountId: string | null; currency: string; externalPaymentUrl: string | null; id: string; orderId: string; paymentType: string; providerClientSecret: string | null; providerType: string | null; publishableKey: string | null; status: string; }>

Operation Id

createSalesOrderPayment

createPaypal#

createPaypal: (orderId: string, request: {
  returnUrl?: string;
}, requestOptions?: RequestOptions) => Promise<{
  payment: {
     adyen:   | {
        clientKey: string;
        environment: "test" | "live";
        sessionData: string;
        sessionId: string;
      }
        | null;
     amount: number;
     connectedAccountId: string | null;
     currency: string;
     externalPaymentUrl: string | null;
     id: string;
     orderId: string;
     paymentType: string;
     providerClientSecret: string | null;
     providerType: string | null;
     publishableKey: string | null;
     status: string;
  };
  paypal: {
     approveUrl: string | null;
     clientId: string;
     currency: string;
     environment: "live" | "sandbox";
     intent: "capture";
     merchantId: string | null;
     orderId: string;
  };
}>;

Start a PayPal payment The PayPal JS SDK's createOrder step: creates the PayPal order for the order's outstanding balance on the organisation's own PayPal connection, and answers its id with what the SDK is loaded with (client id, currency, intent capture). PayPal must be offered for the order: allowed by the payment method policies, and a PayPal connection for the order's mode (sandbox for a test order) that holds the order's currency; otherwise 400 PAYPAL_NOT_OFFERED. The same access rule as reading the order applies.

Parameters
ParameterType
orderIdstring
request{ returnUrl?: string; }
request.returnUrl?string
requestOptions?RequestOptions
Returns

Promise<{ payment: { adyen: | { clientKey: string; environment: "test" | "live"; sessionData: string; sessionId: string; } | null; amount: number; connectedAccountId: string | null; currency: string; externalPaymentUrl: string | null; id: string; orderId: string; paymentType: string; providerClientSecret: string | null; providerType: string | null; publishableKey: string | null; status: string; }; paypal: { approveUrl: string | null; clientId: string; currency: string; environment: "live" | "sandbox"; intent: "capture"; merchantId: string | null; orderId: string; }; }>

Operation Id

createSalesOrderPaypalPayment

readAdyenSessionResult#

readAdyenSessionResult: (orderId: string, paymentId: string, request: {
  sessionResult: string;
}, requestOptions?: RequestOptions) => Promise<{
  outcome: "pending" | "active" | "expired" | "refused" | "confirming" | "cancelled";
  paymentId: string;
  paymentStatus: string;
  sessionStatus:   | "active"
     | "expired"
     | "completed"
     | "paymentPending"
     | "refused"
     | "canceled";
}>;

Read an Adyen Drop-in result For an order paid through Adyen Drop-in (TKT-539): hand over the sessionResult Drop-in finished with, and read back what Adyen says of the session. It confirms nothing: an Adyen payment succeeds only when Adyen's AUTHORISATION webhook says so, so outcome is confirming until paymentStatus reads succeeded; poll the order or the payment. The same access rule as reading the order applies, and the payment must belong to it.

Parameters
ParameterTypeDescription
orderIdstring-
paymentIdstring-
request{ sessionResult: string; }-
request.sessionResultstringDescription The sessionResult from Drop-in's onPaymentCompleted, or the return URL's query Example X3XtfGC9!H4sIAAAAAAAA...
requestOptions?RequestOptions-
Returns

Promise<{ outcome: "pending" | "active" | "expired" | "refused" | "confirming" | "cancelled"; paymentId: string; paymentStatus: string; sessionStatus: | "active" | "expired" | "completed" | "paymentPending" | "refused" | "canceled"; }>

Operation Id

readSalesOrderAdyenSessionResult

spendStoredValue#

spendStoredValue: (orderId: string, request: {
  amount?: number;
  code?: string;
  storedValueAccountId?: string;
}, requestOptions?: RequestOptions) => Promise<{
  order: {
     id: string;
     paymentStatus: string;
     status: string;
     stillDue: number;
     total: number;
     totalPaid: number;
  };
  payment: {
     amount: number;
     currency: string;
     paymentId: string;
     status: "succeeded";
  };
  storedValue: {
     balance: number;
     id: string;
     instrument: "gift_card" | "account_credit" | "pass_balance";
  };
}>;

Pay with a gift card or account credit Spends a gift card (by its code, which is all a bearer needs) or the signed-in customer's account credit (by storedValueAccountId) on the order: all of what is due, or part of it, the rest then paid by card (POST /orders/{orderId}/payments takes the outstanding balance). Left without an amount it takes as much as the balance and the order allow. A customer token spends only that customer's credit (STORED_VALUE_WRONG_CUSTOMER otherwise); the channel's secret key acts for the order's own customer. A gift card named by its id instead of its code is STORED_VALUE_ACCOUNT_NOT_FOUND. A balance is spent only within the organisation that issued it. One that cannot be spent now is STORED_VALUE_NOT_ACTIVE, whose state says why. The channel must offer stored_value (PAYMENT_METHOD_NOT_AVAILABLE).

Parameters
ParameterTypeDescription
orderIdstring-
request{ amount?: number; code?: string; storedValueAccountId?: string; }-
request.amount?numberDescription Minor units. Left out: as much as the balance and the order allow. Example 3000
request.code?stringDescription A gift card's code, as printed or emailed (with or without the hyphens) Example 7KQ2-MZ9X-LP3R-TV8W
request.storedValueAccountId?stringDescription The balance to spend: the customer's account credit (from their balances) Example sva_7Kq2mZ9xLp3RtV8wYb1c
requestOptions?RequestOptions-
Returns

Promise<{ order: { id: string; paymentStatus: string; status: string; stillDue: number; total: number; totalPaid: number; }; payment: { amount: number; currency: string; paymentId: string; status: "succeeded"; }; storedValue: { balance: number; id: string; instrument: "gift_card" | "account_credit" | "pass_balance"; }; }>

Operation Id

spendSalesOrderStoredValue

salesOrders#

salesOrders: {
  activateWristband: (orderId: string, slotId: string, request: {
     uid: string;
   }, requestOptions?: RequestOptions) => Promise<{
     activatedAt: string | null;
     activation: "immediate" | "on_receipt";
     chipType: string | null;
     commandId: string | null;
     deviceId: string | null;
     encodedAt: string;
     encodedBy: string | null;
     id: string;
     mediaType: string | null;
     orderId: string;
     passId: string;
     shipmentId: string | null;
     slotId: string;
     uid: string;
  }>;
  assignAddOn: (orderId: string, request: {
     orderLineItemId: string;
     slotId: string;
     unitIndex: number;
   }, requestOptions?: RequestOptions) => Promise<{
     bookingPasses: {
        eventId: string | null;
        passId: string;
        status: string;
     }[];
     orderId: string;
     slots: {
        eventId: string;
        holder: {
           email: string | null;
           id: string;
           name: string | null;
        };
        id: string;
        items: {
           eligibleSlotIds: string[] | null;
           entitlementId: string | null;
           orderId: string;
           orderLineItemId: string;
           passId: string | null;
           role: "holder" | "add_on";
           ticketTypeId: string;
           ticketTypeName: string | null;
           unitIndex: number;
        }[];
        kind: "person" | "vehicle" | "group";
        label: string;
        mediaType: string | null;
        naming: {
           changesCloseAt: string | null;
           maxNameChanges: number | null;
           nameChangesAllowed: boolean;
           namesCloseAt: string | null;
           policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
           required: boolean;
           transfersAllowed: boolean;
        };
        orderId: string;
        passId: string | null;
        position: number;
        wristband: {
           activeAt: string | null;
           method: string | null;
           shipmentId: string | null;
           state:   | "active"
              | "none"
              | "to_exchange"
              | "to_post"
              | "to_collect"
              | "posted_pending_activation";
           uid: string | null;
        };
     }[];
     unassigned: {
        eligibleSlotIds: string[];
        entitlementId: string | null;
        orderLineItemId: string;
        passId: string | null;
        ticketTypeId: string;
        ticketTypeName: string | null;
        unitIndex: number;
     }[];
  }>;
  get: (orderId: string, requestOptions?: RequestOptions) => Promise<{
     createdAt: string;
     currency: string;
     expiresAt: string | null;
     id: string;
     isTest: boolean;
     items: {
        description: string | null;
        name: string;
        quantity: number;
        subtotal: number;
        type: string;
        unitPrice: number;
     }[];
     orderNumber: string;
     paymentStatus: string;
     refundToCreditOffered: boolean;
     status: string;
     subtotal: number;
     tickets: {
        admissionStatus: string;
        barcode: string | null;
        bookingPass: boolean;
        codeReleasesAt: string | null;
        entitlementId: string;
        eventOccurrenceId: string | null;
        holderName: string | null;
        id: string;
        mediaType: string | null;
        name: string;
        seatLabel: string | null;
        security: "open" | "protected";
        slotId: string | null;
        status: string;
        type: string;
     }[];
     total: number;
     totalFees: number;
     totalTax: number;
  }>;
  holder: (orderId: string, slotId: string, requestOptions?: RequestOptions) => Promise<{
     bookingPasses: {
        eventId: string | null;
        passId: string;
        status: string;
     }[];
     orderId: string;
     slots: {
        eventId: string;
        holder: {
           email: string | null;
           id: string;
           name: string | null;
        };
        id: string;
        items: {
           eligibleSlotIds: string[] | null;
           entitlementId: string | null;
           orderId: string;
           orderLineItemId: string;
           passId: string | null;
           role: "holder" | "add_on";
           ticketTypeId: string;
           ticketTypeName: string | null;
           unitIndex: number;
        }[];
        kind: "person" | "vehicle" | "group";
        label: string;
        mediaType: string | null;
        naming: {
           changesCloseAt: string | null;
           maxNameChanges: number | null;
           nameChangesAllowed: boolean;
           namesCloseAt: string | null;
           policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
           required: boolean;
           transfersAllowed: boolean;
        };
        orderId: string;
        passId: string | null;
        position: number;
        wristband: {
           activeAt: string | null;
           method: string | null;
           shipmentId: string | null;
           state:   | "active"
              | "none"
              | "to_exchange"
              | "to_post"
              | "to_collect"
              | "posted_pending_activation";
           uid: string | null;
        };
     }[];
     unassigned: {
        eligibleSlotIds: string[];
        entitlementId: string | null;
        orderLineItemId: string;
        passId: string | null;
        ticketTypeId: string;
        ticketTypeName: string | null;
        unitIndex: number;
     }[];
  }>;
  holderLink: (orderId: string, slotId: string, requestOptions?: RequestOptions) => Promise<{
     expiresAt: string;
     holderAccessToken: string;
     orderId: string;
     passId: string | null;
     slotId: string;
  }>;
  holders: (orderId: string, requestOptions?: RequestOptions) => Promise<{
     bookingPasses: {
        eventId: string | null;
        passId: string;
        status: string;
     }[];
     orderId: string;
     slots: {
        eventId: string;
        holder: {
           email: string | null;
           id: string;
           name: string | null;
        };
        id: string;
        items: {
           eligibleSlotIds: string[] | null;
           entitlementId: string | null;
           orderId: string;
           orderLineItemId: string;
           passId: string | null;
           role: "holder" | "add_on";
           ticketTypeId: string;
           ticketTypeName: string | null;
           unitIndex: number;
        }[];
        kind: "person" | "vehicle" | "group";
        label: string;
        mediaType: string | null;
        naming: {
           changesCloseAt: string | null;
           maxNameChanges: number | null;
           nameChangesAllowed: boolean;
           namesCloseAt: string | null;
           policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
           required: boolean;
           transfersAllowed: boolean;
        };
        orderId: string;
        passId: string | null;
        position: number;
        wristband: {
           activeAt: string | null;
           method: string | null;
           shipmentId: string | null;
           state:   | "active"
              | "none"
              | "to_exchange"
              | "to_post"
              | "to_collect"
              | "posted_pending_activation";
           uid: string | null;
        };
     }[];
     unassigned: {
        eligibleSlotIds: string[];
        entitlementId: string | null;
        orderLineItemId: string;
        passId: string | null;
        ticketTypeId: string;
        ticketTypeName: string | null;
        unitIndex: number;
     }[];
  }>;
  nameHolder: (orderId: string, slotId: string, request: {
     email?: string | null;
     name: string;
   }, requestOptions?: RequestOptions) => Promise<{
     bookingPasses: {
        eventId: string | null;
        passId: string;
        status: string;
     }[];
     orderId: string;
     slots: {
        eventId: string;
        holder: {
           email: string | null;
           id: string;
           name: string | null;
        };
        id: string;
        items: {
           eligibleSlotIds: string[] | null;
           entitlementId: string | null;
           orderId: string;
           orderLineItemId: string;
           passId: string | null;
           role: "holder" | "add_on";
           ticketTypeId: string;
           ticketTypeName: string | null;
           unitIndex: number;
        }[];
        kind: "person" | "vehicle" | "group";
        label: string;
        mediaType: string | null;
        naming: {
           changesCloseAt: string | null;
           maxNameChanges: number | null;
           nameChangesAllowed: boolean;
           namesCloseAt: string | null;
           policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
           required: boolean;
           transfersAllowed: boolean;
        };
        orderId: string;
        passId: string | null;
        position: number;
        wristband: {
           activeAt: string | null;
           method: string | null;
           shipmentId: string | null;
           state:   | "active"
              | "none"
              | "to_exchange"
              | "to_post"
              | "to_collect"
              | "posted_pending_activation";
           uid: string | null;
        };
     }[];
     unassigned: {
        eligibleSlotIds: string[];
        entitlementId: string | null;
        orderLineItemId: string;
        passId: string | null;
        ticketTypeId: string;
        ticketTypeName: string | null;
        unitIndex: number;
     }[];
  }>;
  ticketPdf: (orderId: string, passId: string, requestOptions?: RequestOptions) => Promise<any>;
};

Defined in: client.ts:1355

Sales Orders methods

activateWristband#

activateWristband: (orderId: string, slotId: string, request: {
  uid: string;
}, requestOptions?: RequestOptions) => Promise<{
  activatedAt: string | null;
  activation: "immediate" | "on_receipt";
  chipType: string | null;
  commandId: string | null;
  deviceId: string | null;
  encodedAt: string;
  encodedBy: string | null;
  id: string;
  mediaType: string | null;
  orderId: string;
  passId: string;
  shipmentId: string | null;
  slotId: string;
  uid: string;
}>;

Activate a posted wristband (Manage my booking) The holder taps the wristband posted to them in the app: if it is the band sent to that holder it is activated and scans from then on. 409 WRISTBAND_ACTIVATION_MISMATCH (another band), WRISTBAND_NOT_AWAITING_ACTIVATION (none was sent). Order-access gated.

Parameters
ParameterTypeDescription
orderIdstring-
slotIdstring-
request{ uid: string; }-
request.uidstringDescription The UID of the band the holder tapped, as their phone read it
requestOptions?RequestOptions-
Returns

Promise<{ activatedAt: string | null; activation: "immediate" | "on_receipt"; chipType: string | null; commandId: string | null; deviceId: string | null; encodedAt: string; encodedBy: string | null; id: string; mediaType: string | null; orderId: string; passId: string; shipmentId: string | null; slotId: string; uid: string; }>

Operation Id

activateSalesHolderWristband

assignAddOn#

assignAddOn: (orderId: string, request: {
  orderLineItemId: string;
  slotId: string;
  unitIndex: number;
}, requestOptions?: RequestOptions) => Promise<{
  bookingPasses: {
     eventId: string | null;
     passId: string;
     status: string;
  }[];
  orderId: string;
  slots: {
     eventId: string;
     holder: {
        email: string | null;
        id: string;
        name: string | null;
     };
     id: string;
     items: {
        eligibleSlotIds: string[] | null;
        entitlementId: string | null;
        orderId: string;
        orderLineItemId: string;
        passId: string | null;
        role: "holder" | "add_on";
        ticketTypeId: string;
        ticketTypeName: string | null;
        unitIndex: number;
     }[];
     kind: "person" | "vehicle" | "group";
     label: string;
     mediaType: string | null;
     naming: {
        changesCloseAt: string | null;
        maxNameChanges: number | null;
        nameChangesAllowed: boolean;
        namesCloseAt: string | null;
        policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
        required: boolean;
        transfersAllowed: boolean;
     };
     orderId: string;
     passId: string | null;
     position: number;
     wristband: {
        activeAt: string | null;
        method: string | null;
        shipmentId: string | null;
        state:   | "active"
           | "none"
           | "to_exchange"
           | "to_post"
           | "to_collect"
           | "posted_pending_activation";
        uid: string | null;
     };
  }[];
  unassigned: {
     eligibleSlotIds: string[];
     entitlementId: string | null;
     orderLineItemId: string;
     passId: string | null;
     ticketTypeId: string;
     ticketTypeName: string | null;
     unitIndex: number;
  }[];
}>;

Put an add-on on a holder (Manage my booking) Assign or move one add-on of this booking to one of its holders, or to one of the buyer's holders from an earlier booking for the event. 409 ADD_ON_HOLDER_MISMATCH, ADD_ON_LIMIT_REACHED, NOT_AN_ADD_ON, ENTITLEMENT_IN_USE or PASS_CHANGE_CLOSED. Order-access gated.

Parameters
ParameterTypeDescription
orderIdstring-
request{ orderLineItemId: string; slotId: string; unitIndex: number; }-
request.orderLineItemIdstringDescription The add-on line on this order
request.slotId?stringDescription The holder: one of this order's slots or one of the buyer's from an earlier booking
request.unitIndex?number-
requestOptions?RequestOptions-
Returns

Promise<{ bookingPasses: { eventId: string | null; passId: string; status: string; }[]; orderId: string; slots: { eventId: string; holder: { email: string | null; id: string; name: string | null; }; id: string; items: { eligibleSlotIds: string[] | null; entitlementId: string | null; orderId: string; orderLineItemId: string; passId: string | null; role: "holder" | "add_on"; ticketTypeId: string; ticketTypeName: string | null; unitIndex: number; }[]; kind: "person" | "vehicle" | "group"; label: string; mediaType: string | null; naming: { changesCloseAt: string | null; maxNameChanges: number | null; nameChangesAllowed: boolean; namesCloseAt: string | null; policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate"; required: boolean; transfersAllowed: boolean; }; orderId: string; passId: string | null; position: number; wristband: { activeAt: string | null; method: string | null; shipmentId: string | null; state: | "active" | "none" | "to_exchange" | "to_post" | "to_collect" | "posted_pending_activation"; uid: string | null; }; }[]; unassigned: { eligibleSlotIds: string[]; entitlementId: string | null; orderLineItemId: string; passId: string | null; ticketTypeId: string; ticketTypeName: string | null; unitIndex: number; }[]; }>

Operation Id

assignSalesOrderAddOn

get#

get: (orderId: string, requestOptions?: RequestOptions) => Promise<{
  createdAt: string;
  currency: string;
  expiresAt: string | null;
  id: string;
  isTest: boolean;
  items: {
     description: string | null;
     name: string;
     quantity: number;
     subtotal: number;
     type: string;
     unitPrice: number;
  }[];
  orderNumber: string;
  paymentStatus: string;
  refundToCreditOffered: boolean;
  status: string;
  subtotal: number;
  tickets: {
     admissionStatus: string;
     barcode: string | null;
     bookingPass: boolean;
     codeReleasesAt: string | null;
     entitlementId: string;
     eventOccurrenceId: string | null;
     holderName: string | null;
     id: string;
     mediaType: string | null;
     name: string;
     seatLabel: string | null;
     security: "open" | "protected";
     slotId: string | null;
     status: string;
     type: string;
  }[];
  total: number;
  totalFees: number;
  totalTax: number;
}>;

Get order Get an order on this channel. Access requires a secret key (own channel), an X-Order-Access-Token header (guest possession) or a customer token (own orders).

Parameters
ParameterType
orderIdstring
requestOptions?RequestOptions
Returns

Promise<{ createdAt: string; currency: string; expiresAt: string | null; id: string; isTest: boolean; items: { description: string | null; name: string; quantity: number; subtotal: number; type: string; unitPrice: number; }[]; orderNumber: string; paymentStatus: string; refundToCreditOffered: boolean; status: string; subtotal: number; tickets: { admissionStatus: string; barcode: string | null; bookingPass: boolean; codeReleasesAt: string | null; entitlementId: string; eventOccurrenceId: string | null; holderName: string | null; id: string; mediaType: string | null; name: string; seatLabel: string | null; security: "open" | "protected"; slotId: string | null; status: string; type: string; }[]; total: number; totalFees: number; totalTax: number; }>

Operation Id

getSalesOrder

holder#

holder: (orderId: string, slotId: string, requestOptions?: RequestOptions) => Promise<{
  bookingPasses: {
     eventId: string | null;
     passId: string;
     status: string;
  }[];
  orderId: string;
  slots: {
     eventId: string;
     holder: {
        email: string | null;
        id: string;
        name: string | null;
     };
     id: string;
     items: {
        eligibleSlotIds: string[] | null;
        entitlementId: string | null;
        orderId: string;
        orderLineItemId: string;
        passId: string | null;
        role: "holder" | "add_on";
        ticketTypeId: string;
        ticketTypeName: string | null;
        unitIndex: number;
     }[];
     kind: "person" | "vehicle" | "group";
     label: string;
     mediaType: string | null;
     naming: {
        changesCloseAt: string | null;
        maxNameChanges: number | null;
        nameChangesAllowed: boolean;
        namesCloseAt: string | null;
        policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
        required: boolean;
        transfersAllowed: boolean;
     };
     orderId: string;
     passId: string | null;
     position: number;
     wristband: {
        activeAt: string | null;
        method: string | null;
        shipmentId: string | null;
        state:   | "active"
           | "none"
           | "to_exchange"
           | "to_post"
           | "to_collect"
           | "posted_pending_activation";
        uid: string | null;
     };
  }[];
  unassigned: {
     eligibleSlotIds: string[];
     entitlementId: string | null;
     orderLineItemId: string;
     passId: string | null;
     ticketTypeId: string;
     ticketTypeName: string | null;
     unitIndex: number;
  }[];
}>;

One holder (their own link, or the booker) One holder of the booking, with their pass and add-ons. The booker (order access) reads any; a named guest with their own link (X-Holder-Access-Token) reads only themselves. A holder's link never reaches the rest of the booking, a refund or a transfer. A link that is refused is 401 HOLDER_LINK_INVALID (or HOLDER_LINK_EXPIRED after its 30 days), whether or not the booking exists.

Parameters
ParameterType
orderIdstring
slotIdstring
requestOptions?RequestOptions
Returns

Promise<{ bookingPasses: { eventId: string | null; passId: string; status: string; }[]; orderId: string; slots: { eventId: string; holder: { email: string | null; id: string; name: string | null; }; id: string; items: { eligibleSlotIds: string[] | null; entitlementId: string | null; orderId: string; orderLineItemId: string; passId: string | null; role: "holder" | "add_on"; ticketTypeId: string; ticketTypeName: string | null; unitIndex: number; }[]; kind: "person" | "vehicle" | "group"; label: string; mediaType: string | null; naming: { changesCloseAt: string | null; maxNameChanges: number | null; nameChangesAllowed: boolean; namesCloseAt: string | null; policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate"; required: boolean; transfersAllowed: boolean; }; orderId: string; passId: string | null; position: number; wristband: { activeAt: string | null; method: string | null; shipmentId: string | null; state: | "active" | "none" | "to_exchange" | "to_post" | "to_collect" | "posted_pending_activation"; uid: string | null; }; }[]; unassigned: { eligibleSlotIds: string[]; entitlementId: string | null; orderLineItemId: string; passId: string | null; ticketTypeId: string; ticketTypeName: string | null; unitIndex: number; }[]; }>

Operation Id

getSalesOrderHolder

holderLink: (orderId: string, slotId: string, requestOptions?: RequestOptions) => Promise<{
  expiresAt: string;
  holderAccessToken: string;
  orderId: string;
  passId: string | null;
  slotId: string;
}>;

Give a named guest their own link The booker issues a holder access token for one holder: with it (X-Holder-Access-Token) that guest reads and names themselves and downloads their own pass, and nothing else. Refunds and transfers stay with the booker. Order-access gated; a holder cannot issue links.

Parameters
ParameterType
orderIdstring
slotIdstring
requestOptions?RequestOptions
Returns

Promise<{ expiresAt: string; holderAccessToken: string; orderId: string; passId: string | null; slotId: string; }>

Operation Id

createSalesOrderHolderLink

holders#

holders: (orderId: string, requestOptions?: RequestOptions) => Promise<{
  bookingPasses: {
     eventId: string | null;
     passId: string;
     status: string;
  }[];
  orderId: string;
  slots: {
     eventId: string;
     holder: {
        email: string | null;
        id: string;
        name: string | null;
     };
     id: string;
     items: {
        eligibleSlotIds: string[] | null;
        entitlementId: string | null;
        orderId: string;
        orderLineItemId: string;
        passId: string | null;
        role: "holder" | "add_on";
        ticketTypeId: string;
        ticketTypeName: string | null;
        unitIndex: number;
     }[];
     kind: "person" | "vehicle" | "group";
     label: string;
     mediaType: string | null;
     naming: {
        changesCloseAt: string | null;
        maxNameChanges: number | null;
        nameChangesAllowed: boolean;
        namesCloseAt: string | null;
        policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
        required: boolean;
        transfersAllowed: boolean;
     };
     orderId: string;
     passId: string | null;
     position: number;
     wristband: {
        activeAt: string | null;
        method: string | null;
        shipmentId: string | null;
        state:   | "active"
           | "none"
           | "to_exchange"
           | "to_post"
           | "to_collect"
           | "posted_pending_activation";
        uid: string | null;
     };
  }[];
  unassigned: {
     eligibleSlotIds: string[];
     entitlementId: string | null;
     orderLineItemId: string;
     passId: string | null;
     ticketTypeId: string;
     ticketTypeName: string | null;
     unitIndex: number;
  }[];
}>;

Holders and add-ons (Manage my booking) Who each unit of the booking is for: its holders ("Guest 1" until named) with their passes and add-ons, and the add-ons still to place with the holders they can go to. Order-access gated.

Parameters
ParameterType
orderIdstring
requestOptions?RequestOptions
Returns

Promise<{ bookingPasses: { eventId: string | null; passId: string; status: string; }[]; orderId: string; slots: { eventId: string; holder: { email: string | null; id: string; name: string | null; }; id: string; items: { eligibleSlotIds: string[] | null; entitlementId: string | null; orderId: string; orderLineItemId: string; passId: string | null; role: "holder" | "add_on"; ticketTypeId: string; ticketTypeName: string | null; unitIndex: number; }[]; kind: "person" | "vehicle" | "group"; label: string; mediaType: string | null; naming: { changesCloseAt: string | null; maxNameChanges: number | null; nameChangesAllowed: boolean; namesCloseAt: string | null; policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate"; required: boolean; transfersAllowed: boolean; }; orderId: string; passId: string | null; position: number; wristband: { activeAt: string | null; method: string | null; shipmentId: string | null; state: | "active" | "none" | "to_exchange" | "to_post" | "to_collect" | "posted_pending_activation"; uid: string | null; }; }[]; unassigned: { eligibleSlotIds: string[]; entitlementId: string | null; orderLineItemId: string; passId: string | null; ticketTypeId: string; ticketTypeName: string | null; unitIndex: number; }[]; }>

Operation Id

getSalesOrderHolders

nameHolder#

nameHolder: (orderId: string, slotId: string, request: {
  email?: string | null;
  name: string;
}, requestOptions?: RequestOptions) => Promise<{
  bookingPasses: {
     eventId: string | null;
     passId: string;
     status: string;
  }[];
  orderId: string;
  slots: {
     eventId: string;
     holder: {
        email: string | null;
        id: string;
        name: string | null;
     };
     id: string;
     items: {
        eligibleSlotIds: string[] | null;
        entitlementId: string | null;
        orderId: string;
        orderLineItemId: string;
        passId: string | null;
        role: "holder" | "add_on";
        ticketTypeId: string;
        ticketTypeName: string | null;
        unitIndex: number;
     }[];
     kind: "person" | "vehicle" | "group";
     label: string;
     mediaType: string | null;
     naming: {
        changesCloseAt: string | null;
        maxNameChanges: number | null;
        nameChangesAllowed: boolean;
        namesCloseAt: string | null;
        policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate";
        required: boolean;
        transfersAllowed: boolean;
     };
     orderId: string;
     passId: string | null;
     position: number;
     wristband: {
        activeAt: string | null;
        method: string | null;
        shipmentId: string | null;
        state:   | "active"
           | "none"
           | "to_exchange"
           | "to_post"
           | "to_collect"
           | "posted_pending_activation";
        uid: string | null;
     };
  }[];
  unassigned: {
     eligibleSlotIds: string[];
     entitlementId: string | null;
     orderLineItemId: string;
     passId: string | null;
     ticketTypeId: string;
     ticketTypeName: string | null;
     unitIndex: number;
  }[];
}>;

Name a holder (Manage my booking) Put a name on one of the booking's holders, under the event's pass policy: 409 PASS_FROZEN, PASS_CHANGE_NOT_ALLOWED, PASS_CHANGE_LIMIT_REACHED or PASS_CHANGE_CLOSED once the pass is issued and the policy says no. The booker (order access) names any holder; a named guest with their own link (X-Holder-Access-Token) names only themselves and is answered with their own holder only. A link that is refused is 401 HOLDER_LINK_INVALID (or HOLDER_LINK_EXPIRED after its 30 days), whether or not the booking exists.

Parameters
ParameterTypeDescription
orderIdstring-
slotIdstring-
request{ email?: string | null; name: string; }-
request.email?string | nullFormat: email
request.name?string-
requestOptions?RequestOptions-
Returns

Promise<{ bookingPasses: { eventId: string | null; passId: string; status: string; }[]; orderId: string; slots: { eventId: string; holder: { email: string | null; id: string; name: string | null; }; id: string; items: { eligibleSlotIds: string[] | null; entitlementId: string | null; orderId: string; orderLineItemId: string; passId: string | null; role: "holder" | "add_on"; ticketTypeId: string; ticketTypeName: string | null; unitIndex: number; }[]; kind: "person" | "vehicle" | "group"; label: string; mediaType: string | null; naming: { changesCloseAt: string | null; maxNameChanges: number | null; nameChangesAllowed: boolean; namesCloseAt: string | null; policy: "none" | "at_checkout" | "before_deadline" | "id_at_gate"; required: boolean; transfersAllowed: boolean; }; orderId: string; passId: string | null; position: number; wristband: { activeAt: string | null; method: string | null; shipmentId: string | null; state: | "active" | "none" | "to_exchange" | "to_post" | "to_collect" | "posted_pending_activation"; uid: string | null; }; }[]; unassigned: { eligibleSlotIds: string[]; entitlementId: string | null; orderLineItemId: string; passId: string | null; ticketTypeId: string; ticketTypeName: string | null; unitIndex: number; }[]; }>

Operation Id

nameSalesOrderHolder

ticketPdf#

ticketPdf: (orderId: string, passId: string, requestOptions?: RequestOptions) => Promise<any>;

Download a ticket PDF Render and stream a pass as a PDF ticket (application/pdf). The booker (order access) downloads any pass on the order; a named guest with their own link (X-Holder-Access-Token) downloads only their own; a link that is refused is 401 HOLDER_LINK_INVALID (or HOLDER_LINK_EXPIRED after its 30 days), whether or not the booking exists. Browsers fetch this directly rather than through the typed SDK.

Parameters
ParameterType
orderIdstring
passIdstring
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

getSalesOrderTicketPdf

salesPasses#

salesPasses: {
  appleWallet: (passId: string, requestOptions?: RequestOptions) => Promise<any>;
  googleWallet: (passId: string, requestOptions?: RequestOptions) => Promise<{
     saveUrl: string;
  }>;
  rotatingSeed: (passId: string, requestOptions?: RequestOptions) => Promise<{
     algorithm: "SHA1";
     digits: number;
     envelope: string;
     maxSkewSeconds: number;
     passId: string;
     periodSeconds: number;
     secret: string;
  }>;
};

Defined in: client.ts:1475

Sales Passes methods

appleWallet#

appleWallet: (passId: string, requestOptions?: RequestOptions) => Promise<any>;

Add a pass to Apple Wallet The signed .pkpass (application/vnd.apple.pkpass) for the pass's holder: their customer token, or, until the pass is transferred, the booker's customer token or the order's X-Order-Access-Token. It updates itself on the phone when the pass changes; a transfer or a revoking re-issue voids it. 409 PASS_RENDITION_NOT_ALLOWED for a protected pass (use the app or Google Wallet). Browsers fetch this directly.

Parameters
ParameterType
passIdstring
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

getSalesPassAppleWallet

googleWallet#

googleWallet: (passId: string, requestOptions?: RequestOptions) => Promise<{
  saveUrl: string;
}>;

Add a pass to Google Wallet The save-to-Google-Wallet link for the pass's holder: their customer token, or, until the pass is transferred, the booker's customer token or the order's X-Order-Access-Token. A protected pass rotates in Google Wallet; a transfer or a revoking re-issue makes the saved pass inactive. Never cached.

Parameters
ParameterType
passIdstring
requestOptions?RequestOptions
Returns

Promise<{ saveUrl: string; }>

Operation Id

getSalesPassGoogleWallet

rotatingSeed#

rotatingSeed: (passId: string, requestOptions?: RequestOptions) => Promise<{
  algorithm: "SHA1";
  digits: number;
  envelope: string;
  maxSkewSeconds: number;
  passId: string;
  periodSeconds: number;
  secret: string;
}>;

Get a pass's rotating-code seed The seed the app makes the pass's rotating codes from (an RFC 6238 TOTP inside a signed envelope), so a screenshot goes stale. For the pass's holder only: their customer token, or, until the pass is transferred, the booker's customer token or the order's X-Order-Access-Token. Not with a secret key. 409 PASS_CODE_NOT_RELEASED before a late-released code's time. A re-issue or transfer revokes the seed; fetch it again when a scan answers identifier_revoked. Never cached.

Parameters
ParameterType
passIdstring
requestOptions?RequestOptions
Returns

Promise<{ algorithm: "SHA1"; digits: number; envelope: string; maxSkewSeconds: number; passId: string; periodSeconds: number; secret: string; }>

Operation Id

getSalesPassRotatingSeed

salesRefundRequests#

salesRefundRequests: {
  create: (orderId: string, request: {
     reason?: string;
     refundTo?: "account_credit" | "original";
     type: "refund" | "exchange";
   }, requestOptions?: RequestOptions) => Promise<{
     createdAt: string;
     id: string;
     orderId: string;
     reason: string | null;
     refundTo: "account_credit" | "original";
     status: string;
     type: string;
  }>;
};

Defined in: client.ts:1522

Sales Refund Requests methods

create#

create: (orderId: string, request: {
  reason?: string;
  refundTo?: "account_credit" | "original";
  type: "refund" | "exchange";
}, requestOptions?: RequestOptions) => Promise<{
  createdAt: string;
  id: string;
  orderId: string;
  reason: string | null;
  refundTo: "account_credit" | "original";
  status: string;
  type: string;
}>;

Request refund or exchange File a refund or exchange request for the order within the resolved refund policy. Requester identity is derived from the credential, never from the body.

Parameters
ParameterType
orderIdstring
request{ reason?: string; refundTo?: "account_credit" | "original"; type: "refund" | "exchange"; }
request.reason?string
request.refundTo?"account_credit" | "original"
request.type?"refund" | "exchange"
requestOptions?RequestOptions
Returns

Promise<{ createdAt: string; id: string; orderId: string; reason: string | null; refundTo: "account_credit" | "original"; status: string; type: string; }>

Operation Id

createSalesOrderRefundRequest

seatMap#

seatMap: {
  createSeatmapToken: (request: {
     occurrenceId: string;
  }, requestOptions?: RequestOptions) => Promise<any>;
};

Defined in: client.ts:494

Seat map methods

createSeatmapToken#

createSeatmapToken: (request: {
  occurrenceId: string;
}, requestOptions?: RequestOptions) => Promise<any>;

Mint a seat map token Mints the token the seat map Worker checks on every read of an occurrence's seat map: its venue plan version (from the occurrence's pointer on this channel), the channel, a hash of this session and the request's Origin, which must be one of the channel's allowed origins. A buyer queued behind an armed waiting room gets the overview scope only.

Parameters
ParameterTypeDescription
request{ occurrenceId: string; }-
request.occurrenceIdstringDescription The occurrence whose seat map to open. Example eo_AX5SXeHS
requestOptions?RequestOptions-
Returns

Promise<any>

Operation Id

createSeatmapToken

session#

session: {
  attachOrderAccess: (request: {
     channelKey?: string;
     domain?: string;
     orderId: string;
     token: string;
  }, requestOptions?: RequestOptions) => Promise<any>;
  current: (requestOptions?: RequestOptions) => Promise<any>;
  end: (requestOptions?: RequestOptions) => Promise<any>;
  start: (request: {
     channelKey?: string;
     domain?: string;
  }, requestOptions?: RequestOptions) => Promise<any>;
};

Defined in: client.ts:398

Session methods

attachOrderAccess#

attachOrderAccess: (request: {
  channelKey?: string;
  domain?: string;
  orderId: string;
  token: string;
}, requestOptions?: RequestOptions) => Promise<any>;

Attach an order access token to the session Proves possession of an order by reading it upstream with the emailed order access token, then holds the token in the session so GET /sales/orders/{orderId} (and ticket downloads) work without the browser keeping it. Creates the session on a cold open, exactly like POST /session.

Parameters
ParameterTypeDescription
request{ channelKey?: string; domain?: string; orderId: string; token: string; }-
request.channelKey?stringDescription Embed mode, when no session exists yet: the channel publishable key (tlpk_…). Otherwise the channel is resolved from the Host header. Example tlpk_live_abc123
request.domain?stringDescription Hosted mode, when no session exists yet: an explicit domain to resolve the channel from, overriding the Host header. Example tickets.example.com
request.orderId?stringDescription The order the token grants access to. Example ord_123
request.token?stringDescription The order access token from the "view your tickets" email link. Held server-side from then on; never echoed back. Example oat_…
requestOptions?RequestOptions-
Returns

Promise<any>

Operation Id

attachLiveOrderAccess

current#

current: (requestOptions?: RequestOptions) => Promise<any>;

Get the current session Returns the current session’s customer and cart state.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

getLiveSession

end#

end: (requestOptions?: RequestOptions) => Promise<any>;

Destroy the current session Signs out and drops the current session.

Parameters
ParameterType
requestOptions?RequestOptions
Returns

Promise<any>

Operation Id

deleteLiveSession

start#

start: (request: {
  channelKey?: string;
  domain?: string;
}, requestOptions?: RequestOptions) => Promise<any>;

Bootstrap a Live session Resolves the channel and mints a session that holds the channel’s publishable key server-side. Hosted callers (channel resolved from the Host header or an explicit domain) receive an httpOnly cookie; embed callers (providing a channelKey) receive the session id in the body.

Parameters
ParameterTypeDescription
request{ channelKey?: string; domain?: string; }-
request.channelKey?stringDescription Embed mode: the channel publishable key (tlpk_…). When omitted, the channel is resolved from the Host header (hosted mode). Example tlpk_live_abc123
request.domain?stringDescription Hosted mode: an explicit domain to resolve the channel from, overriding the Host header. Example tickets.example.com
requestOptions?RequestOptions-
Returns

Promise<any>

Operation Id

createLiveSession