avo-inspector 2.2.0 → 2.2.2-alpha.2

package/dist-browser/eventSpec/EventValidator.d.ts

@@ -0,0 +1,90 @@
+/**
+ * EventValidator - Client-side validation of tracking events against the Avo Tracking Plan.
+ *
+ * This module handles:
+ * 1. Matching: Identifying the most likely Event and Variant from specs
+ * 2. Validation: Checking runtime properties against the matched spec rules
+ */
+import type { EventSpecResponse, EventSpec, EventSpecMetadata, VariantSpec } from "./AvoEventSpecFetchTypes";
+/**
+ * Validation issue codes for client-side validation.
+ */
+export type ValidationIssueCode = "RequiredMissing" | "ValueBelowMin" | "ValueAboveMax" | "RegexMismatch" | "NotInAllowedValues" | "UnexpectedProperty" | "UnexpectedEvent" | "TypeMismatch";
+/**
+ * Represents a validation issue found during event validation.
+ *
+ * Note: We do NOT include the received value to avoid sending user data to the backend.
+ * The backend can correlate issues with encrypted values via propertyName matching
+ * against eventProperties.encryptedPropertyValue in the payload.
+ */
+export interface ValidationIssue {
+    /** The type of validation issue */
+    code: ValidationIssueCode;
+    /** Property ID (preferred over name) */
+    propertyId?: string;
+    /** Property name - used to correlate with encryptedPropertyValue in eventProperties */
+    propertyName?: string;
+    /** Expected value for the validation rule (from spec, not user data) */
+    expected?: string | number | boolean;
+}
+/**
+ * Result of the validation process.
+ */
+export interface ValidationResult {
+    /** ID of the matched event, null if no match found */
+    eventId: string | null;
+    /** ID of the matched variant, null if base event or no match */
+    variantId: string | null;
+    /** Event spec metadata from the response */
+    eventSpecMetadata: EventSpecMetadata;
+    /** List of all validation issues found */
+    validationErrors: ValidationIssue[];
+}
+/**
+ * Runtime property value - can be any JSON-compatible type
+ */
+export type RuntimePropertyValue = string | number | boolean | null | undefined | object | Array<any>;
+/**
+ * Runtime properties map
+ */
+export type RuntimeProperties = Record<string, RuntimePropertyValue>;
+/**
+ * Internal match result for scoring
+ */
+interface MatchCandidate {
+    event: EventSpec;
+    variant: VariantSpec | null;
+    score: number;
+}
+/**
+ * Validates a runtime event against the EventSpecResponse.
+ *
+ * @param eventName - The event name observed at runtime
+ * @param properties - The properties observed at runtime
+ * @param specResponse - The EventSpecResponse from the backend
+ * @returns ValidationResult with match info and any validation errors
+ */
+export declare function validateEvent(eventName: string, properties: RuntimeProperties, specResponse: EventSpecResponse): ValidationResult;
+/**
+ * Finds the closest matching Event and Variant for the runtime data.
+ *
+ * @param eventName - Runtime event name
+ * @param properties - Runtime properties
+ * @param events - Array of EventSpecs to match against
+ * @returns The best matching event and variant, or null if no match
+ */
+export declare function findClosestMatch(eventName: string, properties: RuntimeProperties, events: EventSpec[]): MatchCandidate | null;
+/**
+ * Validates runtime properties against the matched event and variant specs.
+ *
+ * @param properties - Runtime properties
+ * @param event - Matched EventSpec
+ * @param variant - Matched VariantSpec (or null for base event)
+ * @returns Array of validation issues found
+ */
+export declare function validateProperties(properties: RuntimeProperties, event: EventSpec, variant: VariantSpec | null): ValidationIssue[];
+/**
+ * Quick check if an event exists in the spec (without full validation).
+ */
+export declare function eventExistsInSpec(eventName: string, specResponse: EventSpecResponse): boolean;
+export {};

package/dist-browser/eventSpec/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./AvoEventSpecFetchTypes";
+export * from "./AvoEventSpecCache";
+export * from "./AvoEventSpecFetcher";
+export * from "./EventValidator";

package/dist-browser/index.d.ts

@@ -0,0 +1,2 @@
+export { AvoInspector } from "./AvoInspector";
+export { AvoInspectorEnv, type AvoInspectorEnvType, type AvoInspectorEnvValueType } from "./AvoInspectorEnv";

