@ticketlayer/elements-core 0.1.0 → 0.2.0

package/dist/esm/cores/promo-code.js

@@ -0,0 +1,132 @@
+/**
+ * `tl-promo-code`: an input and an Apply button that redeems a presale or
+ * promo code for the current cart.
+ *
+ * Redemption unlocks gated pricing on the customer; the client re-reads the
+ * cart and publishes `cart:updated`, so `tl-cart` and the badges re-render on
+ * their own and this element subscribes to nothing. It has nothing to do when
+ * a harness mounts it either, so it declares no `mount` hook - the harness
+ * still calls `mount()` and still gets a teardown, which is the point of the
+ * hook being unconditional.
+ *
+ * The API has no un-redeem, so the applied state offers only "use a different
+ * code", which clears the input for another redemption.
+ *
+ * Behaviour is what the Stencil component did before the split, to the letter,
+ * including the two error messages and the uppercased code in the receipt. What
+ * did not come across is the `console.error` tracing.
+ */
+import { defineElement } from '../define.js';
+const STRINGS = {
+    applying: 'Applying…',
+    codePrefix: 'Code ',
+    appliedSuffix: ' applied',
+    alreadyHeldSuffix: ' was already applied',
+    useDifferent: 'Use a different code',
+    enterCode: 'Enter a code',
+    notAvailable: 'Promo codes are not available',
+    signIn: 'Sign in to use this code',
+    rejected: 'That code could not be applied',
+};
+/** True for the "not signed in" family of API errors (401/403, NO_SESSION, NOT_AUTHENTICATED). */
+export function isAuthError(err) {
+    const e = err;
+    if (!e || typeof e !== 'object')
+        return false;
+    return e.status === 401 || e.status === 403 || e.code === 'NO_SESSION' || e.code === 'NOT_AUTHENTICATED';
+}
+export const promoCodeCore = defineElement({
+    tag: 'tl-promo-code',
+    docs: 'Redeem a presale or promo code for the current cart.',
+    category: 'purchase',
+    runtimes: ['web'],
+    tokens: [
+        'background',
+        'border',
+        'error',
+        'font-family',
+        'font-family-mono',
+        'foreground',
+        'muted',
+        'muted-foreground',
+        'primary',
+        'primary-foreground',
+        'radius-md',
+        'spacing-2',
+        'spacing-3',
+        'spacing-4',
+        'success',
+    ],
+    sdkMethods: ['cart.get', 'presale.redeem'],
+    props: {
+        placeholder: {
+            type: 'string',
+            attr: 'placeholder',
+            default: 'Promo or presale code',
+            docs: 'Input placeholder.',
+        },
+        buttonLabel: { type: 'string', attr: 'button-label', default: 'Apply', docs: 'Apply button label.' },
+    },
+    events: {
+        tlPromoApplied: { detail: 'TlPromoApplied', docs: '' },
+        tlError: { detail: '{ message: string; }', docs: '' },
+    },
+    strings: STRINGS,
+    statuses: ['idle', 'applied'],
+    state: () => ({ code: '', applying: false, applied: null, error: null }),
+    status: ({ state }) => (state.applied ? 'applied' : 'idle'),
+    derive: ({ state, props, strings }) => ({
+        actionLabel: state.applying ? strings.applying : props.buttonLabel,
+        disabled: state.applying,
+        appliedCode: state.applied?.code ?? null,
+        appliedSuffix: state.applied?.alreadyHeld ? strings.alreadyHeldSuffix : strings.appliedSuffix,
+    }),
+    actions: (ctx) => ({
+        /** The buyer typed. Typing clears whatever the last attempt complained about. */
+        setCode(code) {
+            ctx.setState({ code, error: null });
+        },
+        /**
+         * Redeem what is in the box.
+         *
+         * The client refreshes the cart on redeem, so the cart is read back only
+         * to put it in the payload; a read that fails is not a failed redemption
+         * and does not become one.
+         */
+        async apply() {
+            const code = ctx.state.code.trim();
+            if (!code) {
+                ctx.setState({ error: ctx.strings.enterCode });
+                return;
+            }
+            ctx.setState({ applying: true, error: null });
+            try {
+                const client = await ctx.whenClient();
+                const presale = client.getPresaleManager?.();
+                if (!presale)
+                    throw new Error(ctx.strings.notAvailable);
+                const result = await presale.redeem(code);
+                const cart = (await client.getCartManager?.()?.get?.().catch(() => null)) ?? null;
+                const applied = { code: code.toUpperCase(), ...result, cart };
+                ctx.setState({ applied, code: '' });
+                ctx.emit('tlPromoApplied', applied);
+            }
+            catch (err) {
+                const message = isAuthError(err)
+                    ? ctx.strings.signIn
+                    : err instanceof Error && err.message
+                        ? err.message
+                        : ctx.strings.rejected;
+                ctx.setState({ error: message });
+                ctx.emit('tlError', { message });
+            }
+            finally {
+                ctx.setState({ applying: false });
+            }
+        },
+        /** Back to the input, for a second code. There is no un-redeem to offer. */
+        reset() {
+            ctx.setState({ applied: null, error: null });
+        },
+    }),
+});

