@owask/tapace-templates 0.0.0-stage → 0.1.0

package/dist/compiler/passmint-compiler.js

@@ -0,0 +1,507 @@
+import { Pass, PassmintError, PassmintSchemaError, renderApplePass, renderGooglePayload, } from 'passmint';
+import { POSTER_SLOTS, STANDARD_SLOTS, featuredActions, imageAssetId, imageSlotsOf, posterLayoutFields, posterLogoAssetId, posterEnabled, resolveRelevance, standardLayoutFields, } from '../contract/index.js';
+import { appleDateStyle, eventFieldValue, eventSemantics, googleEvent, googleLocations, googleShowsNatively, } from './event-ticket.js';
+import { stampRenderFor } from './stamp-card.js';
+import { googleAccountId, googleLoyalty, googleProgramNames, isLoyaltyCard, loyaltyBalanceText, loyaltyFieldTexts, loyaltyShowsNatively, } from './loyalty-card.js';
+export const PREVIEW_ISSUANCE = {
+    passTypeIdentifier: 'pass.tapace.preview',
+    teamIdentifier: 'TAPACEPREV',
+    serialNumber: 'preview',
+};
+export const WALLET_MESSAGE_FIELDS = [
+    {
+        kind: 'announcement',
+        key: 'tapace_announcement',
+        label: 'Announcements',
+        placeholder: 'No announcements yet',
+    },
+    {
+        kind: 'personal',
+        key: 'tapace_message',
+        label: 'Message for you',
+        placeholder: 'No messages yet',
+    },
+];
+const PREVIEW_ISSUER_ID = '0000000000000000';
+/** Google keeps at most 10 merchant locations on a class, and 10 on an object. */
+const MAX_GOOGLE_LOCATIONS = 10;
+export class AssetResolutionError extends Error {
+}
+/**
+ * Stand-in assets for structural validation (field counts, colors, required
+ * icon, barcode) without reading real bytes. Ownership + image validity are
+ * checked separately at upload/reference time; real bytes/URLs are needed only
+ * at signing (a later feature).
+ */
+export function placeholderAssets(ids) {
+    const resolved = {};
+    for (const id of ids) {
+        resolved[id] = {
+            bytes: new Uint8Array([0]),
+            url: `https://assets.tapace.example/${id}`,
+        };
+    }
+    return resolved;
+}
+export function resolveFieldValue(field, values, mode) {
+    if (field.binding === 'perPass') {
+        const supplied = field.id !== undefined ? values[field.id] : undefined;
+        if (supplied !== undefined &&
+            !(mode === 'issue' && isBlankValue(supplied))) {
+            return supplied;
+        }
+        if (field.defaultValue !== undefined) {
+            if (mode === 'issue' && isBlankValue(field.defaultValue))
+                return undefined;
+            return field.defaultValue;
+        }
+        if (mode === 'preview')
+            return field.sampleValue !== undefined ? field.sampleValue : '';
+        return undefined;
+    }
+    if (field.defaultValue !== undefined)
+        return field.defaultValue;
+    if (mode === 'preview' && field.sampleValue !== undefined)
+        return field.sampleValue;
+    return '';
+}
+function isBlankValue(value) {
+    return typeof value === 'string' && value.trim() === '';
+}
+function resolveBarcodeMessage(barcode, options) {
+    switch (barcode.source.kind) {
+        case 'static':
+            return barcode.source.value;
+        case 'serialNumber':
+            return options.issuance.serialNumber;
+        case 'passValue': {
+            if (options.mode === 'preview')
+                return barcode.source.sampleValue ?? '';
+            // Issued/deployed passes: use the stored per-pass value, or fall back to the
+            // pass's serial number when none was provided (barcode transition rules).
+            const provided = options.barcodeValue?.trim();
+            return provided ? provided : options.issuance.serialNumber;
+        }
+    }
+}
+/**
+ * The barcode message an already-issued pass renders, honoring the `passValue`
+ * serial-number fallback. Shared by the sign path and the deployment engine so the
+ * fallback lives in one place.
+ */
+export function resolveIssuedBarcodeMessage(barcode, barcodeValue, serialNumber) {
+    return resolveBarcodeMessage(barcode, {
+        mode: 'issue',
+        issuance: { ...PREVIEW_ISSUANCE, serialNumber },
+        barcodeValue: barcodeValue ?? undefined,
+    });
+}
+/**
+ * Whether passmint accepts a barcode payload for a format/encoding — used by the
+ * deployment engine to decide when a format/encoding change makes an existing
+ * payload unrenderable (omit until corrected). Everything but the barcode is a
+ * valid placeholder, so a schema error isolates the barcode.
+ */
+export function barcodeRenderable(format, message, messageEncoding) {
+    try {
+        const barcode = { format, message };
+        if (messageEncoding)
+            barcode.messageEncoding = messageEncoding;
+        Pass.generic({
+            passTypeIdentifier: PREVIEW_ISSUANCE.passTypeIdentifier,
+            teamIdentifier: PREVIEW_ISSUANCE.teamIdentifier,
+            serialNumber: PREVIEW_ISSUANCE.serialNumber,
+            organizationName: 'preview',
+            description: 'preview',
+            images: { icon: { x2: { bytes: new Uint8Array([0]) } } },
+            colors: { background: '#000000', foreground: '#FFFFFF' },
+        })
+            .barcode(barcode)
+            .build();
+        return true;
+    }
+    catch (err) {
+        if (err instanceof PassmintSchemaError)
+            return false;
+        throw err;
+    }
+}
+function imageValue(asset, platform, slot) {
+    if (platform === 'apple') {
+        if (!asset.bytes) {
+            throw new AssetResolutionError(`Apple requires image bytes for slot "${slot}".`);
+        }
+        return { x2: { bytes: asset.bytes } };
+    }
+    if (!asset.url) {
+        throw new AssetResolutionError(`Google requires an https URL for slot "${slot}".`);
+    }
+    return { x2: { url: asset.url } };
+}
+function buildImages(def, options) {
+    const images = {};
+    for (const slot of imageSlotsOf(def)) {
+        if (slot === 'artwork' || slot === 'primaryLogo')
+            continue;
+        const id = options.platform === 'google' && slot === 'logo'
+            ? def.google.logoAssetId
+            : imageAssetId(def, slot);
+        if (!id)
+            continue;
+        const asset = options.assets[id];
+        if (!asset)
+            throw new AssetResolutionError(`Missing resolved asset for slot "${slot}".`);
+        images[slot] = imageValue(asset, options.platform, slot);
+    }
+    const heroId = def.google.heroAssetId;
+    if (options.platform === 'google' && heroId) {
+        const asset = options.assets[heroId];
+        if (!asset?.url)
+            throw new AssetResolutionError('Google hero image requires an https URL.');
+        images.heroImage = { url: asset.url };
+    }
+    if (options.platform === 'apple' && posterEnabled(def)) {
+        // A stamp card's poster art is drawn per pass, with its stamps.
+        if (def.type !== 'stamp_card') {
+            const artworkId = imageAssetId(def, 'artwork');
+            const artwork = artworkId ? options.assets[artworkId] : undefined;
+            if (!artwork)
+                throw new AssetResolutionError('Missing resolved asset for slot "artwork".');
+            // A generic pass's art stays in background.png, as first device-tested; the
+            // other styles have their own use for that file or none.
+            images[def.type === 'generic' ? 'background' : 'artwork'] = imageValue(artwork, 'apple', 'artwork');
+        }
+        const logoId = posterLogoAssetId(def);
+        if (logoId) {
+            const logo = options.assets[logoId];
+            if (!logo)
+                throw new AssetResolutionError('Missing resolved asset for slot "primaryLogo".');
+            images.primaryLogo = imageValue({ bytes: logo.posterLogoBytes ?? logo.bytes }, 'apple', 'primaryLogo');
+        }
+    }
+    return images;
+}
+function fieldValueFor(def, field, values, mode, loyaltyTexts) {
+    if (field.binding === 'event')
+        return eventFieldValue(def, field, mode);
+    if (field.binding === 'shared' || field.binding === 'perPass')
+        return resolveFieldValue(field, values, mode);
+    return loyaltyTexts[field.binding];
+}
+function mapField(def, field, values, mode, platform, loyaltyTexts, changeMessage) {
+    if (platform === 'google' && (googleShowsNatively(def, field) || loyaltyShowsNatively(def, field)))
+        return undefined;
+    const value = fieldValueFor(def, field, values, mode, loyaltyTexts);
+    if (value === undefined)
+        return undefined;
+    const mapped = { key: field.key, label: field.label, value };
+    if (field.textAlignment)
+        mapped.textAlignment = field.textAlignment;
+    if (changeMessage)
+        mapped.changeMessage = changeMessage;
+    const dateStyle = platform === 'apple' && value !== '' ? appleDateStyle(field) : undefined;
+    if (dateStyle)
+        Object.assign(mapped, dateStyle);
+    return mapped;
+}
+function actionUrl(action, links, mode) {
+    const supplied = action.id !== undefined ? links[action.id] : undefined;
+    switch (action.binding) {
+        case 'fixed':
+            return action.url;
+        case 'overridable':
+            return supplied ?? action.url;
+        case 'perPass':
+            return mode === 'preview' ? (supplied ?? action.sampleUrl) : supplied;
+    }
+}
+function mapBarcode(def, options) {
+    if (!def.barcode)
+        return undefined;
+    const barcode = {
+        format: def.barcode.format,
+        message: resolveBarcodeMessage(def.barcode, options),
+    };
+    // Wallets render the message when altText is absent or empty; a single space
+    // is what blanks the line on both Apple and Google.
+    if (def.barcode.showText === false)
+        barcode.altText = ' ';
+    else if (def.barcode.altText)
+        barcode.altText = def.barcode.altText;
+    if (def.barcode.messageEncoding)
+        barcode.messageEncoding = def.barcode.messageEncoding;
+    return barcode;
+}
+/** Build the validated passmint pass for one platform. Throws PassmintSchemaError on invalid mappings. */
+export function compile(def, options) {
+    const mode = options.mode ?? 'preview';
+    const values = options.values ?? {};
+    const issuance = options.issuance ?? PREVIEW_ISSUANCE;
+    const base = {
+        passTypeIdentifier: issuance.passTypeIdentifier,
+        teamIdentifier: issuance.teamIdentifier,
+        serialNumber: issuance.serialNumber,
+        organizationName: def.organizationName,
+        description: def.description,
+        images: buildImages(def, options),
+        colors: {
+            background: def.colors.background,
+            foreground: def.colors.foreground,
+            ...(def.colors.label ? { label: def.colors.label } : {}),
+        },
+    };
+    const poster = options.platform === 'apple' && posterEnabled(def);
+    // logoText is one key for both Apple layouts, so the poster's choice decides it
+    // on older iOS too, over hideLogoText.
+    const posterBrand = poster ? def.apple.poster?.brand : undefined;
+    const hideAppleLogoText = posterBrand
+        ? posterBrand === 'logo'
+        : def.apple.hideLogoText;
+    if (def.logoText && !(options.platform === 'apple' && hideAppleLogoText))
+        base.logoText = def.logoText;
+    if (options.platform === 'apple' &&
+        def.apple.sharingProhibited !== undefined) {
+        base.sharingProhibited = def.apple.sharingProhibited;
+    }
+    if (options.platform === 'apple' && options.webService) {
+        base.webService = options.webService;
+    }
+    if (options.platform === 'apple' && options.voided)
+        base.voided = true;
+    if (options.platform === 'apple') {
+        const { locations, dates } = resolveRelevance(def, options.relevance);
+        if (locations.length > 0) {
+            base.locations = locations.map(({ latitude, longitude, message }) => ({
+                latitude,
+                longitude,
+                ...(message ? { relevantText: message } : {}),
+            }));
+        }
+        if (dates.length > 0) {
+            // Wallet follows the first window that hasn't ended and ignores the rest
+            // (verified on iOS 27), so the windows go in time order.
+            base.relevantDates = [...dates]
+                .sort((a, b) => Date.parse(a.start) - Date.parse(b.start))
+                .map(({ start, end }) => ({ startDate: start, endDate: end }));
+        }
+    }
+    if (options.platform === 'google') {
+        // A generic class carries no design, so its object takes the template's
+        // locations; loyalty and event classes carry them, and the object only the
+        // pass's own (device test GN1: Google's nearby notice showed with class locations).
+        const own = def.type === 'generic'
+            ? resolveRelevance(def, options.relevance).locations
+            : (options.relevance?.locations ?? []);
+        const merchantLocations = googleLocations(def, own);
+        // Passmint has no Google merchantLocations; applyRaw sets them on the object.
+        if (merchantLocations.length > 0)
+            base.applyRaw = { google: { merchantLocations } };
+    }
+    const stamps = def.type === 'stamp_card' ? stampRenderFor(def, options.stamps, mode) : undefined;
+    const balanceText = loyaltyBalanceText(def, stamps?.count ?? 0, options.points);
+    const loyaltyTexts = loyaltyFieldTexts(def, stamps?.count ?? 0, options.points);
+    if (stamps && options.platform === 'apple') {
+        base.images.strip = {
+            x2: { bytes: stamps.appleStrip.x2 },
+            x3: { bytes: stamps.appleStrip.x3 },
+        };
+        if (poster)
+            base.images.artwork = { x2: { bytes: stamps.appleArtwork } };
+    }
+    if (stamps && options.platform === 'google')
+        base.images.googleObject = { heroImage: { url: stamps.googleHeroUrl } };
+    const valueOf = (field) => fieldValueFor(def, field, values, mode, loyaltyTexts);
+    if (isLoyaltyCard(def) && options.platform === 'google') {
+        const accountId = googleAccountId(def, valueOf);
+        // Passmint uses the serial number as the loyalty account id; applyRaw replaces it.
+        if (accountId)
+            base.applyRaw = { google: { ...base.applyRaw?.google, accountId } };
+    }
+    const semantics = eventSemantics(def, valueOf);
+    if (semantics)
+        base.semantics = semantics;
+    if (options.platform === 'google') {
+        const event = googleEvent(def, valueOf, options.holderName ?? undefined);
+        if (event)
+            base.google = { event };
+    }
+    const builder = def.type === 'event_ticket'
+        ? Pass.eventTicket(poster ? { ...base, poster: true } : base)
+        : isLoyaltyCard(def)
+            ? Pass.storeCard({
+                ...base,
+                ...(poster ? { poster: true } : {}),
+                google: options.platform === 'google'
+                    ? { loyalty: googleLoyalty(def, balanceText ?? '', valueOf) }
+                    : undefined,
+            })
+            : Pass.generic(poster ? { ...base, poster: true } : base);
+    const adders = {
+        header: (f) => builder.headerField(f),
+        primary: (f) => builder.primaryField(f),
+        secondary: (f) => builder.secondaryField(f),
+        auxiliary: (f) => builder.auxiliaryField(f),
+        back: (f) => builder.backField(f),
+    };
+    const changeMessages = options.platform === 'apple' ? options.changeMessages : undefined;
+    const map = (field) => mapField(def, field, values, mode, options.platform, loyaltyTexts, field.id !== undefined ? changeMessages?.[field.id] : undefined);
+    // Wallet ignores the generic block's back fields on a poster, so the reserved
+    // notification fields lead the back of both blocks.
+    const walletMessageFields = options.platform === 'apple' && options.walletMessages
+        ? WALLET_MESSAGE_FIELDS.map((field) => ({
+            key: field.key,
+            label: field.label,
+            value: options.walletMessages?.[field.kind] ?? field.placeholder,
+            changeMessage: '%@',
+        }))
+        : [];
+    for (const field of walletMessageFields)
+        builder.backField(field);
+    const standard = standardLayoutFields(def);
+    for (const slot of STANDARD_SLOTS) {
+        for (const field of standard[slot]) {
+            const mapped = map(field);
+            if (mapped)
+                adders[slot](mapped);
+        }
+    }
+    if (poster) {
+        for (const field of walletMessageFields)
+            builder.posterField('back', field);
+        const posterFields = posterLayoutFields(def);
+        for (const slot of POSTER_SLOTS) {
+            for (const field of posterFields?.[slot] ?? []) {
+                const mapped = map(field);
+                if (mapped)
+                    builder.posterField(slot, mapped);
+            }
+        }
+    }
+    if (options.platform === 'apple') {
+        for (const action of featuredActions(def)) {
+            const url = actionUrl(action, options.actionLinks ?? {}, mode);
+            if (url)
+                builder.featuredAction({ identifier: action.key, type: action.type, url });
+        }
+    }
+    const barcode = mapBarcode(def, {
+        values,
+        mode,
+        issuance,
+        barcodeValue: options.barcodeValue,
+    });
+    if (barcode)
+        builder.barcode(barcode);
+    return builder.build().toObject();
+}
+/** The resolved barcode payload for preview/display, or undefined if no barcode. */
+export function previewBarcodeMessage(def) {
+    if (!def.barcode)
+        return undefined;
+    return resolveBarcodeMessage(def.barcode, {
+        mode: 'preview',
+        issuance: PREVIEW_ISSUANCE,
+    });
+}
+export function renderApple(def, options) {
+    return renderApplePass(compile(def, { ...options, platform: 'apple' }));
+}
+export function renderGoogle(def, options) {
+    const payload = renderGooglePayload(compile(def, { ...options, platform: 'google' }), {
+        issuerId: options.issuerId ?? PREVIEW_ISSUER_ID,
+        ...(options.classSuffix ? { classSuffix: options.classSuffix } : {}),
+        ...(options.objectSuffix ? { objectSuffix: options.objectSuffix } : {}),
+    });
+    // Passmint gives every class the shared fields (issuerName, reviewStatus,
+    // hexBackgroundColor), none of which GenericClass defines: a generic card
+    // comes entirely from its object, so the class keeps only its id (and the
+    // holder lock below).
+    const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+    if (payload.genericClasses)
+        payload.genericClasses = payload.genericClasses
+            .filter(isRecord)
+            .map(({ id }) => ({ id }));
+    if (def.google.singleHolder) {
+        for (const [key, entries] of Object.entries(payload)) {
+            if (!key.endsWith('Classes') || !Array.isArray(entries))
+                continue;
+            for (const cls of entries.filter(isRecord))
+                cls.multipleDevicesAndHoldersAllowedStatus = 'ONE_USER_ALL_DEVICES';
+        }
+    }
+    const loyaltyClasses = (payload.loyaltyClasses ?? []).filter(isRecord);
+    if (isLoyaltyCard(def)) {
+        for (const cls of loyaltyClasses)
+            Object.assign(cls, googleProgramNames(def));
+    }
+    const classLocations = def.type === 'generic' ? [] : googleLocations(def, def.relevance?.locations ?? []);
+    if (classLocations.length > 0) {
+        // An event class already lists its venue (from passmint); the template's places follow it.
+        for (const cls of [...loyaltyClasses, ...(payload.eventTicketClasses ?? []).filter(isRecord)]) {
+            const current = Array.isArray(cls.merchantLocations) ? cls.merchantLocations : [];
+            cls.merchantLocations = [...current, ...classLocations].slice(0, MAX_GOOGLE_LOCATIONS);
+        }
+    }
+    const wideLogoId = def.google.wideLogoAssetId;
+    if (wideLogoId) {
+        // Passmint has no wide logo; an event ticket's and a loyalty program's live on the class.
+        const uri = options.assets[wideLogoId]?.url;
+        if (!uri)
+            throw new AssetResolutionError('Google wide logo requires an https URL.');
+        const holders = [
+            ...(payload.genericObjects ?? []),
+            ...(payload.eventTicketClasses ?? []),
+        ].filter(isRecord);
+        for (const holder of holders)
+            holder.wideLogo = { sourceUri: { uri } };
+        for (const cls of loyaltyClasses)
+            cls.wideProgramLogo = { sourceUri: { uri } };
+    }
+    if (options.voided) {
+        // Passmint always emits `state: "ACTIVE"`.
+        for (const [key, entries] of Object.entries(payload)) {
+            if (!key.endsWith('Objects') || !Array.isArray(entries))
+                continue;
+            for (const object of entries.filter(isRecord))
+                object.state = 'INACTIVE';
+        }
+    }
+    return payload;
+}
+/**
+ * Compile each enabled platform and collect passmint's own schema issues.
+ * Used by the preview/validate endpoint so the designer surfaces native-limit
+ * violations (field counts, missing icon, bad color) the way it surfaces ours.
+ */
+export function collectCompileIssues(def, options) {
+    const issues = [];
+    const platforms = [];
+    if (def.platforms.apple)
+        platforms.push('apple');
+    if (def.platforms.google)
+        platforms.push('google');
+    for (const platform of platforms) {
+        try {
+            compile(def, { ...options, platform });
+        }
+        catch (err) {
+            issues.push(...toCompileIssues(platform, err));
+        }
+    }
+    return issues;
+}
+export function toCompileIssues(platform, err) {
+    if (err instanceof PassmintSchemaError) {
+        return err.issues.map((issue) => ({
+            platform,
+            path: (issue.path ?? [])
+                .map((p) => typeof p === 'object' && p !== null ? p.key : p)
+                .join('.'),
+            message: issue.message ?? 'Invalid value.',
+        }));
+    }
+    if (err instanceof AssetResolutionError || err instanceof PassmintError) {
+        return [{ platform, path: '', message: err.message }];
+    }
+    throw err;
+}