package/dist-browser/utils.d.ts

@@ -0,0 +1,3 @@
+declare const isValueEmpty: (value: string | null | undefined) => boolean;
+declare function deepEquals(x: any, y: any): boolean;
+export { isValueEmpty, deepEquals };

package/dist-native/AvoBatcher.d.ts

@@ -0,0 +1,24 @@
+import { AvoNetworkCallsHandler } from "./AvoNetworkCallsHandler";
+export interface AvoBatcherType {
+    handleSessionStarted(): void;
+    handleTrackSchema(eventName: string, schema: Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>, eventId: string | null, eventHash: string | null): void;
+}
+export declare class AvoBatcher implements AvoBatcherType {
+    private events;
+    private batchFlushAttemptTimestamp;
+    private networkCallsHandler;
+    constructor(networkCallsHandler: AvoNetworkCallsHandler);
+    handleSessionStarted(): void;
+    handleTrackSchema(eventName: string, schema: Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>, eventId: string | null, eventHash: string | null): void;
+    private checkIfBatchNeedsToBeSent;
+    private saveEvents;
+    static get cacheKey(): string;
+}

package/dist-native/AvoBatcher.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoBatcher = void 0;
+var AvoInspector_1 = require("./AvoInspector");
+var AvoBatcher = /** @class */ (function () {
+    function AvoBatcher(networkCallsHandler) {
+        var _this = this;
+        this.events = [];
+        this.networkCallsHandler = networkCallsHandler;
+        this.batchFlushAttemptTimestamp = Date.now();
+        AvoInspector_1.AvoInspector.avoStorage
+            .getItemAsync(AvoBatcher.cacheKey)
+            .then(function (savedEvents) {
+            if (savedEvents !== null) {
+                var nonNullSavedEvents = savedEvents.filter(function (event) { return event !== null; });
+                _this.events = _this.events.concat(nonNullSavedEvents);
+                _this.checkIfBatchNeedsToBeSent();
+            }
+        });
+    }
+    AvoBatcher.prototype.handleSessionStarted = function () {
+        this.events.push(this.networkCallsHandler.bodyForSessionStartedCall());
+        this.saveEvents();
+        this.checkIfBatchNeedsToBeSent();
+    };
+    AvoBatcher.prototype.handleTrackSchema = function (eventName, schema, eventId, eventHash) {
+        this.events.push(this.networkCallsHandler.bodyForEventSchemaCall(eventName, schema, eventId, eventHash));
+        this.saveEvents();
+        if (AvoInspector_1.AvoInspector.shouldLog) {
+            console.log("Avo Inspector: saved event " +
+                eventName +
+                " with schema " +
+                JSON.stringify(schema));
+        }
+        this.checkIfBatchNeedsToBeSent();
+    };
+    AvoBatcher.prototype.checkIfBatchNeedsToBeSent = function () {
+        var batchSize = this.events.length;
+        var now = Date.now();
+        var timeSinceLastFlushAttempt = now - this.batchFlushAttemptTimestamp;
+        var sendBySize = batchSize % AvoInspector_1.AvoInspector.batchSize == 0;
+        var sendByTime = timeSinceLastFlushAttempt >= AvoInspector_1.AvoInspector.batchFlushSeconds * 1000;
+        var avoBatcher = this;
+        if (sendBySize || sendByTime) {
+            this.batchFlushAttemptTimestamp = now;
+            var sendingEvents_1 = avoBatcher.events;
+            avoBatcher.events = [];
+            this.networkCallsHandler.callInspectorWithBatchBody(sendingEvents_1, function (error) {
+                if (error != null) {
+                    avoBatcher.events = avoBatcher.events.concat(sendingEvents_1);
+                    if (AvoInspector_1.AvoInspector.shouldLog) {
+                        console.log("Avo Inspector: batch sending failed: " +
+                            error +
+                            ". We will attempt to send your schemas with next batch");
+                    }
+                }
+                else {
+                    if (AvoInspector_1.AvoInspector.shouldLog) {
+                        console.log("Avo Inspector: batch sent successfully.");
+                    }
+                }
+                avoBatcher.saveEvents();
+            });
+        }
+    };
+    AvoBatcher.prototype.saveEvents = function () {
+        if (this.events.length > 1000) {
+            var extraElements = this.events.length - 1000;
+            this.events.splice(0, extraElements);
+        }
+        AvoInspector_1.AvoInspector.avoStorage.setItem(AvoBatcher.cacheKey, this.events);
+    };
+    Object.defineProperty(AvoBatcher, "cacheKey", {
+        get: function () {
+            return "AvoInspectorEvents";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AvoBatcher;
+}());
+exports.AvoBatcher = AvoBatcher;

package/dist-native/AvoDeduplicator.d.ts

@@ -0,0 +1,36 @@
+export declare class AvoDeduplicator {
+    avoFunctionsEvents: {
+        [time: number]: string;
+    };
+    manualEvents: {
+        [time: number]: string;
+    };
+    avoFunctionsEventsParams: {
+        [eventName: string]: {
+            [propName: string]: any;
+        };
+    };
+    manualEventsParams: {
+        [eventName: string]: {
+            [propName: string]: any;
+        };
+    };
+    shouldRegisterEvent(eventName: string, params: {
+        [propName: string]: any;
+    }, fromAvoFunction: boolean): boolean;
+    private hasSameEventAs;
+    private lookForEventIn;
+    hasSeenEventParams(params: {
+        [propName: string]: any;
+    }, checkInAvoFunctions: boolean): boolean;
+    private lookForEventParamsIn;
+    shouldRegisterSchemaFromManually(eventName: string, eventSchema: Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>): boolean;
+    private hasSameShapeInAvoFunctionsAs;
+    private lookForEventSchemaIn;
+    private clearOldEvents;
+    private _clearEvents;
+}

package/dist-native/AvoDeduplicator.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoDeduplicator = void 0;
+var AvoSchemaParser_1 = require("./AvoSchemaParser");
+var utils_1 = require("./utils");
+var AvoDeduplicator = /** @class */ (function () {
+    function AvoDeduplicator() {
+        this.avoFunctionsEvents = {};
+        this.manualEvents = {};
+        this.avoFunctionsEventsParams = {};
+        this.manualEventsParams = {};
+    }
+    AvoDeduplicator.prototype.shouldRegisterEvent = function (eventName, params, fromAvoFunction) {
+        this.clearOldEvents();
+        if (fromAvoFunction) {
+            this.avoFunctionsEvents[Date.now()] = eventName;
+            this.avoFunctionsEventsParams[eventName] = params;
+        }
+        else {
+            this.manualEvents[Date.now()] = eventName;
+            this.manualEventsParams[eventName] = params;
+        }
+        var checkInAvoFunctions = !fromAvoFunction;
+        return !this.hasSameEventAs(eventName, params, checkInAvoFunctions);
+    };
+    AvoDeduplicator.prototype.hasSameEventAs = function (eventName, params, checkInAvoFunctions) {
+        var result = false;
+        if (checkInAvoFunctions) {
+            if (this.lookForEventIn(eventName, params, this.avoFunctionsEventsParams)) {
+                result = true;
+            }
+        }
+        else {
+            if (this.lookForEventIn(eventName, params, this.manualEventsParams)) {
+                result = true;
+            }
+        }
+        if (result) {
+            delete this.avoFunctionsEventsParams[eventName];
+            delete this.manualEventsParams[eventName];
+        }
+        return result;
+    };
+    AvoDeduplicator.prototype.lookForEventIn = function (eventName, params, eventsStorage) {
+        for (var otherEventName in eventsStorage) {
+            if (eventsStorage.hasOwnProperty(otherEventName)) {
+                if (otherEventName === eventName) {
+                    var otherParams = eventsStorage[eventName];
+                    if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    };
+    AvoDeduplicator.prototype.hasSeenEventParams = function (params, checkInAvoFunctions) {
+        var result = false;
+        if (checkInAvoFunctions) {
+            if (this.lookForEventParamsIn(params, this.avoFunctionsEventsParams)) {
+                result = true;
+            }
+        }
+        else {
+            if (this.lookForEventParamsIn(params, this.manualEventsParams)) {
+                result = true;
+            }
+        }
+        return result;
+    };
+    AvoDeduplicator.prototype.lookForEventParamsIn = function (params, eventsStorage) {
+        for (var otherEventName in eventsStorage) {
+            if (eventsStorage.hasOwnProperty(otherEventName)) {
+                var otherParams = eventsStorage[otherEventName];
+                if (otherParams && (0, utils_1.deepEquals)(params, otherParams)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    AvoDeduplicator.prototype.shouldRegisterSchemaFromManually = function (eventName, eventSchema) {
+        this.clearOldEvents();
+        return !this.hasSameShapeInAvoFunctionsAs(eventName, eventSchema);
+    };
+    AvoDeduplicator.prototype.hasSameShapeInAvoFunctionsAs = function (eventName, eventSchema) {
+        var result = false;
+        if (this.lookForEventSchemaIn(eventName, eventSchema, this.avoFunctionsEventsParams)) {
+            result = true;
+        }
+        if (result) {
+            delete this.avoFunctionsEventsParams[eventName];
+        }
+        return result;
+    };
+    AvoDeduplicator.prototype.lookForEventSchemaIn = function (eventName, eventSchema, eventsStorage) {
+        for (var otherEventName in eventsStorage) {
+            if (eventsStorage.hasOwnProperty(otherEventName)) {
+                if (otherEventName === eventName) {
+                    var otherSchema = AvoSchemaParser_1.AvoSchemaParser.extractSchema(eventsStorage[eventName]);
+                    if (otherSchema && (0, utils_1.deepEquals)(eventSchema, otherSchema)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    };
+    AvoDeduplicator.prototype.clearOldEvents = function () {
+        var now = Date.now();
+        var msToConsiderOld = 300;
+        for (var time in this.avoFunctionsEvents) {
+            if (this.avoFunctionsEvents.hasOwnProperty(time)) {
+                var timestamp = Number(time) || 0;
+                if (now - timestamp > msToConsiderOld) {
+                    var eventName = this.avoFunctionsEvents[time];
+                    delete this.avoFunctionsEvents[time];
+                    delete this.avoFunctionsEventsParams[eventName];
+                }
+            }
+        }
+        for (var time in this.manualEvents) {
+            if (this.manualEvents.hasOwnProperty(time)) {
+                var timestamp = Number(time) || 0;
+                if (now - timestamp > msToConsiderOld) {
+                    var eventName = this.manualEvents[time];
+                    delete this.manualEvents[time];
+                    delete this.manualEventsParams[eventName];
+                }
+            }
+        }
+    };
+    // used in tests
+    AvoDeduplicator.prototype._clearEvents = function () {
+        this.avoFunctionsEvents = {};
+        this.manualEvents = {};
+        this.avoFunctionsEventsParams = {};
+        this.manualEventsParams = {};
+    };
+    return AvoDeduplicator;
+}());
+exports.AvoDeduplicator = AvoDeduplicator;

package/dist-native/AvoGuid.d.ts

@@ -0,0 +1,3 @@
+export default class AvoGuid {
+    static newGuid(): string;
+}

package/dist-native/AvoGuid.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var AvoGuid = /** @class */ (function () {
+    function AvoGuid() {
+    }
+    AvoGuid.newGuid = function () {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+            var r = (Math.random() * 16) | 0, v = c == "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    };
+    return AvoGuid;
+}());
+exports.default = AvoGuid;

package/dist-native/AvoInspector.d.ts

@@ -0,0 +1,52 @@
+import { AvoInspectorEnvValueType } from "./AvoInspectorEnv";
+import { AvoSessionTracker } from "./AvoSessionTracker";
+import { AvoBatcher } from "./AvoBatcher";
+import { AvoStorage } from "./AvoStorage";
+import { AvoDeduplicator } from "./AvoDeduplicator";
+export declare class AvoInspector {
+    environment: AvoInspectorEnvValueType;
+    avoBatcher: AvoBatcher;
+    avoDeduplicator: AvoDeduplicator;
+    sessionTracker: AvoSessionTracker;
+    apiKey: string;
+    version: string;
+    static avoStorage: AvoStorage;
+    private static _batchSize;
+    static get batchSize(): number;
+    static set batchSize(newSize: number);
+    private static _batchFlushSeconds;
+    static get batchFlushSeconds(): number;
+    private static _shouldLog;
+    static get shouldLog(): boolean;
+    static set shouldLog(enable: boolean);
+    constructor(options: {
+        apiKey: string;
+        env: AvoInspectorEnvValueType;
+        version: string;
+        appName?: string;
+    });
+    trackSchemaFromEvent(eventName: string, eventProperties: {
+        [propName: string]: any;
+    }): Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>;
+    private _avoFunctionTrackSchemaFromEvent;
+    trackSchema(eventName: string, eventSchema: Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>): void;
+    private trackSchemaInternal;
+    enableLogging(enable: boolean): void;
+    extractSchema(eventProperties: {
+        [propName: string]: any;
+    }, shouldLogIfEnabled?: boolean): Array<{
+        propertyName: string;
+        propertyType: string;
+        children?: any;
+    }>;
+    setBatchSize(newBatchSize: number): void;
+    setBatchFlushSeconds(newBatchFlushSeconds: number): void;
+}

package/dist-native/AvoInspector.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvoInspector = void 0;
+var AvoInspectorEnv_1 = require("./AvoInspectorEnv");
+var AvoSchemaParser_1 = require("./AvoSchemaParser");
+var AvoSessionTracker_1 = require("./AvoSessionTracker");
+var AvoBatcher_1 = require("./AvoBatcher");
+var AvoNetworkCallsHandler_1 = require("./AvoNetworkCallsHandler");
+var AvoStorage_1 = require("./AvoStorage");
+var AvoDeduplicator_1 = require("./AvoDeduplicator");
+var utils_1 = require("./utils");
+var libVersion = require("../package.json").version;
+var AvoInspector = /** @class */ (function () {
+    // constructor(apiKey: string, env: AvoInspectorEnv, version: string) {
+    function AvoInspector(options) {
+        var _this = this;
+        // the constructor does aggressive null/undefined checking because same code paths will be accessible from JS
+        if ((0, utils_1.isValueEmpty)(options.env)) {
+            this.environment = AvoInspectorEnv_1.AvoInspectorEnv.Dev;
+            console.warn("[Avo Inspector] No environment provided. Defaulting to dev.");
+        }
+        else if (Object.values(AvoInspectorEnv_1.AvoInspectorEnv).indexOf(options.env) === -1) {
+            this.environment = AvoInspectorEnv_1.AvoInspectorEnv.Dev;
+            console.warn("[Avo Inspector] Unsupported environment provided. Defaulting to dev. Supported environments - Dev, Staging, Prod.");
+        }
+        else {
+            this.environment = options.env;
+        }
+        if ((0, utils_1.isValueEmpty)(options.apiKey)) {
+            throw new Error("[Avo Inspector] No API key provided. Inspector can't operate without API key.");
+        }
+        else {
+            this.apiKey = options.apiKey;
+        }
+        if ((0, utils_1.isValueEmpty)(options.version)) {
+            throw new Error("[Avo Inspector] No version provided. Many features of Inspector rely on versioning. Please provide comparable string version, i.e. integer or semantic.");
+        }
+        else {
+            this.version = options.version;
+        }
+        if (this.environment === AvoInspectorEnv_1.AvoInspectorEnv.Dev) {
+            AvoInspector._batchSize = 1;
+            AvoInspector._shouldLog = true;
+        }
+        else {
+            AvoInspector._batchSize = 30;
+            AvoInspector._batchFlushSeconds = 30;
+            AvoInspector._shouldLog = false;
+        }
+        AvoInspector.avoStorage = new AvoStorage_1.AvoStorage(AvoInspector._shouldLog);
+        var avoNetworkCallsHandler = new AvoNetworkCallsHandler_1.AvoNetworkCallsHandler(this.apiKey, this.environment.toString(), options.appName || "", this.version, libVersion);
+        this.avoBatcher = new AvoBatcher_1.AvoBatcher(avoNetworkCallsHandler);
+        this.sessionTracker = new AvoSessionTracker_1.AvoSessionTracker(this.avoBatcher);
+        this.avoDeduplicator = new AvoDeduplicator_1.AvoDeduplicator();
+        try {
+            if (process.env.BROWSER) {
+                // XXX make node/browser split clearer
+                if (typeof window !== "undefined") {
+                    window.addEventListener("load", function () {
+                        _this.sessionTracker.startOrProlongSession(Date.now());
+                    }, false);
+                }
+            }
+            else {
+                this.sessionTracker.startOrProlongSession(Date.now());
+            }
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+        }
+    }
+    Object.defineProperty(AvoInspector, "batchSize", {
+        get: function () {
+            return this._batchSize;
+        },
+        set: function (newSize) {
+            if (newSize < 1) {
+                this._batchSize = 1;
+            }
+            else {
+                this._batchSize = newSize;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AvoInspector, "batchFlushSeconds", {
+        get: function () {
+            return this._batchFlushSeconds;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AvoInspector, "shouldLog", {
+        get: function () {
+            return this._shouldLog;
+        },
+        set: function (enable) {
+            this._shouldLog = enable;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AvoInspector.prototype.trackSchemaFromEvent = function (eventName, eventProperties) {
+        try {
+            if (this.avoDeduplicator.shouldRegisterEvent(eventName, eventProperties, false)) {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: supplied event " +
+                        eventName +
+                        " with params " +
+                        JSON.stringify(eventProperties));
+                }
+                var eventSchema = this.extractSchema(eventProperties, false);
+                this.trackSchemaInternal(eventName, eventSchema, null, null);
+                return eventSchema;
+            }
+            else {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: Deduplicated event: " + eventName);
+                }
+                return [];
+            }
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+            return [];
+        }
+    };
+    AvoInspector.prototype._avoFunctionTrackSchemaFromEvent = function (eventName, eventProperties, eventId, eventHash) {
+        try {
+            if (this.avoDeduplicator.shouldRegisterEvent(eventName, eventProperties, true)) {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: supplied event " +
+                        eventName +
+                        " with params " +
+                        JSON.stringify(eventProperties));
+                }
+                var eventSchema = this.extractSchema(eventProperties, false);
+                this.trackSchemaInternal(eventName, eventSchema, eventId, eventHash);
+                return eventSchema;
+            }
+            else {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: Deduplicated event: " + eventName);
+                }
+                return [];
+            }
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+            return [];
+        }
+    };
+    AvoInspector.prototype.trackSchema = function (eventName, eventSchema) {
+        try {
+            if (this.avoDeduplicator.shouldRegisterSchemaFromManually(eventName, eventSchema)) {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: supplied event " +
+                        eventName +
+                        " with schema " +
+                        JSON.stringify(eventSchema));
+                }
+                this.trackSchemaInternal(eventName, eventSchema, null, null);
+            }
+            else {
+                if (AvoInspector.shouldLog) {
+                    console.log("Avo Inspector: Deduplicated event: " + eventName);
+                }
+            }
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+        }
+    };
+    AvoInspector.prototype.trackSchemaInternal = function (eventName, eventSchema, eventId, eventHash) {
+        try {
+            this.sessionTracker.startOrProlongSession(Date.now());
+            this.avoBatcher.handleTrackSchema(eventName, eventSchema, eventId, eventHash);
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+        }
+    };
+    AvoInspector.prototype.enableLogging = function (enable) {
+        AvoInspector._shouldLog = enable;
+    };
+    AvoInspector.prototype.extractSchema = function (eventProperties, shouldLogIfEnabled) {
+        if (shouldLogIfEnabled === void 0) { shouldLogIfEnabled = true; }
+        try {
+            this.sessionTracker.startOrProlongSession(Date.now());
+            if (this.avoDeduplicator.hasSeenEventParams(eventProperties, true)) {
+                if (shouldLogIfEnabled && AvoInspector.shouldLog) {
+                    console.warn("Avo Inspector: WARNING! You are trying to extract schema shape that was just reported by your Avo functions. " +
+                        "This is an indicator of duplicate inspector reporting. " +
+                        "Please reach out to support@avo.app for advice if you are not sure how to handle this.");
+                }
+            }
+            if (AvoInspector.shouldLog) {
+                console.log("Avo Inspector: extracting schema from " +
+                    JSON.stringify(eventProperties));
+            }
+            return AvoSchemaParser_1.AvoSchemaParser.extractSchema(eventProperties);
+        }
+        catch (e) {
+            console.error("Avo Inspector: something went wrong. Please report to support@avo.app.", e);
+            return [];
+        }
+    };
+    AvoInspector.prototype.setBatchSize = function (newBatchSize) {
+        AvoInspector._batchSize = newBatchSize;
+    };
+    AvoInspector.prototype.setBatchFlushSeconds = function (newBatchFlushSeconds) {
+        AvoInspector._batchFlushSeconds = newBatchFlushSeconds;
+    };
+    AvoInspector._batchSize = 30;
+    AvoInspector._batchFlushSeconds = 30;
+    AvoInspector._shouldLog = false;
+    return AvoInspector;
+}());
+exports.AvoInspector = AvoInspector;