package/dist/esm/cores/ticket-selector.js

@@ -92,6 +92,36 @@ export const ticketSelectorCore = defineElement({
         addSuccess: false,
         feeQuote: null,
     }),
+    /**
+     * On screen: wait for the host's client, then read the ticket types. The
+     * harness used to do this (it awaited `whenSDK()` and called `load()`
+     * itself); the core does it now, so every runtime loads at the same moment
+     * and in the same order (TKT-197).
+     *
+     * There is nothing to undo, so nothing is returned. The guards are what make
+     * a remount safe: `active()` is false once this mount has been torn down, so
+     * an element that was removed while the client was still coming up neither
+     * loads nor writes an error into a view nobody is rendering.
+     */
+    mount: (ctx) => {
+        // Nothing to read until the host has said which occurrence is on sale.
+        // Until then the element stays in `loading`, which is what it did before.
+        if (!ctx.props.eventId || !ctx.props.occurrenceId)
+            return;
+        void (async () => {
+            try {
+                await ctx.whenClient();
+                if (!ctx.active())
+                    return;
+                await ctx.actions.load();
+            }
+            catch (err) {
+                if (!ctx.active())
+                    return;
+                ctx.actions.connectFailed(err instanceof Error ? err.message : ctx.strings.noClient);
+            }
+        })();
+    },
     status: ({ state }) => (state.loading ? 'loading' : state.error ? 'error' : 'ready'),
     derive: (ctx) => {
         const { state, strings, props, formatMoney } = ctx;

package/dist/esm/define.d.ts

@@ -33,6 +33,16 @@ export type PropType = 'string' | 'number' | 'boolean' | 'object' | 'array';
  */
 export interface PropSpec<V> {
     type: PropType;
+    /**
+     * The type exactly as the harness writes it, when that is narrower than
+     * `type`: a literal union (`'"lg" | "md" | "sm"'`) or an optional prop
+     * (`'string | undefined'`). Written out for the same reason
+     * {@link EventSpec.detail} is - the catalogue is JSON and a type is not -
+     * and checked against the Stencil build by the catalogue emitter, so a core
+     * and its harness cannot disagree about what a prop accepts. Left out when
+     * `type` says it all.
+     */
+    tsType?: string;
     attr: string | null;
     default?: V;
     required?: boolean;
@@ -74,6 +84,92 @@ export interface ActionContext<P extends object, S extends object, Str extends S
     optionalClient(): ElementClient | null;
     /** A timer the instance clears on destroy. */
     after(ms: number, run: () => void): void;
+    /**
+     * The client, once the host has published one. Rejects when the host never
+     * produces one, which on the web is a page that never started Live. A
+     * harness supplies the waiting through `clientReady`; with none it settles
+     * from whatever the client resolver says right now.
+     *
+     * On an action as well as a mount, because an action a buyer triggers can be
+     * the first thing that needs the client (`tl-promo-code` redeems a code
+     * without reading anything first). `client()` would throw on a page that is
+     * still starting up; this waits, which is what the components did.
+     */
+    whenClient(): Promise<ElementClient>;
+    /**
+     * The runtime's key/value store, for the little a core is allowed to
+     * remember between visits (`tl-cart-badge` keeps the last item count so the
+     * badge does not flash empty on the next page).
+     *
+     * A seam and not a direct `localStorage`, for the same reason `client` is
+     * one: a core has no runtime in it, and the store is not the same object on
+     * every runtime. A harness that has one hands it over; with none, reads
+     * return null and writes go nowhere, so a core never has to ask whether it
+     * has somewhere to write.
+     */
+    readonly storage: ElementStorage;
+    /**
+     * The parameters the host was opened with, for the elements a link lands on.
+     *
+     * The second seam, and the same bargain as {@link ActionContext.storage}: two
+     * elements are the far end of a link someone follows out of an email or back
+     * from a payment provider, and what they have to read is in that link.
+     * `tl-login` exchanges `?code=`, and `tl-order-confirmation` finds its order
+     * in `?orderId=` and learns from `?redirect_status=` whether the payment
+     * actually went through.
+     *
+     * Where those parameters live is per runtime and nowhere near a core: the
+     * web has `window.location.search`, and a native harness has whatever its
+     * deep-link router hands it. So the core says WHICH parameter it reads and
+     * WHEN, and the harness says WHERE they come from. A harness that has none
+     * passes none, every read comes back null, and the core falls through to the
+     * behaviour it has when a page carries no link - which for both of these is
+     * the behaviour a host who set the prop already gets.
+     */
+    readonly query: ElementQuery;
+}
+/**
+ * What a harness hands over for {@link ActionContext.storage}: strings in,
+ * strings out, synchronous, and allowed to fail silently. Deliberately the
+ * smallest thing every runtime can supply.
+ */
+export interface ElementStorage {
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+}
+/** The store a core gets when its harness supplies none: it forgets. */
+export declare const NO_STORAGE: ElementStorage;
+/**
+ * What a harness hands over for {@link ActionContext.query}: one named
+ * parameter at a time, synchronous, null when it is not there. Read-only on
+ * purpose - a core reports what a link said, it does not rewrite the address
+ * bar, which is a navigation decision and therefore the host's.
+ */
+export interface ElementQuery {
+    get(name: string): string | null;
+}
+/** The parameters a core gets when its harness supplies none: there are none. */
+export declare const NO_QUERY: ElementQuery;
+/** What a mount teardown is: run it once, and running it again does nothing. */
+export type MountTeardown = () => void;
+/**
+ * What a mount is handed: everything an action gets, plus the actions
+ * themselves, a way to register cleanups, and the two things a subscription
+ * needs to be safe - the client once the host has published it, and whether
+ * this mount is still the live one.
+ */
+export interface MountContext<P extends object, S extends object, Str extends StringMap, A extends ActionMap> extends ActionContext<P, S, Str> {
+    /** The core's own actions, so a mount can `actions.load()`. */
+    readonly actions: A;
+    /**
+     * Register a cleanup for this mount. Everything registered runs once, in
+     * reverse order, when the mount is torn down. A cleanup registered after
+     * this mount has already been torn down runs immediately, which is what
+     * makes an `await` before a subscription safe.
+     */
+    onTeardown(cleanup: () => void): void;
+    /** False once this mount has been torn down, or the instance destroyed. */
+    active(): boolean;
 }
 /** A core, as `defineElement` returns it. */
 export interface ElementCore<P extends object, S extends object, D extends object, A extends ActionMap, Status extends string, Str extends StringMap> {
@@ -99,6 +195,19 @@ export interface ElementCore<P extends object, S extends object, D extends objec
     /** Every value `status` can return; a harness renders one branch per entry. */
     readonly statuses: readonly Status[];
     readonly state: (props: Readonly<P>) => S;
+    /**
+     * What happens when a harness puts the element on screen, and what undoes
+     * it. Typically `actions.load()` plus any subscription the element lives on;
+     * the returned function, and anything registered with `ctx.onTeardown`, is
+     * what the harness runs when the element goes away again.
+     *
+     * The core owns this, not the harness (TKT-197): a harness that decided when
+     * to load or who owns a subscription would have to decide it again for every
+     * runtime, and the two would drift. A core with nothing to do on mount leaves
+     * it out; `instance.mount()` still exists and still returns a teardown, so a
+     * harness calls it unconditionally.
+     */
+    readonly mount?: (ctx: MountContext<P, S, Str, A>) => MountTeardown | void;
     readonly status: (ctx: ViewContext<P, S, Str>) => Status;
     readonly derive: (ctx: ViewContext<P, S, Str>) => D;
     readonly actions: (ctx: ActionContext<P, S, Str>) => A;
@@ -124,10 +233,29 @@ export interface CreateElementOptions<P extends object, Str extends StringMap> {
     emit?: (event: string, detail: unknown) => void;
     /** Copy overrides, per instance. */
     strings?: Partial<Str>;
+    /**
+     * Resolves when the host's client is available, for a harness whose runtime
+     * publishes one late. The web harness passes `whenSDK`; a harness whose
+     * client is there from the start passes nothing. Only `mount`'s
+     * `whenClient()` waits on it.
+     */
+    clientReady?: () => Promise<unknown>;
     /** The locale money is formatted in. */
     locale?: string;
     /** The currency used when a value carries none. */
     currency?: string;
+    /**
+     * Where the core may remember a little between visits. The web harness
+     * passes a `localStorage` wrapper; a harness with no store passes nothing
+     * and the core's reads come back null.
+     */
+    storage?: ElementStorage;
+    /**
+     * The parameters the host was opened with. The web harness passes a wrapper
+     * over `window.location.search`; a harness whose runtime has no such thing
+     * passes nothing and the core's reads come back null.
+     */
+    query?: ElementQuery;
 }
 export interface ElementInstance<P extends object, S extends object, D extends object, A extends ActionMap, Status extends string, Str extends StringMap> {
     readonly core: ElementCore<P, S, D, A, Status, Str>;
@@ -138,6 +266,24 @@ export interface ElementInstance<P extends object, S extends object, D extends o
     setProps(next: Partial<P>): void;
     setClient(client: ElementClient | null | (() => ElementClient | null)): void;
     subscribe(listener: (view: ElementView<P, S, D, Status, Str>) => void): () => void;
+    /**
+     * Put the element to work, and hand back what stops it again.
+     *
+     * A harness calls this when the element appears (`connectedCallback` on the
+     * web) and the returned teardown when it goes away. The rules, which
+     * `test/mount.test.mjs` holds to:
+     *
+     * - The teardown is idempotent: calling it twice does nothing the second
+     *   time, and a teardown from an earlier mount does nothing at all.
+     * - At most one mount is live. Mounting while mounted tears the previous one
+     *   down first, so a remount cannot leave two subscriptions behind.
+     * - `destroy()` is terminal and runs the live mount's teardown first, so a
+     *   harness that only destroys still leaks nothing. Mounting a destroyed
+     *   instance does nothing and returns a teardown that does nothing.
+     */
+    mount(): MountTeardown;
+    /** Whether a mount is live right now. */
+    readonly mounted: boolean;
     destroy(): void;
 }
 /**

package/dist/esm/define.js

@@ -1,3 +1,12 @@
+/** The store a core gets when its harness supplies none: it forgets. */
+export const NO_STORAGE = {
+    get: () => null,
+    set: () => undefined,
+};
+/** The parameters a core gets when its harness supplies none: there are none. */
+export const NO_QUERY = {
+    get: () => null,
+};
 const CATEGORIES = [
     'discovery',
     'purchase',
@@ -67,6 +76,8 @@ export function createElement(core, options = {}) {
         style: 'currency',
         currency: currency || fallbackCurrency,
     }).format(amountInMinorUnits / 100);
+    const storage = options.storage ?? NO_STORAGE;
+    const query = options.query ?? NO_QUERY;
     const viewContext = () => ({ props, state, strings, formatMoney });
     const buildView = () => {
         const ctx = viewContext();
@@ -85,6 +96,15 @@ export function createElement(core, options = {}) {
         for (const listener of [...listeners])
             listener(view);
     };
+    const whenClient = async () => {
+        if (options.clientReady)
+            await options.clientReady();
+        const client = resolveClient();
+        if (!client) {
+            throw new Error(`[elements-core] ${core.tag}: no client. A harness hands the core the client the host published.`);
+        }
+        return client;
+    };
     const actionContext = {
         get props() {
             return props;
@@ -122,6 +142,9 @@ export function createElement(core, options = {}) {
                 return null;
             }
         },
+        storage,
+        query,
+        whenClient,
         after(ms, run) {
             if (destroyed)
                 return;
@@ -134,6 +157,52 @@ export function createElement(core, options = {}) {
         },
     };
     const actions = core.actions(actionContext);
+    // The live mount, as an identity rather than a boolean: a teardown closes
+    // over the token it was made for, so a stale one tears nothing down.
+    let mountToken = null;
+    let cleanups = [];
+    const teardownMount = (token) => {
+        if (mountToken !== token)
+            return;
+        mountToken = null;
+        const pending = cleanups;
+        cleanups = [];
+        for (const cleanup of pending.reverse())
+            cleanup();
+    };
+    const mount = () => {
+        if (destroyed)
+            return () => { };
+        if (mountToken)
+            teardownMount(mountToken);
+        const token = {};
+        mountToken = token;
+        const live = () => mountToken === token && !destroyed;
+        const returned = core.mount?.({
+            ...actionContext,
+            get props() {
+                return props;
+            },
+            get state() {
+                return state;
+            },
+            actions,
+            active: live,
+            onTeardown(cleanup) {
+                if (live())
+                    cleanups.push(cleanup);
+                else
+                    cleanup();
+            },
+        });
+        if (typeof returned === 'function') {
+            if (live())
+                cleanups.push(returned);
+            else
+                returned();
+        }
+        return () => teardownMount(token);
+    };
     return {
         core,
         get props() {
@@ -161,7 +230,13 @@ export function createElement(core, options = {}) {
                 listeners.delete(listener);
             };
         },
+        mount,
+        get mounted() {
+            return mountToken !== null;
+        },
         destroy() {
+            if (mountToken)
+                teardownMount(mountToken);
             destroyed = true;
             for (const handle of timers)
                 clearTimeout(handle);

package/dist/esm/index.d.ts

@@ -13,11 +13,13 @@
  * what the docs site and a native host read is a projection of the object that
  * runs, not a second copy kept by hand.
  */
-export { createElement, defineElement } from './define.js';
-export type { ActionContext, ActionMap, CreateElementOptions, ElementCategory, ElementCore, ElementDefinition, ElementInstance, ElementView, EventSpec, PropSpec, PropSpecs, PropType, Runtime, StringMap, ViewContext, } from './define.js';
+export { createElement, defineElement, NO_QUERY, NO_STORAGE } from './define.js';
+export type { ActionContext, ActionMap, CreateElementOptions, ElementCategory, ElementCore, ElementDefinition, ElementInstance, ElementQuery, ElementStorage, ElementView, EventSpec, MountContext, MountTeardown, PropSpec, PropSpecs, PropType, Runtime, StringMap, ViewContext, } from './define.js';
 export { manifestOf } from './manifest.js';
 export type { AnyElementCore, ElementManifest, ManifestEvent, ManifestProp } from './manifest.js';
-export type { ElementCartManager, ElementClient, ElementEventsManager } from './client.js';
+export type { ElementAuthManager, ElementCartManager, ElementCheckoutContext, ElementClient, ElementEventContext, ElementEventsManager, ElementModalOptions, ElementOrderResult, ElementOrdersManager, ElementPresaleManager, ElementPresaleRedemption, } from './client.js';
 export { cartTotals, expressesFee, minorUnits, selectionTotals, FEE_LABEL_FALLBACK, } from './money.js';
 export type { TlCartLike, TlFeeQuote, TlSelectionLine, TlSelectionTotals, TlTotals, } from './money.js';
+export { errorMessage, formatDate, formatDateTime, formatPrice, orderCustomerEmail, orderEventName, orderTotals, resolveOccurrence, statusLabel, statusTone, ticketCount, ticketItems, totalsAgree, } from './orders.js';
+export type { StatusTone, TlOrderData, TlOrderItem, TlOrderTicketRef, TlOrderTotals, TlResolvedOccurrence, TlTicketData, } from './orders.js';
 export * from './cores/index.js';

package/dist/esm/index.js

@@ -13,7 +13,8 @@
  * what the docs site and a native host read is a projection of the object that
  * runs, not a second copy kept by hand.
  */
-export { createElement, defineElement } from './define.js';
+export { createElement, defineElement, NO_QUERY, NO_STORAGE } from './define.js';
 export { manifestOf } from './manifest.js';
 export { cartTotals, expressesFee, minorUnits, selectionTotals, FEE_LABEL_FALLBACK, } from './money.js';
+export { errorMessage, formatDate, formatDateTime, formatPrice, orderCustomerEmail, orderEventName, orderTotals, resolveOccurrence, statusLabel, statusTone, ticketCount, ticketItems, totalsAgree, } from './orders.js';
 export * from './cores/index.js';

package/dist/esm/manifest.d.ts

@@ -18,6 +18,12 @@ export interface ManifestProp {
     name: string;
     attr: string | null;
     type: string;
+    /**
+     * The narrower type the core writes out, when it has one: a literal union or
+     * an optional prop. Null when `type` says it all. The catalogue emitter
+     * compares this, falling back to `type`, against the Stencil build.
+     */
+    tsType: string | null;
     default: unknown;
     required: boolean;
     docs: string;
@@ -41,6 +47,12 @@ export interface ElementManifest {
     strings: Record<string, string>;
     statuses: string[];
     actions: string[];
+    /**
+     * Whether the core declares a `mount` hook (TKT-197). A harness calls
+     * `instance.mount()` either way; this says whether anything happens, which
+     * is the one part of the lifecycle a consumer of the catalogue can see.
+     */
+    mounts: boolean;
 }
 /**
  * A core with its type parameters forgotten, which is all a registry or the

package/dist/esm/manifest.js

@@ -5,6 +5,7 @@ export function manifestOf(core) {
         name,
         attr: spec.attr,
         type: spec.type,
+        tsType: spec.tsType ?? null,
         default: spec.default ?? null,
         required: !!spec.required,
         docs: spec.docs,
@@ -25,6 +26,7 @@ export function manifestOf(core) {
         strings: { ...core.strings },
         statuses: [...core.statuses],
         actions: Object.keys(dryRunActions(core)).sort(),
+        mounts: typeof core.mount === 'function',
     };
 }
 /**
@@ -47,5 +49,8 @@ function dryRunActions(core) {
         client: refuse('client'),
         optionalClient: refuse('optionalClient'),
         after: refuse('after'),
+        storage: { get: refuse('storage.get'), set: refuse('storage.set') },
+        query: { get: refuse('query.get') },
+        whenClient: refuse('whenClient'),
     });
 }

package/dist/esm/orders.d.ts

@@ -0,0 +1,110 @@
+import type { ElementClient } from './client.js';
+export interface TlOrderItem {
+    name: string;
+    description?: string | null;
+    type?: string;
+    quantity: number;
+    unitPrice: number | string;
+    subtotal: number | string;
+}
+export interface TlOrderTicketRef {
+    id: string;
+    name: string;
+    eventOccurrenceId: string | null;
+}
+export interface TlOrderData {
+    id: string;
+    orderNumber: string;
+    status: string;
+    paymentStatus?: string;
+    currency: string;
+    items: TlOrderItem[];
+    subtotal: number | string;
+    totalFees?: number | string;
+    totalTax?: number | string;
+    totalDiscounts?: number | string;
+    total: number | string;
+    tickets?: TlOrderTicketRef[];
+    createdAt?: string;
+    eventName?: string | null;
+    customerEmail?: string | null;
+    customer?: {
+        email?: string | null;
+    } | null;
+}
+/**
+ * One issued ticket, as the order view carries it: the redemption token a
+ * scanner reads, what it admits and whether it has been used.
+ */
+export interface TlTicketData {
+    id: string;
+    barcode: string;
+    type: string;
+    status: string;
+    holderName: string | null;
+    name: string;
+    admissionStatus: string;
+    eventOccurrenceId: string | null;
+    seatLabel: string | null;
+}
+export interface TlResolvedOccurrence {
+    eventId: string;
+    eventName: string;
+    startsAt: string | null;
+}
+/** Money arrives as minor-unit integers or decimal strings ("50.00"). */
+export declare function formatPrice(value: number | string | null | undefined, currency?: string): string;
+export declare function formatDateTime(iso: string): string;
+export declare function formatDate(iso: string): string;
+/** Line items that are tickets (fees, taxes and discounts have their own type). */
+export declare function ticketItems(order: TlOrderData): TlOrderItem[];
+export declare function ticketCount(order: TlOrderData): number;
+/** Event name as the order view exposes it: the first ticket line's name. */
+export declare function orderEventName(order: TlOrderData): string | null;
+export declare function orderCustomerEmail(order: TlOrderData | null, customer: unknown): string | null;
+export declare function statusLabel(status: string | undefined): string;
+export type StatusTone = 'success' | 'info' | 'warning' | 'error' | 'muted';
+export declare function statusTone(status: string | undefined): StatusTone;
+export declare function errorMessage(err: unknown, fallback: string): string;
+/**
+ * Find the event and start time for an occurrence id. The order view only
+ * carries the occurrence id, so this walks the channel's listings (cached by
+ * live-api) until one owns the occurrence. Best effort: null when not found,
+ * and null on a client whose events manager cannot list or fetch, which is an
+ * older connector rather than a failure.
+ */
+export declare function resolveOccurrence(client: ElementClient, occurrenceId: string, maxEvents?: number): Promise<TlResolvedOccurrence | null>;
+/**
+ * The money rows the order views render.
+ *
+ * Two things about the sales order view drive this (backstage-api
+ * `src/domains/orders/services/order-line-items.service.ts`, `views/index.ts`):
+ *
+ *  - the fee is a LINE ITEM, `type: 'fee'`, named after the channel fee
+ *    profile's `serviceFeeLabel` (the API falls back to "Service Fee"). That
+ *    name is the only place the label reaches a buyer-facing response.
+ *  - `order.subtotal` INCLUDES the fee line, because the order's totals sum
+ *    every non-discount, non-tax line into it; and `order.totalFees` is set at
+ *    order creation and never rewritten by the recalculation, so it reads 0 on
+ *    a real order that charged a fee. Rendering "Subtotal" straight off the
+ *    order therefore hides the fee inside it, which is the bug this fixes.
+ *
+ * So the fee comes from the fee lines first and `totalFees` only as a
+ * fallback, the subtotal is the ticket lines alone, and the total is the
+ * order's own figure - never a sum of ours.
+ */
+export interface TlOrderTotals {
+    currency: string;
+    /** Ticket lines only, in minor units: the fee is not folded in. */
+    subtotal: number;
+    fees: number;
+    feeLabel: string;
+    showFee: boolean;
+    tax: number;
+    discount: number;
+    /** What the buyer was charged, as the order reports it. */
+    total: number;
+}
+export declare function orderTotals(order: TlOrderData | null | undefined): TlOrderTotals;
+/** The rows add up to the total the order reports. Asserted in the specs. */
+export declare function totalsAgree(totals: TlOrderTotals): boolean;