node-avo-inspector 1.2.0 → 2.0.0-beta.2

package/dist/AvoSchemaParser.js

@@ -4,32 +4,115 @@ exports.AvoSchemaParser = void 0;
 let isArray = (obj) => {
     return Object.prototype.toString.call(obj) === "[object Array]";
 };
+let isComplex = (value) => {
+    return typeof value === "object" && value != null;
+};
+// Binary data is never enumerated (a Buffer has one indexed key per byte): an ArrayBuffer view
+// is typed by its element type, as Java and Go type primitive arrays. A float view
+// (Float16Array, Float32Array, Float64Array) is list(float) with children ["float"], any other
+// (Buffer, integer typed array, DataView) list(int) with ["int"]; an ArrayBuffer or
+// SharedArrayBuffer is an object with no properties. It is still one complex value: the leaf
+// rules apply to it first, and mapping it costs one expansion.
+const FLOAT_VIEW_TAGS = ["[object Float16Array]", "[object Float32Array]", "[object Float64Array]"];
+const binaryElementType = (value) => {
+    if (!ArrayBuffer.isView(value)) {
+        return null;
+    }
+    return FLOAT_VIEW_TAGS.indexOf(Object.prototype.toString.call(value)) >= 0 ? "float" : "int";
+};
+const isArrayBufferLike = (value) => {
+    const tag = Object.prototype.toString.call(value);
+    return tag === "[object ArrayBuffer]" || tag === "[object SharedArrayBuffer]";
+};
+// A view's children, whatever its length: its elements are never visited.
+const binaryChildren = (_value, elementType) => [elementType];
+// Deeper complex values are reported as "object" instead of being descended into.
+const MAX_DEPTH = 10;
+// Complex values expanded per extractSchema call. Shared references that are not cycles
+// can otherwise expand exponentially; the rest are reported as "object" like the depth cap.
+const MAX_EXPANSIONS = 10000;
+// Properties emitted per extractSchema call, at every depth; past it the rest are omitted
+// (in iteration order). Independent of MAX_EXPANSIONS: one object with a million keys is a
+// single expansion.
+const MAX_PROPERTIES = 10000;
 class AvoSchemaParser {
+    /**
+     * Maps each property to its name, type and (for objects and lists) child schema.
+     * Values nested deeper than MAX_DEPTH, cyclic references, and complex values past the
+     * MAX_EXPANSIONS budget are reported as "object".
+     */
     static extractSchema(eventProperties) {
-        if (eventProperties === null || eventProperties === undefined) {
+        // Only an object has named properties. JavaScript callers can pass anything, and
+        // mapping a primitive, an array or binary data as the root would return a bare type or
+        // an element list instead of properties (the wire's eventProperties is a list of them).
+        if (!isComplex(eventProperties) ||
+            isArray(eventProperties) ||
+            binaryElementType(eventProperties) !== null ||
+            isArrayBufferLike(eventProperties)) {
             return [];
         }
-        let mapping = (object) => {
+        // Objects and arrays on the path from the root to the value being mapped. A value that
+        // is its own ancestor (a cycle) is reported like one past the depth cap, so an object
+        // holding itself under several keys cannot expand exponentially.
+        const ancestors = new Set();
+        let expansions = 0;
+        let properties = 0;
+        const isLeaf = (value, depth) => isComplex(value) &&
+            (depth >= MAX_DEPTH || ancestors.has(value) || expansions >= MAX_EXPANSIONS);
+        let mapping = (object, depth) => {
+            if (isComplex(object)) {
+                ancestors.add(object);
+                expansions += 1;
+            }
+            try {
+                return mapValue(object, depth);
+            }
+            finally {
+                ancestors.delete(object);
+            }
+        };
+        let mapValue = (object, depth) => {
+            const elementType = binaryElementType(object);
+            if (elementType !== null) {
+                return binaryChildren(object, elementType);
+            }
+            if (isArrayBufferLike(object)) {
+                return [];
+            }
             if (isArray(object)) {
                 let list = object.map((x) => {
-                    return mapping(x);
+                    return isLeaf(x, depth) ? "object" : mapping(x, depth + 1);
                 });
                 return this.removeDuplicates(list);
             }
-            else if (typeof object === "object") {
+            else if (isComplex(object)) {
+                // isComplex, not typeof: a null list element is the type "null" (spec §9.2), not
+                // an object to enumerate.
                 let mappedResult = [];
-                for (var key in object) {
-                    if (object.hasOwnProperty(key)) {
-                        let val = object[key];
-                        let mappedEntry = {
-                            propertyName: key,
-                            propertyType: this.getPropValueType(val),
-                        };
-                        if (typeof val === "object" && val != null) {
-                            mappedEntry["children"] = mapping(val);
+                // Object.keys, not object.hasOwnProperty: a null-prototype object has no such method,
+                // and a property named "hasOwnProperty" would shadow it.
+                for (const key of Object.keys(object)) {
+                    if (properties >= MAX_PROPERTIES) {
+                        break;
+                    }
+                    properties += 1;
+                    let val = object[key];
+                    let mappedEntry = {
+                        propertyName: key,
+                        propertyType: this.getPropValueType(val),
+                    };
+                    // Binary data takes this path too, as in Java and Go: past the limits it is "object",
+                    // otherwise mapping types it with one expansion, without walking its bytes.
+                    if (isComplex(val)) {
+                        if (isLeaf(val, depth)) {
+                            mappedEntry.propertyType = "object";
+                            mappedEntry["children"] = [];
+                        }
+                        else {
+                            mappedEntry["children"] = mapping(val, depth + 1);
                         }
-                        mappedResult.push(mappedEntry);
                     }
+                    mappedResult.push(mappedEntry);
                 }
                 return mappedResult;
             }
@@ -37,25 +120,39 @@ class AvoSchemaParser {
                 return this.getPropValueType(object);
             }
         };
-        var mappedEventProps = mapping(eventProperties);
+        var mappedEventProps = mapping(eventProperties, 0);
         return mappedEventProps;
     }
+    // A list's children: each distinct child schema once, the first occurrence, in order. Children
+    // are compared by value (childKey), so equal elements, such as one Buffer repeated, leave one
+    // child. Only the output is deduplicated: every element was already mapped and counted
+    // toward the limits.
     static removeDuplicates(array) {
-        // XXX TODO fix any types
-        var primitives = { boolean: {}, number: {}, string: {} };
-        var objects = [];
+        const seen = new Set();
         return array.filter((item) => {
-            var type = typeof item;
-            if (type in primitives) {
-                return primitives[type].hasOwnProperty(item)
-                    ? false
-                    : (primitives[type][item] = true);
-            }
-            else {
-                return objects.indexOf(item) >= 0 ? false : objects.push(item);
+            const key = this.childKey(item);
+            if (seen.has(key)) {
+                return false;
             }
+            seen.add(key);
+            return true;
         });
     }
+    // A canonical key for a child schema: a type string; an object's properties, sorted so that
+    // property order does not matter; or a nested list's children, in order.
+    static childKey(child) {
+        if (typeof child === "string") {
+            return JSON.stringify(child);
+        }
+        if (child.length > 0 && !isArray(child[0]) && typeof child[0] === "object") {
+            const properties = child.map((entry) => JSON.stringify(entry.propertyName) +
+                ":" +
+                JSON.stringify(entry.propertyType) +
+                (entry.children !== undefined ? ":" + this.childKey(entry.children) : ""));
+            return "{" + properties.sort().join(",") + "}";
+        }
+        return "[" + child.map((element) => this.childKey(element)).join(",") + "]";
+    }
     static getBasicPropType(propValue) {
         let propType = typeof propValue;
         if (propValue == null) {
@@ -64,13 +161,13 @@ class AvoSchemaParser {
         else if (propType === "string") {
             return "string";
         }
-        else if (propType === "number" || propType === "bigint") {
-            if ((propValue + "").indexOf(".") >= 0) {
-                return "float";
-            }
-            else {
-                return "int";
-            }
+        else if (propType === "bigint") {
+            return "int";
+        }
+        else if (propType === "number") {
+            // Whole numbers (including 0.0, which JS cannot tell from 0) are "int"; everything
+            // else, including exponent forms like 1e-7, NaN and ±Infinity, is "float".
+            return Number.isInteger(propValue) ? "int" : "float";
         }
         else if (propType === "boolean") {
             return "boolean";
@@ -83,6 +180,10 @@ class AvoSchemaParser {
         }
     }
     static getPropValueType(propValue) {
+        const elementType = binaryElementType(propValue);
+        if (elementType !== null) {
+            return `list(${elementType})`;
+        }
         if (isArray(propValue)) {
             //we now know that propValue is an array. get first element in propValue array
             let propElement = propValue[0];
@@ -91,6 +192,10 @@ class AvoSchemaParser {
             }
             else {
                 let propElementType = this.getBasicPropType(propElement);
+                // "list(unknown)" is not a wire type; elements with no JSON type count as objects.
+                if (propElementType === "unknown") {
+                    propElementType = "object";
+                }
                 return `list(${propElementType})`;
             }
         }

package/dist/AvoStreamId.d.ts

@@ -1,5 +1,6 @@
 export declare class AvoStreamId {
     private _streamId;
-    constructor(streamId?: string);
+    constructor(streamId?: unknown);
+    private static normalize;
     get streamId(): string;
 }

package/dist/AvoStreamId.js

@@ -1,13 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvoStreamId = void 0;
+const AvoInspector_1 = require("./AvoInspector");
+const AvoLog_1 = require("./AvoLog");
 class AvoStreamId {
+    // Accepts whatever a JavaScript caller passes. Numbers, bigints and booleans (a numeric
+    // user id, say) are sent as their string form; any other non-string is ignored.
     constructor(streamId) {
-        this._streamId = streamId !== null && streamId !== void 0 ? streamId : "";
+        this._streamId = AvoStreamId.normalize(streamId);
         if (this._streamId.includes(":")) {
-            console.warn("[Avo Inspector] Warning: streamId contains ':' which is not supported");
+            AvoLog_1.AvoLog.streamIdColon();
         }
     }
+    static normalize(streamId) {
+        if (streamId === undefined || streamId === null) {
+            return "";
+        }
+        if (typeof streamId === "string") {
+            return streamId;
+        }
+        if (typeof streamId === "number" || typeof streamId === "bigint" || typeof streamId === "boolean") {
+            return String(streamId);
+        }
+        if (AvoInspector_1.AvoInspector.shouldLog) {
+            console.warn("[Avo Inspector] Warning: streamId must be a string; ignoring a value of type " + typeof streamId);
+        }
+        return "";
+    }
     get streamId() {
         return this._streamId;
     }

package/dist/eventSpec/AvoEventSpecCache.d.ts

@@ -1,18 +1,41 @@
-import { EventSpecResponse } from "./AvoEventSpecFetchTypes";
+import { EventSpecCoordinates, EventSpecResponse } from "./AvoEventSpecFetchTypes";
+/**
+ * The key of a fetch with gateway coordinates, or undefined without any: "\0" and a JSON
+ * array of `parts` then both normalized coordinates (null for an absent one). JSON encodes
+ * every part on its own, so no event name can make it equal another key; and as the
+ * apiKey never contains NUL, no key without coordinates starts with "\0".
+ * Shared by the spec cache key and the fetcher's in-flight dedupe key.
+ */
+export declare const coordinatesKey: (parts: string[], coordinates?: EventSpecCoordinates) => string | undefined;
+/** Trims each coordinate and drops a blank or non-string one. */
+export declare const normalizeCoordinates: (coordinates?: EventSpecCoordinates) => EventSpecCoordinates;
+/** TTL of a fetch that failed other than with a 404, so a blip skips validation only briefly. */
+export declare const TRANSIENT_FAILURE_TTL_MS = 5000;
 export declare class AvoEventSpecCache {
     private cache;
     private globalEventCount;
-    static makeKey(apiKey: string, streamId: string, eventName: string): string;
+    /**
+     * The key of one spec. Gateway coordinates are part of it, so a gateway-input spec and an
+     * output spec for the same event name never share an entry; without coordinates the key
+     * is the plain `apiKey\0streamId\0eventName`.
+     */
+    static makeKey(apiKey: string, streamId: string, eventName: string, coordinates?: EventSpecCoordinates): string;
     /**
      * Returns the cached EventSpecResponse, or undefined on cache miss.
-     * A cached response with eventSpec: null means "no spec exists for this event".
+     * A cached response with eventSpec: null means "no spec exists for this event";
+     * a cached null means the fetch failed (such as a 404), so the event is not validated.
      */
-    get(key: string): EventSpecResponse | undefined;
+    get(key: string): EventSpecResponse | null | undefined;
     /**
      * Returns true if the key exists in the cache and has not expired.
      */
     contains(key: string): boolean;
-    set(key: string, value: EventSpecResponse): void;
+    /**
+     * Stores a fetched spec, or null for a failed fetch. A spec is kept until its TTL or
+     * MAX_EVENT_COUNT uses; a null until its TTL only. `ttlMs` defaults to 60 s; a transient
+     * failure passes TRANSIENT_FAILURE_TTL_MS.
+     */
+    set(key: string, value: EventSpecResponse | null, ttlMs?: number): void;
     flush(): void;
     private purgeExpired;
     private evictLRU;

package/dist/eventSpec/AvoEventSpecCache.js

@@ -1,19 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvoEventSpecCache = void 0;
+exports.AvoEventSpecCache = exports.TRANSIENT_FAILURE_TTL_MS = exports.normalizeCoordinates = exports.coordinatesKey = void 0;
+const utils_1 = require("../utils");
 const MAX_EVENT_COUNT = 50;
+/**
+ * The key of a fetch with gateway coordinates, or undefined without any: "\0" and a JSON
+ * array of `parts` then both normalized coordinates (null for an absent one). JSON encodes
+ * every part on its own, so no event name can make it equal another key; and as the
+ * apiKey never contains NUL, no key without coordinates starts with "\0".
+ * Shared by the spec cache key and the fetcher's in-flight dedupe key.
+ */
+const coordinatesKey = (parts, coordinates) => {
+    const { originHint, outputReference } = (0, exports.normalizeCoordinates)(coordinates);
+    if (originHint === undefined && outputReference === undefined) {
+        return undefined;
+    }
+    return "\0" + JSON.stringify([...parts, originHint !== null && originHint !== void 0 ? originHint : null, outputReference !== null && outputReference !== void 0 ? outputReference : null]);
+};
+exports.coordinatesKey = coordinatesKey;
+/** Trims each coordinate and drops a blank or non-string one. */
+const normalizeCoordinates = (coordinates) => {
+    const result = {};
+    if (coordinates === null || typeof coordinates !== "object") {
+        return result;
+    }
+    const originHint = (0, utils_1.normalizeOption)(coordinates.originHint);
+    const outputReference = (0, utils_1.normalizeOption)(coordinates.outputReference);
+    if (originHint !== undefined) {
+        result.originHint = originHint;
+    }
+    if (outputReference !== undefined) {
+        result.outputReference = outputReference;
+    }
+    return result;
+};
+exports.normalizeCoordinates = normalizeCoordinates;
 const TTL_MS = 60000;
+/** TTL of a fetch that failed other than with a 404, so a blip skips validation only briefly. */
+exports.TRANSIENT_FAILURE_TTL_MS = 5000;
 class AvoEventSpecCache {
     constructor() {
         this.cache = new Map();
         this.globalEventCount = 0;
     }
-    static makeKey(apiKey, streamId, eventName) {
-        return `${apiKey}\0${streamId}\0${eventName}`;
+    /**
+     * The key of one spec. Gateway coordinates are part of it, so a gateway-input spec and an
+     * output spec for the same event name never share an entry; without coordinates the key
+     * is the plain `apiKey\0streamId\0eventName`.
+     */
+    static makeKey(apiKey, streamId, eventName, coordinates) {
+        var _a;
+        return (_a = (0, exports.coordinatesKey)([apiKey, streamId, eventName], coordinates)) !== null && _a !== void 0 ? _a : `${apiKey}\0${streamId}\0${eventName}`;
     }
     /**
      * Returns the cached EventSpecResponse, or undefined on cache miss.
-     * A cached response with eventSpec: null means "no spec exists for this event".
+     * A cached response with eventSpec: null means "no spec exists for this event";
+     * a cached null means the fetch failed (such as a 404), so the event is not validated.
      */
     get(key) {
         const entry = this.cache.get(key);
@@ -21,13 +63,14 @@ class AvoEventSpecCache {
             return undefined;
         }
         // TTL check
-        if (Date.now() - entry.timestamp > TTL_MS) {
+        if (Date.now() - entry.timestamp > entry.ttlMs) {
             this.cache.delete(key);
             return undefined;
         }
-        // Per-entry access count eviction
+        // Per-entry access count eviction, which refreshes a spec after MAX_EVENT_COUNT uses.
+        // A cached failure has nothing to refresh: it stays until its TTL.
         entry.eventCount++;
-        if (entry.eventCount >= MAX_EVENT_COUNT) {
+        if (entry.value !== null && entry.eventCount >= MAX_EVENT_COUNT) {
             this.cache.delete(key);
             return undefined;
         }
@@ -42,17 +85,28 @@ class AvoEventSpecCache {
         if (entry === undefined) {
             return false;
         }
-        if (Date.now() - entry.timestamp > TTL_MS) {
+        if (Date.now() - entry.timestamp > entry.ttlMs) {
             this.cache.delete(key);
             return false;
         }
-        if (entry.eventCount >= MAX_EVENT_COUNT) {
+        if (entry.value !== null && entry.eventCount >= MAX_EVENT_COUNT) {
             this.cache.delete(key);
             return false;
         }
         return true;
     }
-    set(key, value) {
+    /**
+     * Stores a fetched spec, or null for a failed fetch. A spec is kept until its TTL or
+     * MAX_EVENT_COUNT uses; a null until its TTL only. `ttlMs` defaults to 60 s; a transient
+     * failure passes TRANSIENT_FAILURE_TTL_MS.
+     */
+    set(key, value, ttlMs = TTL_MS) {
+        // Every track sharing one fetch stores its response: only the first store counts, or a
+        // burst of such tracks would rotate unrelated entries out of the cache.
+        const existing = this.cache.get(key);
+        if (existing !== undefined && existing.value === value) {
+            return;
+        }
         this.globalEventCount++;
         // Global rotation: evict LRU entry every MAX_EVENT_COUNT operations
         if (this.globalEventCount >= MAX_EVENT_COUNT) {
@@ -63,6 +117,7 @@ class AvoEventSpecCache {
         this.cache.set(key, {
             value,
             timestamp: Date.now(),
+            ttlMs,
             eventCount: 0,
             lastAccessed: Date.now(),
         });
@@ -78,7 +133,7 @@ class AvoEventSpecCache {
     purgeExpired() {
         const now = Date.now();
         for (const [key, entry] of this.cache.entries()) {
-            if (now - entry.timestamp > TTL_MS) {
+            if (now - entry.timestamp > entry.ttlMs) {
                 this.cache.delete(key);
             }
         }

package/dist/eventSpec/AvoEventSpecFetchTypes.d.ts

@@ -1,18 +1,42 @@
 /**
  * Type definitions for Event Spec validation responses.
  */
-/** A single property constraint from the spec. */
-export interface PropertyConstraint {
-    propertyName: string;
-    /** Expected type, e.g. "string", "int", "float", "boolean", "object", "list(string)" */
-    propertyType: string;
-    /** Optional regex pattern that the value must match */
-    regex?: string;
+/**
+ * The value constraints the spec sets on one property. Each constraint maps a key to the
+ * tracking-plan event IDs (base event or variant) that require it, so one property can carry
+ * different rules for different variants.
+ */
+export interface PropertyConstraints {
+    /** Tracking-plan type name, e.g. "string", "int", "float", "bool", "object" (not validated) */
+    type: string;
+    /** Whether the property is required (a missing value fails only when it is) */
+    required: boolean;
+    /** True when the property is a list of `type` */
+    isList?: boolean;
+    /** Pinned values: exact value -> event IDs that require it */
+    pinnedValues?: Record<string, string[]>;
+    /** Allowed values: JSON array of strings -> event IDs that accept only those values */
+    allowedValues?: Record<string, string[]>;
+    /** Regex patterns: pattern -> event IDs that require a match */
+    regexPatterns?: Record<string, string[]>;
+    /** Ranges: "min,max" (either bound may be empty) -> event IDs that require it */
+    minMaxRanges?: Record<string, string[]>;
+    /** Constraints on the properties of an object, or of each object in a list */
+    children?: Record<string, PropertyConstraints>;
 }
-/** The spec for a single event, as returned by the API. */
+/** One tracking-plan event matching the requested name: its base event and variants. */
+export interface EventSpecEntry {
+    branchId: string;
+    baseEventId: string;
+    variantIds: string[];
+    /** Only the properties that carry value constraints */
+    props: Record<string, PropertyConstraints>;
+}
+/** The spec for an event name, as returned by the API. */
 export interface EventSpec {
     eventName: string;
-    properties: PropertyConstraint[];
+    /** Several entries when name mapping matches more than one event */
+    events: EventSpecEntry[];
 }
 /** Metadata identifying the spec source. */
 export interface EventSpecMetadata {
@@ -26,16 +50,24 @@ export interface EventSpecResponse {
     eventSpec: EventSpec | null;
     metadata: EventSpecMetadata;
 }
+/**
+ * The outcome for one property: the tracking-plan event IDs whose constraints the value
+ * breaks, and the outcome for the object's properties when it has any.
+ */
+export interface PropertyValidationOutcome {
+    failedEventIds: string[];
+    children?: Record<string, PropertyValidationOutcome>;
+}
 /** Per-property validation result. */
-export interface PropertyValidationResult {
+export interface PropertyValidationResult extends PropertyValidationOutcome {
     propertyName: string;
-    failedEventIds: string[];
-    passedEventIds: string[];
 }
-/** Payload sent to reportValidatedEvent. */
-export interface ValidatedEventPayload {
-    streamId: string;
-    eventName: string;
-    eventSpecMetadata: EventSpecMetadata;
-    propertyResults: PropertyValidationResult[];
+/**
+ * The gateway coordinates of a spec fetch, as the event carries them on the track body:
+ * trimmed, blank omitted. With `originHint` a gateway key answers the gateway-input
+ * checkpoint's spec, with both that output's spec; a source key ignores them.
+ */
+export interface EventSpecCoordinates {
+    originHint?: string;
+    outputReference?: string;
 }

package/dist/eventSpec/AvoEventSpecFetcher.d.ts

@@ -1,25 +1,48 @@
-import { EventSpecResponse } from "./AvoEventSpecFetchTypes";
-type FetchCallback = (result: EventSpecResponse | null) => void;
+import { EventSpecResponse, EventSpecCoordinates } from "./AvoEventSpecFetchTypes";
+/**
+ * `notFound` is true when a null result is the endpoint's 404 (no spec for these keys),
+ * false for any other failure (status, timeout, network error, unparseable body).
+ */
+type FetchCallback = (result: EventSpecResponse | null, notFound?: boolean) => void;
 export declare class AvoEventSpecFetcher {
     private apiKey;
+    private protocol;
+    private hostname;
+    private port;
+    private origin;
     private inFlight;
     private agent;
+    private requests;
     private static specEndpoint;
-    constructor(apiKey: string);
-    fetch(eventName: string, streamId: string, callback: FetchCallback): void;
+    private static fetchTimeoutMs;
+    private static socketWaitTimeoutMs;
+    /** `mockEndpoint`: a valid override URL (AvoNetworkCallsHandler.mockEndpoint), or null. */
+    constructor(apiKey: string, mockEndpoint?: string | null);
+    /**
+     * `coordinates`: the event's gateway coordinates. Each non-blank one is sent as a query
+     * parameter and is part of the dedupe key; without any, the request and key are those of
+     * a plain source fetch.
+     */
+    fetch(eventName: string, streamId: string, callback: FetchCallback, coordinates?: EventSpecCoordinates): void;
+    private send;
     private resolveCallbacks;
     /**
      * Parse the wire format from /trackingPlan/eventSpec into our internal types.
      *
      * Wire format:
-     *   { events: [{ b, id, vids, p: { "PropName": { t: "string", r: true, v: {...}, rx: {...} } } }],
+     *   { events: [{ b, id, vids, p: { "PropName": { t, r, l?, p?, v?, rx?, minmax?, children? } } }],
      *     metadata: { schemaId, branchId, latestActionId, sourceId } }
+     *   where p, v, rx and minmax each map a constraint key to the event IDs that require it.
      *
      * Internal format:
-     *   { eventSpec: { eventName, properties: [{ propertyName, propertyType, regex? }] } | null,
+     *   { eventSpec: { eventName, events: [{ branchId, baseEventId, variantIds, props }] } | null,
      *     metadata: { schemaId, branchId, latestActionId, sourceId } }
      */
     static parseWireResponse(wire: any, eventName: string): EventSpecResponse;
+    private static parseEventEntry;
+    private static parseConstraintsByName;
+    private static parseConstraints;
+    /** Aborts this instance's in-flight requests; the shared agent stays usable. */
     destroy(): void;
 }
 export {};