@genlook/storefront 0.1.0

package/dist/client.js

@@ -0,0 +1,465 @@
+import { initialCoreState, selectUnseenResults } from "./entities";
+import { createStore } from "./store";
+import { can as evaluatePolicy, PolicyBlockedError } from "./policy";
+import { attachAnalytics } from "./analytics";
+import { runUpload } from "./upload";
+import { PendingUpload } from "./pending-upload";
+import { CoreEvents } from "./events";
+function photoMetaFields(meta) {
+    return {
+        fileSize: meta.fileSize,
+        mimeType: meta.mimeType,
+        uploadSource: meta.uploadSource,
+        skipClientDimensionCheck: meta.skipClientDimensionCheck,
+        ...(meta.photoAgeSeconds != null ? { photo_age_s: meta.photoAgeSeconds } : {}),
+        ...(meta.capturedInPicker != null ? { captured_in_picker: meta.capturedInPicker } : {}),
+        ...(meta.pickerDurationMs != null ? { picker_duration_ms: meta.pickerDurationMs } : {}),
+        ...(meta.pickerBackgrounded != null ? { picker_backgrounded: meta.pickerBackgrounded } : {}),
+        ...(meta.heldDurationMs != null ? { held_duration_ms: meta.heldDurationMs } : {}),
+        ...(typeof meta.dimensions === "object"
+            ? { width: meta.dimensions.width, height: meta.dimensions.height }
+            : {}),
+    };
+}
+import { getCurrentPlan, checkCredits, rateGeneration, rateResult, runGeneration, acknowledgeGeneration, scheduleInFlightResumes, GenerationFailedError, } from "./generation";
+import { collectEmail } from "./email";
+import { runDataErasure } from "./erasure";
+import { createShareLink, getShareUrl } from "./sharing";
+import { loadJobs, saveJobs } from "./persistence";
+import { loadConsent, saveConsent } from "./consent";
+import { loadUsage, saveUsage, mergeUsage, migrateLegacyUsage, pruneTryOns } from "./usage";
+import { loadHistory, saveHistory, selectRecentResults, buildTryOnResult, appendEntry, updateEntry, } from "./history";
+const CREDITS_CHECK_CACHE_TTL = 2 * 60 * 1000;
+const GENERATE_DEDUP_TTL = 60 * 1000;
+const RATING_EVENT_SOURCE = "history-page-test-2";
+export class TryOnClient {
+    config;
+    transport;
+    storage;
+    track;
+    now;
+    netInfo;
+    onDispose;
+    disposed = false;
+    store;
+    creditsCheckCache = null;
+    inFlight = new Map();
+    pending = new PendingUpload();
+    staged = null;
+    events = new CoreEvents();
+    constructor(deps) {
+        this.config = deps.config;
+        this.transport = deps.transport;
+        this.storage = deps.storage;
+        this.track = deps.tracker ?? { capture: () => { } };
+        attachAnalytics(this.events, this.track);
+        this.now = deps.now ?? Date.now;
+        this.netInfo = deps.netInfo;
+        this.onDispose = deps.onDispose;
+        this.store = createStore(this.buildInitialState());
+        const storeId = this.config.storeId ?? "";
+        const now = this.now();
+        const usage = loadUsage(this.storage, storeId, now) ?? migrateLegacyUsage(this.storage, now);
+        const jobs = loadJobs(this.storage, storeId, now);
+        const history = loadHistory(this.storage);
+        const consent = loadConsent(this.storage, this.config.storeId);
+        this.store.subscribe(() => {
+            saveJobs(this.storage, storeId, Object.values(this.store.getState().generations));
+        });
+        this.store.subscribe(() => {
+            const now = this.now();
+            const merged = mergeUsage(loadUsage(this.storage, storeId, now), this.usageSnapshot(), now);
+            saveUsage(this.storage, storeId, merged, now);
+        });
+        this.store.subscribe(() => {
+            saveHistory(this.storage, this.store.getState().history);
+        });
+        if (usage || jobs.length > 0 || history.length > 0 || consent) {
+            this.store.setState((s) => {
+                const next = { ...s };
+                if (usage) {
+                    next.limits = {
+                        ...s.limits,
+                        tryOns: usage.tryOns, refunded: usage.refunded, totalTryOns: usage.totalTryOns,
+                    };
+                    next.identity = { ...s.identity, email: usage.email ?? s.identity.email };
+                }
+                if (jobs.length > 0) {
+                    const generations = { ...s.generations };
+                    for (const job of jobs)
+                        generations[job.id] = job;
+                    next.generations = generations;
+                }
+                if (history.length > 0)
+                    next.history = history;
+                if (consent)
+                    next.legalConsent = consent;
+                return next;
+            });
+        }
+        if (consent)
+            this.track.grantWidgetScopeConsent?.();
+        scheduleInFlightResumes(this.generationDeps(), jobs);
+    }
+    getState() {
+        return this.store.getState();
+    }
+    subscribe(listener) {
+        return this.store.subscribe(listener);
+    }
+    flushEvents(opts) {
+        return Promise.resolve(this.track.flush?.(opts)).then(() => undefined, () => undefined);
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.flushEvents().catch(() => { });
+        try {
+            this.onDispose?.();
+        }
+        catch { }
+    }
+    buildInitialState() {
+        const state = initialCoreState();
+        const l = this.config.limits ?? {};
+        state.limits.maxGenerations = l.maxGenerations ?? state.limits.maxGenerations;
+        state.limits.emailCollectionStep = l.emailCollectionStep ?? state.limits.emailCollectionStep;
+        state.limits.period = l.period === "daily" ? "daily" : "weekly";
+        if (l.maxConcurrent !== undefined)
+            state.limits.maxConcurrent = l.maxConcurrent;
+        state.limits.loggedInCustomersOnly = this.config.loggedInCustomersOnly ?? false;
+        state.limits.requireLegalConsent = this.config.requireLegalConsent ?? false;
+        state.identity.loggedInCustomerId = this.config.loggedInCustomerId ?? null;
+        return state;
+    }
+    applySettings(settings) {
+        this.store.setState((s) => {
+            const limits = { ...s.limits };
+            let changed = false;
+            if (settings.maxGenerations !== undefined && settings.maxGenerations !== limits.maxGenerations) {
+                limits.maxGenerations = settings.maxGenerations;
+                changed = true;
+            }
+            if (settings.emailCollectionStep !== undefined &&
+                settings.emailCollectionStep !== limits.emailCollectionStep) {
+                limits.emailCollectionStep = settings.emailCollectionStep;
+                changed = true;
+            }
+            if (settings.period !== undefined && settings.period !== limits.period) {
+                limits.period = settings.period;
+                changed = true;
+            }
+            if (settings.loggedInCustomersOnly !== undefined &&
+                settings.loggedInCustomersOnly !== limits.loggedInCustomersOnly) {
+                limits.loggedInCustomersOnly = settings.loggedInCustomersOnly;
+                changed = true;
+            }
+            return changed ? { ...s, limits } : s;
+        });
+    }
+    setIdentity(input) {
+        this.store.setState((s) => ({
+            ...s,
+            identity: {
+                email: input.email !== undefined ? input.email : s.identity.email,
+                loggedInCustomerId: input.loggedInCustomerId !== undefined ? input.loggedInCustomerId : s.identity.loggedInCustomerId,
+            },
+        }));
+    }
+    can(action) {
+        return evaluatePolicy(action, this.store.getState(), this.now());
+    }
+    usageSnapshot() {
+        const s = this.store.getState();
+        return {
+            tryOns: s.limits.tryOns,
+            refunded: s.limits.refunded,
+            totalTryOns: s.limits.totalTryOns,
+            email: s.identity.email,
+        };
+    }
+    syncUsageFromStorage() {
+        const now = this.now();
+        const persisted = loadUsage(this.storage, this.config.storeId ?? "", now);
+        if (!persisted)
+            return;
+        const current = this.usageSnapshot();
+        const merged = mergeUsage(persisted, current, now);
+        const unchanged = merged.tryOns.length === current.tryOns.length &&
+            merged.refunded.length === current.refunded.length &&
+            merged.totalTryOns === current.totalTryOns &&
+            merged.email === current.email;
+        if (unchanged)
+            return;
+        this.store.setState((s) => ({
+            ...s,
+            limits: {
+                ...s.limits,
+                tryOns: merged.tryOns, refunded: merged.refunded, totalTryOns: merged.totalTryOns,
+            },
+            identity: s.identity.email === null && merged.email
+                ? { ...s.identity, email: merged.email }
+                : s.identity,
+        }));
+    }
+    recordUsage() {
+        let now = this.now();
+        const { tryOns: existing, refunded } = this.store.getState().limits;
+        while (existing.includes(now) || refunded.includes(now))
+            now += 1;
+        const at = now;
+        this.store.setState((s) => ({
+            ...s,
+            limits: {
+                ...s.limits,
+                tryOns: pruneTryOns([...s.limits.tryOns, at], at),
+                totalTryOns: s.limits.totalTryOns + 1,
+            },
+        }));
+        return at;
+    }
+    acceptLegalConsent(version) {
+        const current = this.store.getState().legalConsent;
+        if (current && current.version === version)
+            return;
+        const consent = { version, acceptedAt: new Date(this.now()).toISOString() };
+        saveConsent(this.storage, this.config.storeId, consent);
+        this.store.setState((s) => ({ ...s, legalConsent: consent }));
+        this.events.emit({ type: "tryon:legal_consent_accepted", consent_version: version });
+        this.flushStagedPhoto();
+        this.track.grantWidgetScopeConsent?.();
+    }
+    unseenResults() {
+        return selectUnseenResults(this.store.getState());
+    }
+    acknowledge(generationId) {
+        acknowledgeGeneration(this.store, generationId);
+    }
+    netFields() {
+        if (!this.netInfo)
+            return {};
+        try {
+            const n = this.netInfo();
+            return {
+                net_online: n.online,
+                ...(n.effectiveType ? { net_effective_type: n.effectiveType } : {}),
+                ...(n.visibility ? { net_visibility: n.visibility } : {}),
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    uploadDeps() {
+        return {
+            transport: this.transport,
+            store: this.store,
+            now: this.now,
+            emitImageUpload: (meta) => this.events.emit({ type: "tryon:photo_upload_started", ...photoMetaFields(meta) }),
+            emitImageUploadSuccess: (meta, fileId, ms) => this.events.emit({
+                type: "tryon:photo_upload_succeeded",
+                fileId,
+                fileSize: meta.fileSize, mimeType: meta.mimeType,
+                uploadSource: meta.uploadSource, skipClientDimensionCheck: meta.skipClientDimensionCheck,
+                duration_ms: ms,
+            }),
+            emitImageUploadError: (meta, error) => this.events.emit({
+                type: "tryon:photo_upload_failed",
+                fileSize: meta.fileSize, mimeType: meta.mimeType, uploadSource: meta.uploadSource,
+                error: error.substring(0, 500),
+                kind: "upload_failed", code: "UPLOAD_FAILED",
+                ...this.netFields(),
+            }),
+            emitImageUploadRejected: (meta, reason, extra) => this.events.emit({
+                type: "tryon:photo_upload_rejected",
+                fileSize: meta.fileSize, mimeType: meta.mimeType, uploadSource: meta.uploadSource,
+                rejectionReason: reason,
+                kind: "upload_rejected",
+                ...(extra ?? {}),
+            }),
+        };
+    }
+    generationDeps() {
+        return {
+            transport: this.transport,
+            store: this.store,
+            now: this.now,
+            emitGenerationStart: (id) => this.events.emit({ type: "tryon:generation_started", generationId: id }),
+            emitGenerationSucceeded: (i) => this.events.emit({
+                type: "tryon:generation_succeeded",
+                generationId: i.generationId,
+                duration_ms: i.durationMs,
+                productId: i.productId,
+                ...(i.variantId !== undefined ? { variantId: i.variantId } : {}),
+            }),
+            emitGenerationFailed: (i) => this.events.emit({ type: "tryon:generation_failed", generationId: i.generationId, kind: i.kind, code: i.code }),
+            emitGenerationBlocked: (reason) => this.events.emit({ type: "tryon:generation_blocked", reason }),
+        };
+    }
+    uploadPhoto(file, meta, productContext) {
+        const verdict = this.can("upload");
+        if (!verdict.ok) {
+            const rejected = Promise.reject(new PolicyBlockedError(verdict.blocked));
+            rejected.catch(() => { });
+            return rejected;
+        }
+        const promise = runUpload(this.uploadDeps(), file, meta, productContext);
+        this.pending.register(promise);
+        return promise;
+    }
+    on(type, listener) {
+        return this.events.on(type, listener);
+    }
+    onAny(listener) {
+        return this.events.onAny(listener);
+    }
+    stagePhoto(file, meta, productContext) {
+        if (this.store.getState().legalConsent) {
+            this.staged = null;
+            this.events.emit({ type: "tryon:photo_submitted", held: false, ...photoMetaFields(meta) });
+            void this.uploadPhoto(file, meta, productContext);
+            return;
+        }
+        this.staged = { file, meta, productContext, heldAt: this.now() };
+        this.events.emit({ type: "tryon:photo_submitted", held: true, ...photoMetaFields(meta) });
+    }
+    flushStagedPhoto() {
+        const held = this.staged;
+        if (!held)
+            return;
+        this.staged = null;
+        const meta = { ...held.meta, heldDurationMs: Math.max(0, this.now() - held.heldAt) };
+        void this.uploadPhoto(held.file, meta, held.productContext);
+    }
+    clearPendingUpload() {
+        this.pending.clear();
+        this.staged = null;
+        this.events.emit({ type: "tryon:photo_discarded" });
+        this.store.setState((s) => (s.latestPhotoId === null ? s : { ...s, latestPhotoId: null }));
+    }
+    async resolveUserImageId(input) {
+        let userImageId = input.userImageId;
+        const pending = this.pending.current();
+        if (input.userImage === "latest" && pending) {
+            try {
+                userImageId = (await pending).fileId;
+            }
+            catch (err) {
+                throw new GenerationFailedError("UPLOAD_FAILED", err instanceof Error ? err.message : String(err));
+            }
+        }
+        if (!userImageId) {
+            throw new GenerationFailedError("UPLOAD_FAILED", "No uploaded photo available");
+        }
+        return userImageId;
+    }
+    async generate(input) {
+        const userImageId = await this.resolveUserImageId(input);
+        const key = `${userImageId}:${input.productId}:${input.variantId ?? ""}`;
+        const now = this.now();
+        const cached = this.inFlight.get(key);
+        if (cached && now - cached.ts < GENERATE_DEDUP_TTL)
+            return cached.promise;
+        this.syncUsageFromStorage();
+        const verdict = this.can("generate");
+        if (!verdict.ok) {
+            this.events.emit({ type: "tryon:generation_blocked", reason: verdict.blocked });
+            throw new PolicyBlockedError(verdict.blocked);
+        }
+        const usageAt = this.recordUsage();
+        const promise = runGeneration(this.generationDeps(), {
+            userImageId, productId: input.productId, variantId: input.variantId, usageAt,
+        }).then((res) => {
+            if (!input.context)
+                return res;
+            const result = buildTryOnResult({
+                generationId: res.generationId,
+                resultImage: res.imageUrl,
+                context: input.context,
+                now: this.now(),
+            });
+            this.appendResult(result);
+            return { ...res, result };
+        });
+        this.inFlight.set(key, { promise, ts: now });
+        promise.catch(() => {
+            const c = this.inFlight.get(key);
+            if (c && c.promise === promise)
+                this.inFlight.delete(key);
+        });
+        return promise;
+    }
+    getHistory() {
+        return this.store.getState().history;
+    }
+    appendResult(entry) {
+        this.store.setState((s) => ({ ...s, history: appendEntry(s.history, entry) }));
+    }
+    updateResult(id, patch) {
+        this.store.setState((s) => ({ ...s, history: updateEntry(s.history, id, patch) }));
+    }
+    replaceHistory(entries) {
+        this.store.setState((s) => ({ ...s, history: [...entries] }));
+    }
+    clearHistory() {
+        this.store.setState((s) => ({ ...s, history: [] }));
+    }
+    deleteMyData() {
+        return runDataErasure({
+            transport: this.transport,
+            clearHistory: () => this.clearHistory(),
+            clearPendingUpload: () => this.clearPendingUpload(),
+            emitDataErased: () => this.events.emit({ type: "tryon:data_erased" }),
+        });
+    }
+    recentResults(retentionDays) {
+        return selectRecentResults(this.store.getState().history, retentionDays, this.now());
+    }
+    getShareUrl(entryId, opts) {
+        return getShareUrl({
+            transport: this.transport,
+            store: this.store,
+            emitShareLinkCreated: (i) => this.events.emit({ type: "tryon:share_link_created", generationId: i.generationId, entryId: i.entryId }),
+        }, entryId, opts);
+    }
+    rateResult(entryId, rating, reason) {
+        return rateResult({
+            transport: this.transport,
+            store: this.store,
+            emitResultRated: (generationId, r) => this.events.emit({ type: "tryon:result_rated", generationId, rating: r, source: RATING_EVENT_SOURCE }),
+            emitResultRatingReason: (generationId, rc) => this.events.emit({ type: "tryon:result_feedback_given", generationId, reason: rc, source: RATING_EVENT_SOURCE }),
+        }, entryId, rating, reason);
+    }
+    getCurrentPlan() {
+        return getCurrentPlan(this.transport);
+    }
+    async checkCredits() {
+        const now = this.now();
+        if (this.creditsCheckCache && now - this.creditsCheckCache.timestamp < CREDITS_CHECK_CACHE_TTL) {
+            console.log("Using cached credits check result");
+            return this.creditsCheckCache.data;
+        }
+        const result = await checkCredits(this.transport);
+        this.creditsCheckCache = { data: result, timestamp: now };
+        this.store.setState((s) => ({ ...s, limits: { ...s.limits, creditsAllowed: result.allowed } }));
+        return result;
+    }
+    rateGeneration(generationId, rating, reason) {
+        return rateGeneration(this.transport, generationId, rating, reason);
+    }
+    collectEmail(request) {
+        this.setIdentity({ email: request.email });
+        this.events.emit({
+            type: "tryon:email_collected",
+            emailCollectionStep: request.emailCollectionStep,
+            checkboxDisplayed: true,
+            ...(request.marketingConsent !== undefined ? { marketingConsent: request.marketingConsent } : {}),
+        });
+        return collectEmail(this.transport, request);
+    }
+    createShareLink(generationId, effectiveDomain, productUrl) {
+        return createShareLink(this.transport, generationId, effectiveDomain, productUrl);
+    }
+}
+export { PolicyBlockedError };

package/dist/consent.d.ts

@@ -0,0 +1,17 @@
+import type { KVStorage } from "./ports";
+import type { LegalConsent } from "./entities";
+/** Same key the pre-headless sheet wrote: `tryon-legal-consent:${storeId ?? "default"}`.
+ *  `storeId` is optional and threaded through un-coerced (the client passes
+ *  `config.storeId`) so it matches the sheet's `host.storeId` — both descend from
+ *  the one boot-computed storeId. */
+export declare function consentStorageKey(storeId?: string): string;
+/**
+ * Load the persisted consent record, or null when absent/malformed. Accepts the
+ * legacy `{ version, acceptedAt }` shape byte-for-byte — the pre-headless sheet's
+ * `hasStoredConsent` only checked truthiness, so any record it wrote (always with
+ * both string fields) loads here.
+ */
+export declare function loadConsent(storage: KVStorage, storeId?: string): LegalConsent | null;
+/** Persist the consent record (best-effort). Shape byte-identical to the legacy
+ *  sheet write: `{ version, acceptedAt }`. */
+export declare function saveConsent(storage: KVStorage, storeId: string | undefined, consent: LegalConsent): void;

package/dist/consent.js

@@ -0,0 +1,34 @@
+export function consentStorageKey(storeId) {
+    return `tryon-legal-consent:${storeId ?? "default"}`;
+}
+export function loadConsent(storage, storeId) {
+    let raw;
+    try {
+        raw = storage.getItem(consentStorageKey(storeId));
+    }
+    catch {
+        return null;
+    }
+    if (!raw)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const rec = parsed;
+    if (typeof rec.version !== "string" || typeof rec.acceptedAt !== "string")
+        return null;
+    return { version: rec.version, acceptedAt: rec.acceptedAt };
+}
+export function saveConsent(storage, storeId, consent) {
+    try {
+        storage.setItem(consentStorageKey(storeId), JSON.stringify(consent));
+    }
+    catch {
+    }
+}

package/dist/create-client.d.ts

@@ -0,0 +1,84 @@
+/**
+ * One-call composition root for an integrator holding a publishable key.
+ *
+ * `new TryOnClient(...)` requires a Transport and a KVStorage, which is right for
+ * the storefront plugins (they have an app proxy and their own storage) but is
+ * two adapters of busywork for everyone else. This wires the defaults shipped
+ * with the core — fetch transport, device storage, auto-minted anonymous id,
+ * and the core Tracker over host-free ports — while leaving every port
+ * individually overridable for React Native, tests, or a self-hosted API.
+ */
+import { TryOnClient } from "./client";
+import type { TryOnClientConfig } from "./client";
+import type { ConsentSource, IntegrationName, KVStorage, NetworkInfo, Transport } from "./ports";
+import type { TrackSink } from "./analytics";
+import type { FetchLike } from "./fetch-transport";
+import type { ScreenSize, TrackingConsentMode } from "./default-tracking";
+export interface CreateTryOnClientOptions extends TryOnClientConfig {
+    /** Publishable key (`pk_…`) issued for the store. Required unless a
+     *  ready-made `transport` is supplied. */
+    publishableKey?: string;
+    /** API origin. Defaults to the Genlook production API. */
+    baseUrl?: string;
+    /** Path the public endpoints are mounted under. Defaults to the store API. */
+    apiPath?: string;
+    /** Known shopper id → `x-genlook-customer-id`. Defaults to
+     *  `loggedInCustomerId` when that is set. */
+    customerId?: string | null;
+    /** Known shopper email → `x-genlook-customer-email`. */
+    customerEmail?: string | null;
+    /** Client build id → `x-genlook-widget-version`. */
+    widgetVersion?: string;
+    /** Device fingerprint source; read only on the requests that opt in. */
+    getFingerprint?: () => string | null | undefined;
+    /** Override the host `fetch` (tests, custom agents). */
+    fetchImpl?: FetchLike;
+    /** Full transport override. Skips the fetch transport entirely (app-proxy
+     *  hosts, mocks). */
+    transport?: Transport;
+    /** Storage override. REQUIRED on React Native — pass the resolved
+     *  `createHydratedStorage(AsyncStorage)`. Defaults to localStorage, falling
+     *  back to in-memory. */
+    storage?: KVStorage;
+    /** Pin the anonymous id instead of reading/minting it from storage. */
+    anonymousId?: string;
+    /** Full tracker override. When set it wins outright and NO default tracker,
+     *  ports or flush timer are built — the storefront widget keeps its own. */
+    tracker?: TrackSink;
+    now?: () => number;
+    netInfo?: () => NetworkInfo;
+    /**
+     * Consent posture of the default tracker. `"granted"` (the default) sends the
+     * funnel events; `"denied"` cuts the channel entirely — nothing is captured,
+     * nothing is sent, and the widget-scope escape hatch stays shut. Pass a live
+     * {@link ConsentSource} instead when the host has a real CMP to read.
+     */
+    tracking?: TrackingConsentMode | ConsentSource;
+    /** Which surface the tracking batches name themselves as. Defaults to
+     *  "tryon_core". */
+    integration?: IntegrationName | null;
+    /** Version reported alongside {@link integration}. Defaults to this
+     *  package's semver. */
+    integrationVersion?: string | null;
+    /** Screen size for the tracking context, when the host knows one. */
+    screen?: ScreenSize | (() => ScreenSize | null | undefined);
+    /** Periodic flush cadence (ms). Defaults to the core's own interval (5s). */
+    flushIntervalMs?: number;
+}
+/**
+ * Build a ready-to-use {@link TryOnClient}.
+ *
+ * ```ts
+ * const client = createTryOnClient({ publishableKey: "pk_live_…", storeId });
+ * ```
+ *
+ * React Native — hydrate storage first, since {@link KVStorage} is synchronous:
+ * ```ts
+ * const storage = await createHydratedStorage(AsyncStorage);
+ * const client = createTryOnClient({ publishableKey, storeId, storage });
+ * ```
+ *
+ * Funnel events are tracked by default; pass `tracking: "denied"` to send none.
+ * Call `client.dispose()` when the client goes away — it stops the flush timer.
+ */
+export declare function createTryOnClient(options: CreateTryOnClientOptions): TryOnClient;