package/dist/compiler/preview-model.d.ts

@@ -0,0 +1,123 @@
+import { type TemplateDefinition } from '../contract/index.js';
+import { type CompileOptions } from './passmint-compiler.js';
+export interface FieldPreview {
+    key: string;
+    label: string;
+    value: string;
+    textAlignment?: 'left' | 'center' | 'right' | 'start';
+}
+export interface BarcodePreview {
+    format: string;
+    message: string;
+    altText?: string;
+}
+export type PreviewStyle = 'generic' | 'eventTicket' | 'storeCard';
+export interface ApplePreview {
+    platform: 'apple';
+    style: PreviewStyle;
+    organizationName: string;
+    description: string;
+    logoText?: string;
+    colors: {
+        background: string;
+        foreground: string;
+        label: string;
+    };
+    images: {
+        logo?: string;
+        thumbnail?: string;
+        strip?: string;
+        background?: string;
+        /** A stamp card's drawn stamps, as a PNG data URL. */
+        stamps?: string;
+    };
+    fields: Record<'header' | 'primary' | 'secondary' | 'auxiliary' | 'back', FieldPreview[]>;
+    barcode?: BarcodePreview;
+    /** The iOS 27 poster, when it is on. The fields above are what older iOS shows. */
+    poster?: PosterPreview;
+    featuredActions: {
+        key: string;
+        type: string;
+        url: string;
+    }[];
+}
+export interface PosterPreview {
+    brand: 'logo' | 'text' | 'logoAndText';
+    /** `stamps` is a stamp card's poster art with its stamps drawn in, as a PNG data URL. */
+    images: {
+        artwork?: string;
+        logo?: string;
+        stamps?: string;
+    };
+    fields: Record<'header' | 'primary' | 'footer' | 'additionalInfo' | 'back', FieldPreview[]>;
+}
+export interface GoogleCardItemPreview {
+    label: string;
+    value: string;
+    /** An event time: `value` is a timestamp to format in `GoogleEventPreview.timezone`. */
+    time?: 'dateTime' | 'date' | 'time';
+}
+/** A Google event ticket's native parts; its own fields are `textModules`. */
+export interface GoogleEventPreview {
+    issuerName: string;
+    eventName: string;
+    venue?: {
+        name: string;
+        address: string;
+    };
+    dateTime: {
+        doorsOpen?: string;
+        start?: string;
+        end?: string;
+    };
+    doorsOpenLabel: 'doorsOpen' | 'gatesOpen';
+    timezone?: string;
+    seat: {
+        seat?: string;
+        row?: string;
+        section?: string;
+        gate?: string;
+    };
+    ticketHolderName?: string;
+    ticketType?: string;
+    ticketNumber: string;
+    /** The template's card-front rows; Google's default rows when absent. */
+    cardRows?: GoogleCardItemPreview[][];
+}
+/** A Google loyalty card's (stamp or points) native parts; its own fields are `textModules`. */
+export interface GoogleLoyaltyPreview {
+    issuerName: string;
+    programName: string;
+    balance: {
+        label: string;
+        value: string;
+    };
+    accountName?: string;
+    accountId: string;
+}
+/** A generic card, or the native event ticket (`event`) or loyalty card (`loyalty`). */
+export interface GooglePreview {
+    platform: 'google';
+    style: 'generic' | 'eventTicket' | 'loyalty';
+    event?: GoogleEventPreview;
+    loyalty?: GoogleLoyaltyPreview;
+    cardTitle: string;
+    header: string;
+    subheader?: string;
+    backgroundColor: string;
+    foregroundColor: string;
+    labelColor: string;
+    /** `stamps` is a stamp card's drawn stamps (Google's hero), as a PNG data URL. */
+    images: {
+        logo?: string;
+        wideLogo?: string;
+        hero?: string;
+        stamps?: string;
+    };
+    textModules: FieldPreview[];
+    barcode?: BarcodePreview;
+}
+type Options = Omit<CompileOptions, 'platform'>;
+export declare function applePreview(def: TemplateDefinition, options: Options): ApplePreview;
+export declare function googlePreview(def: TemplateDefinition, options: Options): GooglePreview;
+export {};