flowgrid-sdk 1.4.1 → 1.4.2

package/dist/lib/flowgrid.js

@@ -36,6 +36,75 @@ import { PageViews, Sessions, Events, Identify, Funnels, Retention, Attribution,
 import { Products, CartTracking, Checkout, Purchases, Refunds, Promotions, WishlistTracking, CustomerLTV, SearchAnalytics, Subscriptions, } from "./features/ecommerce";
 import { Engagement, Cohorts, ChurnAnalytics, Monetization, MultiPathFunnels, SupportAnalytics, AcquisitionAnalytics, PathAnalytics, AlertsAnalytics, SecurityAnalytics, Forecasting, } from "./features/enterprise";
 import { ActivationTracker, ExperimentTracker, FeatureTracker, PromptTracker, EventTracker, PageViewTracker, SessionTracker, IdentifyTracker, FunnelTracker, RetentionTracker, AttributionTracker, HeatmapTracker, PerformanceTracker, ReplayTracker, ProductTracker, CartTracker, CheckoutTracker, PurchaseTracker, RefundTracker, PromotionTracker, WishlistTracker, SubscriptionTracker, LTVTracker, SearchTracker, EngagementTracker, CohortTracker, ChurnTracker, MonetizationTracker, MultiPathFunnelTracker, SupportTracker, AcquisitionTracker, PathTracker, AlertTracker, SecurityTracker, ForecastingTracker, } from "./tracking";
+const UNHANDLED_TRACK = { handled: false };
+const PRODUCT_KEYS = [
+    "productId",
+    "name",
+    "brand",
+    "category",
+    "variant",
+    "price",
+    "currency",
+    "quantity",
+    "discount",
+    "coupon",
+    "position",
+    "url",
+    "imageUrl",
+    "rating",
+    "reviewCount",
+    "stockStatus",
+    "attributes",
+];
+function handled(value) {
+    return { handled: true, value };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(props, key) {
+    const value = props[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function numberValue(props, key) {
+    const value = props[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function booleanValue(props, key) {
+    const value = props[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+function recordValue(props, key) {
+    const value = props[key];
+    return isRecord(value) ? value : undefined;
+}
+function hasValue(props, key) {
+    const value = props[key];
+    return value !== undefined && value !== null && !(typeof value === "string" && value.length === 0);
+}
+function omitProperties(props, keys) {
+    const next = {};
+    const blocked = new Set([...keys, "domain"]);
+    for (const [key, value] of Object.entries(props)) {
+        if (!blocked.has(key))
+            next[key] = value;
+    }
+    return next;
+}
+function productFrom(props) {
+    const nested = recordValue(props, "product");
+    if (nested)
+        return { ...nested, currency: nested.currency ?? "USD" };
+    if (!hasValue(props, "productId") || !hasValue(props, "name") || !hasValue(props, "price")) {
+        return undefined;
+    }
+    const product = { currency: "USD" };
+    for (const key of PRODUCT_KEYS) {
+        if (props[key] !== undefined)
+            product[key] = props[key];
+    }
+    return product;
+}
 const DEFAULT_ENDPOINT = "https://core.flow-grid.xyz";
 /**
  * Unified FlowGrid SDK client. Instantiate once, use everywhere.
@@ -185,20 +254,594 @@ export class FlowGrid {
     get alerts() { return this.wrap("alerts", AlertsAnalytics, AlertTracker); }
     get security() { return this.wrap("security", SecurityAnalytics, SecurityTracker); }
     get forecasting() { return this.wrap("forecasting", Forecasting, ForecastingTracker); }
-    // ==========================================================================
-    // TOP-LEVEL SHORTCUTS — the 80% case
-    // ==========================================================================
-    /**
-     * Track a custom event.
-     *
-     * @example
-     * ```ts
-     * fg.track("signup_completed", { plan: "pro" });
-     * ```
-     */
-    track(eventName, properties, options) {
+    track(eventName, properties = {}, options = {}) {
+        const contextualProperties = this.withTrackContext(properties, options);
+        const routed = this.dispatchTrack(eventName, contextualProperties, Boolean(options.domain), options.domain);
+        if (routed.handled)
+            return routed.value;
         return this.events.track(eventName, properties, options);
     }
+    withTrackContext(properties, options) {
+        return {
+            ...properties,
+            ...(options.userId !== undefined && properties.userId === undefined ? { userId: options.userId } : {}),
+            ...(options.sessionId !== undefined && properties.sessionId === undefined ? { sessionId: options.sessionId } : {}),
+        };
+    }
+    requireTrackProperties(eventName, properties, keys, strict) {
+        const missing = keys.filter(key => !hasValue(properties, key));
+        if (missing.length === 0)
+            return true;
+        if (strict) {
+            throw new Error(`FlowGrid.track("${eventName}") missing required properties: ${missing.join(", ")}`);
+        }
+        return false;
+    }
+    dispatchTrack(eventName, properties, strict, domain) {
+        const dispatchers = [];
+        if (!domain || domain === "activation")
+            dispatchers.push(() => this.dispatchActivationTrack(eventName, properties, strict));
+        if (!domain || domain === "feature")
+            dispatchers.push(() => this.dispatchFeatureTrack(eventName, properties, strict));
+        if (!domain || domain === "prompt")
+            dispatchers.push(() => this.dispatchPromptTrack(eventName, properties, strict));
+        if (!domain || domain === "experiment")
+            dispatchers.push(() => this.dispatchExperimentTrack(eventName, properties, strict));
+        if (!domain || domain === "analytics" || domain === "funnel" || domain === "retention" || domain === "attribution") {
+            dispatchers.push(() => this.dispatchAnalyticsTrack(eventName, properties, strict, domain));
+        }
+        if (!domain || domain === "ecommerce")
+            dispatchers.push(() => this.dispatchEcommerceTrack(eventName, properties, strict));
+        if (!domain ||
+            domain === "engagement" ||
+            domain === "churn" ||
+            domain === "monetization" ||
+            domain === "support" ||
+            domain === "acquisition" ||
+            domain === "paths" ||
+            domain === "security" ||
+            domain === "multiPathFunnels") {
+            dispatchers.push(() => this.dispatchEnterpriseTrack(eventName, properties, strict, domain));
+        }
+        for (const dispatch of dispatchers) {
+            const result = dispatch();
+            if (result.handled)
+                return result;
+        }
+        return UNHANDLED_TRACK;
+    }
+    dispatchActivationTrack(eventName, properties, strict) {
+        switch (eventName) {
+            case "signup_completed": {
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "method"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.activation.signup(stringValue(properties, "userId"), stringValue(properties, "method"), stringValue(properties, "source"), omitProperties(properties, ["userId", "method", "source"])));
+            }
+            case "onboarding_step": {
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "stepId", "stepName", "stepOrder", "totalSteps"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.activation.onboardingStep(stringValue(properties, "userId"), stringValue(properties, "stepId"), stringValue(properties, "stepName"), numberValue(properties, "stepOrder"), numberValue(properties, "totalSteps"), {
+                    skipped: booleanValue(properties, "skipped"),
+                    timeSpent: numberValue(properties, "timeSpent"),
+                    properties: omitProperties(properties, ["userId", "stepId", "stepName", "stepOrder", "totalSteps", "skipped", "timeSpent"]),
+                }));
+            }
+            case "onboarding_completed": {
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "totalTimeSpent", "stepsCompleted"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.activation.onboardingComplete(stringValue(properties, "userId"), numberValue(properties, "totalTimeSpent"), numberValue(properties, "stepsCompleted"), numberValue(properties, "stepsSkipped") ?? 0));
+            }
+            case "first_action": {
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "actionName", "timeSinceSignup"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.activation.firstAction(stringValue(properties, "userId"), stringValue(properties, "actionName"), numberValue(properties, "timeSinceSignup"), omitProperties(properties, ["userId", "actionName", "timeSinceSignup"])));
+            }
+            default:
+                if (strict)
+                    return handled(this.activation.event(eventName, properties));
+                return UNHANDLED_TRACK;
+        }
+    }
+    dispatchFeatureTrack(eventName, properties, strict) {
+        const actions = {
+            feature_viewed: "viewed",
+            feature_used: "used",
+            feature_completed: "completed",
+            feature_abandoned: "abandoned",
+        };
+        const action = actions[eventName] ?? (eventName === "feature_usage"
+            ? properties.action : undefined);
+        if (eventName === "feature_usage" || action) {
+            if (!this.requireTrackProperties(eventName, properties, ["featureId", "featureName"], strict))
+                return UNHANDLED_TRACK;
+            return handled(this.features.client.trackUsage({
+                ...properties,
+                action: typeof action === "string" ? action : "used",
+            }));
+        }
+        if (strict) {
+            if (!this.requireTrackProperties(eventName, properties, ["userId", "featureName"], true))
+                return UNHANDLED_TRACK;
+            return handled(this.features.create(stringValue(properties, "userId"), eventName, stringValue(properties, "featureName"), omitProperties(properties, ["userId", "featureName"])));
+        }
+        return UNHANDLED_TRACK;
+    }
+    dispatchPromptTrack(eventName, properties, strict) {
+        switch (eventName) {
+            case "prompt_submitted":
+                if (!this.requireTrackProperties(eventName, properties, ["promptId", "promptType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.prompts.client.trackSubmission(properties));
+            case "prompt_response":
+                if (!this.requireTrackProperties(eventName, properties, ["promptId", "responseTime", "completed"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.prompts.client.trackResponse(properties));
+            case "prompt_feedback":
+                if (!this.requireTrackProperties(eventName, properties, ["promptId", "feedbackType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.prompts.client.trackFeedback(properties));
+            case "prompt_conversation":
+                if (!this.requireTrackProperties(eventName, properties, ["conversationId", "userId", "turnCount", "totalDuration"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.prompts.conversation(stringValue(properties, "conversationId"), stringValue(properties, "userId"), numberValue(properties, "turnCount"), numberValue(properties, "totalDuration")));
+            default:
+                if (strict || eventName.startsWith("prompt_"))
+                    return handled(this.prompts.event(eventName, properties));
+                return UNHANDLED_TRACK;
+        }
+    }
+    dispatchExperimentTrack(eventName, properties, strict) {
+        switch (eventName) {
+            case "experiment_assignment":
+                if (!this.requireTrackProperties(eventName, properties, ["experimentId", "userId", "variantId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.experiments.client.assign(properties));
+            case "experiment_exposure":
+                if (!this.requireTrackProperties(eventName, properties, ["experimentId", "userId", "variantId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.experiments.exposure(stringValue(properties, "experimentId"), stringValue(properties, "userId"), stringValue(properties, "variantId")));
+            case "experiment_conversion":
+                if (!this.requireTrackProperties(eventName, properties, ["experimentId", "userId", "variantId", "metricName"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.experiments.client.trackConversion({
+                    ...properties,
+                    value: numberValue(properties, "value") ?? 1,
+                }));
+            default:
+                if (strict || eventName.startsWith("experiment_")) {
+                    if (!this.requireTrackProperties(eventName, properties, ["variant"], strict))
+                        return UNHANDLED_TRACK;
+                    return handled(this.experiments.client.track({
+                        eventName,
+                        variant: stringValue(properties, "variant"),
+                        properties: omitProperties(properties, ["variant"]),
+                    }));
+                }
+                return UNHANDLED_TRACK;
+        }
+    }
+    dispatchAnalyticsTrack(eventName, properties, strict, domain) {
+        switch (eventName) {
+            case "click_event":
+                if (!this.requireTrackProperties(eventName, properties, ["elementId", "elementText"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.events.client.trackClick(properties));
+            case "form_event":
+                if (!this.requireTrackProperties(eventName, properties, ["formId", "formName"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.events.client.trackForm(properties));
+            case "search_event":
+                if (!this.requireTrackProperties(eventName, properties, ["query", "category"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.events.client.trackSearch(properties));
+            case "error_event":
+                if (!this.requireTrackProperties(eventName, properties, ["message", "type"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.events.client.trackError(properties));
+            case "funnel_step":
+                if (!this.requireTrackProperties(eventName, properties, ["funnelId", "step", "stepNumber"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.funnels.client.trackStep(properties));
+            case "funnel_complete":
+                if (!this.requireTrackProperties(eventName, properties, ["funnelId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.funnels.complete(stringValue(properties, "funnelId"), stringValue(properties, "userId"), omitProperties(properties, ["funnelId", "userId"])));
+            case "funnel_abandon":
+                if (!this.requireTrackProperties(eventName, properties, ["funnelId", "lastStep"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.funnels.abandon(stringValue(properties, "funnelId"), stringValue(properties, "lastStep"), stringValue(properties, "userId"), stringValue(properties, "reason")));
+            case "user_activity":
+                if (domain && domain !== "retention")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.retention.client.trackActivity(properties));
+            case "attribution_touchpoint":
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "channel"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.attribution.client.trackTouchpoint(properties));
+            case "attribution_conversion":
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "conversionType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.attribution.client.recordConversion(properties));
+            default:
+                return UNHANDLED_TRACK;
+        }
+    }
+    dispatchEcommerceTrack(eventName, properties, strict) {
+        switch (eventName) {
+            case "product_view": {
+                const product = productFrom(properties);
+                if (!product) {
+                    if (strict)
+                        throw new Error(`FlowGrid.track("${eventName}") missing required properties: product or productId, name, price`);
+                    return UNHANDLED_TRACK;
+                }
+                return handled(this.products.client.view({
+                    ...product,
+                    ...omitProperties(properties, ["product", ...PRODUCT_KEYS]),
+                }));
+            }
+            case "product_impression":
+                if (!this.requireTrackProperties(eventName, properties, ["list"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.products.client.impression(properties));
+            case "product_click": {
+                const product = productFrom(properties);
+                if (!product || !this.requireTrackProperties(eventName, properties, ["listId", "position"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.products.client.click({
+                    ...properties,
+                    product,
+                }));
+            }
+            case "add_to_cart":
+            case "remove_from_cart": {
+                const product = productFrom(properties);
+                if (!product) {
+                    if (strict)
+                        throw new Error(`FlowGrid.track("${eventName}") missing required properties: product or productId, name, price`);
+                    return UNHANDLED_TRACK;
+                }
+                const config = {
+                    ...omitProperties(properties, ["product", ...PRODUCT_KEYS]),
+                    product,
+                    quantity: numberValue(properties, "quantity") ?? 1,
+                };
+                return handled(eventName === "add_to_cart"
+                    ? this.cart.client.addItem(config)
+                    : this.cart.client.removeItem(config));
+            }
+            case "update_cart_item": {
+                const product = productFrom(properties);
+                if (!product || !this.requireTrackProperties(eventName, properties, ["previousQuantity", "newQuantity"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.cart.client.updateItem({
+                    ...omitProperties(properties, ["product", ...PRODUCT_KEYS]),
+                    product,
+                }));
+            }
+            case "view_cart":
+                if (!this.requireTrackProperties(eventName, properties, ["cart"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.cart.client.view(properties));
+            case "begin_checkout":
+                if (!this.requireTrackProperties(eventName, properties, ["cart"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.checkout.client.begin(properties));
+            case "checkout_step":
+                if (!this.requireTrackProperties(eventName, properties, ["step", "stepNumber", "cart"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.checkout.client.step(properties));
+            case "add_shipping_info":
+                if (!this.requireTrackProperties(eventName, properties, ["cart", "shipping"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.checkout.client.addShipping(properties));
+            case "add_payment_info":
+                if (!this.requireTrackProperties(eventName, properties, ["cart", "payment"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.checkout.client.addPayment(properties));
+            case "purchase":
+                if (!this.requireTrackProperties(eventName, properties, ["order"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.purchases.client.track(properties));
+            case "refund":
+                if (!this.requireTrackProperties(eventName, properties, ["orderId", "refundId", "amount", "currency"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.refunds.client.track(properties));
+            case "refund_requested":
+                if (!this.requireTrackProperties(eventName, properties, ["orderId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.refunds.client.request(stringValue(properties, "orderId"), properties.items, stringValue(properties, "reason")));
+            case "refund_approved":
+                if (!this.requireTrackProperties(eventName, properties, ["refundId", "approvedAmount"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.refunds.client.approve(stringValue(properties, "refundId"), numberValue(properties, "approvedAmount")));
+            case "refund_denied":
+                if (!this.requireTrackProperties(eventName, properties, ["refundId", "reason"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.refunds.client.deny(stringValue(properties, "refundId"), stringValue(properties, "reason")));
+            case "refund_completed":
+                if (!this.requireTrackProperties(eventName, properties, ["refundId", "processedAmount"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.refunds.client.complete(stringValue(properties, "refundId"), numberValue(properties, "processedAmount")));
+            case "promotion_view":
+                if (!this.requireTrackProperties(eventName, properties, ["promotionId", "name", "creative", "position"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.promotions.client.view(properties));
+            case "promotion_click":
+                if (!this.requireTrackProperties(eventName, properties, ["promotionId", "name", "creative", "position"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.promotions.client.click(properties));
+            case "coupon_used":
+                if (!this.requireTrackProperties(eventName, properties, ["code", "orderId", "discountValue", "discountType", "orderValueBefore", "orderValueAfter"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.promotions.client.couponUsed(properties));
+            case "add_to_wishlist":
+            case "remove_from_wishlist": {
+                const product = productFrom(properties);
+                if (!product) {
+                    if (strict)
+                        throw new Error(`FlowGrid.track("${eventName}") missing required properties: product or productId, name, price`);
+                    return UNHANDLED_TRACK;
+                }
+                const config = { ...omitProperties(properties, ["product", ...PRODUCT_KEYS]), product };
+                return handled(eventName === "add_to_wishlist"
+                    ? this.wishlist.client.add(config)
+                    : this.wishlist.client.remove(config));
+            }
+            case "view_wishlist":
+                if (!this.requireTrackProperties(eventName, properties, ["wishlist"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.wishlist.client.view(recordValue(properties, "wishlist")));
+            case "wishlist_to_cart": {
+                const product = productFrom(properties);
+                if (!product) {
+                    if (strict)
+                        throw new Error(`FlowGrid.track("${eventName}") missing required properties: product or productId, name, price`);
+                    return UNHANDLED_TRACK;
+                }
+                return handled(this.wishlist.client.moveToCart(product, stringValue(properties, "wishlistId")));
+            }
+            case "share_wishlist":
+                if (!this.requireTrackProperties(eventName, properties, ["wishlistId", "method"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.wishlist.client.share(stringValue(properties, "wishlistId"), stringValue(properties, "method")));
+            case "subscription_start":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId", "plan", "mrr", "billingCycle"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.start(properties));
+            case "subscription_change":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId", "previousPlan", "newPlan", "previousMrr", "newMrr", "changeType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.change(properties));
+            case "subscription_cancel":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId", "plan", "lostMrr"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.cancel(properties));
+            case "subscription_renew":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId", "mrr"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.renew(stringValue(properties, "subscriptionId"), stringValue(properties, "userId"), recordValue(properties, "mrr")));
+            case "trial_converted":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId", "plan", "mrr"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.trialConverted(stringValue(properties, "subscriptionId"), stringValue(properties, "userId"), stringValue(properties, "plan"), recordValue(properties, "mrr")));
+            case "trial_expired":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.trialExpired(stringValue(properties, "subscriptionId"), stringValue(properties, "userId")));
+            case "record_acquisition_cost":
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "cost", "channel"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.ltv.client.recordAcquisitionCost(properties));
+            case "update_customer_segment":
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "newSegment"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.ltv.client.updateSegment(stringValue(properties, "userId"), stringValue(properties, "newSegment")));
+            case "site_search":
+                if (!this.requireTrackProperties(eventName, properties, ["query", "resultsCount"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.search.client.track(properties));
+            case "search_result_click": {
+                const product = productFrom(properties);
+                if (!product || !this.requireTrackProperties(eventName, properties, ["query", "position"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.search.client.trackClick({ ...properties, product }));
+            }
+            case "search_refinement":
+                if (!this.requireTrackProperties(eventName, properties, ["originalQuery", "refinedQuery", "refinementType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.search.client.trackRefinement(stringValue(properties, "originalQuery"), stringValue(properties, "refinedQuery"), stringValue(properties, "refinementType")));
+            case "search_suggestion":
+                if (!this.requireTrackProperties(eventName, properties, ["partialQuery", "selectedSuggestion", "suggestionPosition"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.search.client.trackSuggestion(stringValue(properties, "partialQuery"), stringValue(properties, "selectedSuggestion"), numberValue(properties, "suggestionPosition")));
+            default:
+                return UNHANDLED_TRACK;
+        }
+    }
+    dispatchEnterpriseTrack(eventName, properties, strict, domain) {
+        switch (eventName) {
+            case "engagement.dwell_time":
+            case "engagement_dwell_time":
+                if (domain && domain !== "engagement")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["featureId", "dwellTimeMs"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.engagement.client.trackDwellTime(properties));
+            case "engagement.session_depth":
+            case "engagement_session_depth":
+                if (domain && domain !== "engagement")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["sessionId", "pagesVisited", "featuresUsed", "actionsTaken", "durationMs"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.engagement.client.trackSessionDepth(properties));
+            case "engagement.content_consumption":
+            case "engagement_content_consumption":
+                if (domain && domain !== "engagement")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["contentId", "contentType", "percentageConsumed", "timeSpentMs"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.engagement.client.trackContentConsumption(properties));
+            case "engagement.user_activity":
+            case "engagement_user_activity":
+                if (domain && domain !== "engagement")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "activityType", "durationMs"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.engagement.client.trackUserActivity(properties));
+            case "churn.usage_decay":
+            case "churn_usage_decay":
+                if (domain && domain !== "churn")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "metric", "periods"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.churn.client.trackUsageDecay(properties));
+            case "churn.nps":
+            case "churn_nps":
+                if (domain && domain !== "churn")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "score"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.churn.client.trackNPS(properties));
+            case "churn.churn_event":
+            case "churn_churn_event":
+                if (domain && domain !== "churn")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "churnType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.churn.client.trackChurn(properties));
+            case "churn.prevention_action":
+            case "churn_prevention_action":
+                if (domain && domain !== "churn")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "actionType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.churn.client.trackPreventionAction(properties));
+            case "monetization.revenue":
+            case "monetization_revenue":
+                if (domain && domain !== "monetization")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "amount", "currency", "type"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.monetization.client.trackRevenue(properties));
+            case "support.ticket_created":
+            case "support_ticket_created":
+                if (domain && domain !== "support")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["ticketId", "userId", "subject", "category", "priority", "channel"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.support.client.trackTicket(properties));
+            case "support.ticket_updated":
+            case "support_ticket_updated":
+                if (domain && domain !== "support")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["ticketId", "status"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.support.client.updateTicket(properties));
+            case "support.csat":
+            case "support_csat":
+                if (domain && domain !== "support")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["ticketId", "userId", "score"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.support.client.trackCSAT(properties));
+            case "support.feature_complaint":
+            case "support_feature_complaint":
+                if (domain && domain !== "support")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "featureId", "complaintType", "severity"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.support.client.trackFeatureComplaint(properties));
+            case "acquisition.acquired":
+            case "acquisition_acquired":
+                if (domain && domain !== "acquisition")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "source"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.acquisition.client.trackAcquisition(properties));
+            case "acquisition.lifecycle_transition":
+            case "acquisition_lifecycle_transition":
+                if (domain && domain !== "acquisition")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "fromStage", "toStage"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.acquisition.client.trackLifecycleTransition(properties));
+            case "acquisition.campaign_spend":
+            case "acquisition_campaign_spend":
+                if (domain && domain !== "acquisition")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["campaignId", "amount", "date"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.acquisition.client.trackCampaignSpend(properties));
+            case "paths.transition":
+            case "paths_transition":
+                if (domain && domain !== "paths")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "fromScreen", "toScreen"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.paths.client.trackTransition(properties));
+            case "paths.feature_sequence":
+            case "paths_feature_sequence":
+                if (domain && domain !== "paths")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "feature", "order"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.paths.client.trackFeatureSequence(properties));
+            case "security.login_attempt":
+            case "security_login_attempt":
+                if (domain && domain !== "security")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "success"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.security.client.trackLoginAttempt(properties));
+            case "security.role_change":
+            case "security_role_change":
+                if (domain && domain !== "security")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "changedBy", "previousRole", "newRole"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.security.client.trackRoleChange(properties));
+            case "security.permission_change":
+            case "security_permission_change":
+                if (domain && domain !== "security")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "changedBy", "permission", "action"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.security.client.trackPermissionChange(properties));
+            case "security.data_access":
+            case "security_data_access":
+                if (domain && domain !== "security")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "resourceType", "accessType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.security.client.trackDataAccess(properties));
+            case "security.compliance_event":
+            case "security_compliance_event":
+                if (domain && domain !== "security")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "eventType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.security.client.trackComplianceEvent(properties));
+            case "multi_path_funnels.track_step":
+            case "multi_path_funnels_track_step":
+                if (domain && domain !== "multiPathFunnels")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["funnelId", "step", "userId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.multiPathFunnels.client.trackStep(properties));
+            case "multi_path_funnels.track_micro_conversion":
+            case "multi_path_funnels_track_micro_conversion":
+                if (domain && domain !== "multiPathFunnels")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["conversionId", "userId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.multiPathFunnels.client.trackMicroConversion(properties));
+            default:
+                return UNHANDLED_TRACK;
+        }
+    }
     /**
      * Record an experiment exposure for a user.
      *