@reopt-ai/data-contract 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+
+/**
+ * `@reopt-ai/data-contract` — the wire contract between reopt-data and its
+ * server-credential consumers (RFC-0023).
+ *
+ * Subpaths:
+ *   `@reopt-ai/data-contract`         this module — version, shared primitives, errors
+ *   `@reopt-ai/data-contract/ingest`  POST /api/track request + response schemas
+ *   `@reopt-ai/data-contract/query`   POST /api/v1/query/* request + response schemas
+ *   `@reopt-ai/data-contract/client`  createDataClient() — typed fetch over both
+ *
+ * Only `/client` touches `fetch`; everything else is pure zod. The single
+ * runtime dependency is zod, deliberately — consumers bundle this.
+ */
+
+/**
+ * Contract version. Bumped on any breaking change to a schema in this package.
+ * The server echoes the version it was built against in `x-reopt-contract-version`;
+ * `createDataClient` surfaces a mismatch rather than guessing.
+ */
+declare const CONTRACT_VERSION = "0.1.0";
+/** Response header carrying the server's contract version. */
+declare const CONTRACT_VERSION_HEADER = "x-reopt-contract-version";
+/** Request header names shared by the ingest and query planes. */
+declare const CLIENT_ID_HEADER = "reopt-client-id";
+declare const CLIENT_SECRET_HEADER = "reopt-client-secret";
+declare const WRITE_KEY_HEADER = "reopt-write-key";
+declare const DEVICE_ID_HEADER = "reopt-device-id";
+declare const REQUEST_ID_HEADER = "x-request-id";
+/**
+ * A UTC calendar date. Windows are inclusive on both ends and are widened
+ * server-side to `startDate T00:00:00Z` .. `endDate T23:59:59Z`.
+ */
+declare const zDate: z.ZodString;
+/** ISO-8601 instant, as produced by `Date#toISOString()`. */
+declare const zInstant: z.ZodString;
+/**
+ * Client credentials. The same pair authenticates both planes; what a given
+ * client may reach is decided server-side by `Client.scopes`
+ * (`"ingest"` / `"query"` / `"provision"`).
+ */
+interface ClientCredentials {
+    clientId: string;
+    clientSecret: string;
+}
+/**
+ * Every non-2xx response from either plane, plus the two failures the client
+ * itself raises (`contract_mismatch`, `network_error`).
+ */
+declare class DataApiError extends Error {
+    /**
+     * Brand for {@link DataApiError.is}. A bundler that inlines this module into
+     * more than one entry point produces two distinct classes, and `instanceof`
+     * silently stops matching — the brand survives that, and realm boundaries.
+     */
+    readonly isDataApiError: true;
+    readonly status: number;
+    readonly code: string;
+    readonly requestId?: string;
+    /** Parsed from `Retry-After`, in milliseconds. Only set on 429. */
+    readonly retryAfterMs?: number;
+    /** zod issues for `validation_failed`, or the raw body when unparseable. */
+    readonly details?: unknown;
+    constructor(init: {
+        message: string;
+        status: number;
+        code: string;
+        requestId?: string;
+        retryAfterMs?: number;
+        details?: unknown;
+    });
+    /** 429 and 5xx are worth retrying; 4xx are the caller's fault and are not. */
+    get retryable(): boolean;
+    /**
+     * Prefer this over `instanceof` in a `catch`. It holds even when the class
+     * has been duplicated — across CJS entry points, across bundler chunks, or
+     * across realms — where `instanceof` quietly returns false.
+     */
+    static is(value: unknown): value is DataApiError;
+}
+
+export { CLIENT_ID_HEADER, CLIENT_SECRET_HEADER, CONTRACT_VERSION, CONTRACT_VERSION_HEADER, type ClientCredentials, DEVICE_ID_HEADER, DataApiError, REQUEST_ID_HEADER, WRITE_KEY_HEADER, zDate, zInstant };

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+
+/**
+ * `@reopt-ai/data-contract` — the wire contract between reopt-data and its
+ * server-credential consumers (RFC-0023).
+ *
+ * Subpaths:
+ *   `@reopt-ai/data-contract`         this module — version, shared primitives, errors
+ *   `@reopt-ai/data-contract/ingest`  POST /api/track request + response schemas
+ *   `@reopt-ai/data-contract/query`   POST /api/v1/query/* request + response schemas
+ *   `@reopt-ai/data-contract/client`  createDataClient() — typed fetch over both
+ *
+ * Only `/client` touches `fetch`; everything else is pure zod. The single
+ * runtime dependency is zod, deliberately — consumers bundle this.
+ */
+
+/**
+ * Contract version. Bumped on any breaking change to a schema in this package.
+ * The server echoes the version it was built against in `x-reopt-contract-version`;
+ * `createDataClient` surfaces a mismatch rather than guessing.
+ */
+declare const CONTRACT_VERSION = "0.1.0";
+/** Response header carrying the server's contract version. */
+declare const CONTRACT_VERSION_HEADER = "x-reopt-contract-version";
+/** Request header names shared by the ingest and query planes. */
+declare const CLIENT_ID_HEADER = "reopt-client-id";
+declare const CLIENT_SECRET_HEADER = "reopt-client-secret";
+declare const WRITE_KEY_HEADER = "reopt-write-key";
+declare const DEVICE_ID_HEADER = "reopt-device-id";
+declare const REQUEST_ID_HEADER = "x-request-id";
+/**
+ * A UTC calendar date. Windows are inclusive on both ends and are widened
+ * server-side to `startDate T00:00:00Z` .. `endDate T23:59:59Z`.
+ */
+declare const zDate: z.ZodString;
+/** ISO-8601 instant, as produced by `Date#toISOString()`. */
+declare const zInstant: z.ZodString;
+/**
+ * Client credentials. The same pair authenticates both planes; what a given
+ * client may reach is decided server-side by `Client.scopes`
+ * (`"ingest"` / `"query"` / `"provision"`).
+ */
+interface ClientCredentials {
+    clientId: string;
+    clientSecret: string;
+}
+/**
+ * Every non-2xx response from either plane, plus the two failures the client
+ * itself raises (`contract_mismatch`, `network_error`).
+ */
+declare class DataApiError extends Error {
+    /**
+     * Brand for {@link DataApiError.is}. A bundler that inlines this module into
+     * more than one entry point produces two distinct classes, and `instanceof`
+     * silently stops matching — the brand survives that, and realm boundaries.
+     */
+    readonly isDataApiError: true;
+    readonly status: number;
+    readonly code: string;
+    readonly requestId?: string;
+    /** Parsed from `Retry-After`, in milliseconds. Only set on 429. */
+    readonly retryAfterMs?: number;
+    /** zod issues for `validation_failed`, or the raw body when unparseable. */
+    readonly details?: unknown;
+    constructor(init: {
+        message: string;
+        status: number;
+        code: string;
+        requestId?: string;
+        retryAfterMs?: number;
+        details?: unknown;
+    });
+    /** 429 and 5xx are worth retrying; 4xx are the caller's fault and are not. */
+    get retryable(): boolean;
+    /**
+     * Prefer this over `instanceof` in a `catch`. It holds even when the class
+     * has been duplicated — across CJS entry points, across bundler chunks, or
+     * across realms — where `instanceof` quietly returns false.
+     */
+    static is(value: unknown): value is DataApiError;
+}
+
+export { CLIENT_ID_HEADER, CLIENT_SECRET_HEADER, CONTRACT_VERSION, CONTRACT_VERSION_HEADER, type ClientCredentials, DEVICE_ID_HEADER, DataApiError, REQUEST_ID_HEADER, WRITE_KEY_HEADER, zDate, zInstant };

package/dist/index.js

@@ -0,0 +1,25 @@
+import {
+  CLIENT_ID_HEADER,
+  CLIENT_SECRET_HEADER,
+  CONTRACT_VERSION,
+  CONTRACT_VERSION_HEADER,
+  DEVICE_ID_HEADER,
+  DataApiError,
+  REQUEST_ID_HEADER,
+  WRITE_KEY_HEADER,
+  zDate,
+  zInstant
+} from "./chunk-IAOPUBJU.js";
+export {
+  CLIENT_ID_HEADER,
+  CLIENT_SECRET_HEADER,
+  CONTRACT_VERSION,
+  CONTRACT_VERSION_HEADER,
+  DEVICE_ID_HEADER,
+  DataApiError,
+  REQUEST_ID_HEADER,
+  WRITE_KEY_HEADER,
+  zDate,
+  zInstant
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/ingest.cjs

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkHRKELGGHcjs = require('./chunk-HRKELGGH.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.INGEST_ERROR_CODES = _chunkHRKELGGHcjs.INGEST_ERROR_CODES; exports.INGEST_MODES = _chunkHRKELGGHcjs.INGEST_MODES; exports.INGEST_REJECTION_REASONS = _chunkHRKELGGHcjs.INGEST_REJECTION_REASONS; exports.MAX_TRACK_PAYLOAD_BYTES = _chunkHRKELGGHcjs.MAX_TRACK_PAYLOAD_BYTES; exports.RESERVED_EVENT_NAMES = _chunkHRKELGGHcjs.RESERVED_EVENT_NAMES; exports.reconcileIngestResponse = _chunkHRKELGGHcjs.reconcileIngestResponse; exports.zDecrementPayload = _chunkHRKELGGHcjs.zDecrementPayload; exports.zIdentifyPayload = _chunkHRKELGGHcjs.zIdentifyPayload; exports.zIncrementPayload = _chunkHRKELGGHcjs.zIncrementPayload; exports.zIngestAcceptedResponse = _chunkHRKELGGHcjs.zIngestAcceptedResponse; exports.zIngestError = _chunkHRKELGGHcjs.zIngestError; exports.zIngestErrorCode = _chunkHRKELGGHcjs.zIngestErrorCode; exports.zIngestMode = _chunkHRKELGGHcjs.zIngestMode; exports.zIngestOkResponse = _chunkHRKELGGHcjs.zIngestOkResponse; exports.zIngestRejection = _chunkHRKELGGHcjs.zIngestRejection; exports.zIngestRejectionReason = _chunkHRKELGGHcjs.zIngestRejectionReason; exports.zIngestResponse = _chunkHRKELGGHcjs.zIngestResponse; exports.zTrackHandlerPayload = _chunkHRKELGGHcjs.zTrackHandlerPayload; exports.zTrackPayload = _chunkHRKELGGHcjs.zTrackPayload;
+//# sourceMappingURL=ingest.cjs.map

package/dist/ingest.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/eric/reopt-ai/reopt-data/packages/data-contract/dist/ingest.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,0uCAAC","file":"/Users/eric/reopt-ai/reopt-data/packages/data-contract/dist/ingest.cjs"}

package/dist/ingest.d.cts

@@ -0,0 +1,270 @@
+import { z } from 'zod';
+
+/**
+ * `POST /api/track` — the ingest contract.
+ *
+ * The request shape is shared by both credential modes. The *response* shape
+ * is where server-ingest differs: it reports per-event rejections instead of
+ * failing a whole batch, because a forwarder that stalls on one malformed row
+ * stops forwarding forever.
+ *
+ * Absorbed from the former internal `@reopt/ingest-contract`; that package is
+ * now a deprecated re-export of this module.
+ */
+
+/** Event names the pipeline reserves for its own session bookkeeping. */
+declare const RESERVED_EVENT_NAMES: readonly ["session_start", "session_end", "screen_view"];
+/** Hard cap enforced by the route before the body is even parsed. */
+declare const MAX_TRACK_PAYLOAD_BYTES = 512000;
+declare const zTrackPayload: z.ZodObject<{
+    name: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    profileId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+declare const zIdentifyPayload: z.ZodObject<{
+    profileId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodEmail>;
+    avatar: z.ZodOptional<z.ZodURL>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const zIncrementPayload: z.ZodObject<{
+    profileId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    property: z.ZodString;
+    value: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const zDecrementPayload: z.ZodObject<{
+    profileId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    property: z.ZodString;
+    value: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const zTrackHandlerPayload: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    eventId: z.ZodUUID;
+    timestamp: z.ZodNumber;
+    type: z.ZodLiteral<"track">;
+    payload: z.ZodObject<{
+        name: z.ZodString;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        profileId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    eventId: z.ZodUUID;
+    timestamp: z.ZodNumber;
+    type: z.ZodLiteral<"identify">;
+    payload: z.ZodObject<{
+        profileId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        firstName: z.ZodOptional<z.ZodString>;
+        lastName: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodEmail>;
+        avatar: z.ZodOptional<z.ZodURL>;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    eventId: z.ZodUUID;
+    timestamp: z.ZodNumber;
+    type: z.ZodLiteral<"increment">;
+    payload: z.ZodObject<{
+        profileId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        property: z.ZodString;
+        value: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    eventId: z.ZodUUID;
+    timestamp: z.ZodNumber;
+    type: z.ZodLiteral<"decrement">;
+    payload: z.ZodObject<{
+        profileId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        property: z.ZodString;
+        value: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+type ITrackPayload = z.infer<typeof zTrackPayload>;
+type IIdentifyPayload = z.infer<typeof zIdentifyPayload>;
+type IIncrementPayload = z.infer<typeof zIncrementPayload>;
+type IDecrementPayload = z.infer<typeof zDecrementPayload>;
+type ITrackHandlerPayload = z.infer<typeof zTrackHandlerPayload>;
+/**
+ * Decided by the credential presented, never by a header the caller sets:
+ * `reopt-write-key` alone → `browser`, `reopt-client-id` + `reopt-client-secret`
+ * → `server`. A separate mode header could disagree with the credential; this
+ * cannot.
+ *
+ * `browser` keeps the 5-second click dedup and device-scoped sessions.
+ * `server` drops both and relies solely on `eventId` idempotency — a server
+ * batch legitimately contains the same event name many times within one second,
+ * and its "device" is a process, not a person.
+ */
+declare const INGEST_MODES: readonly ["browser", "server"];
+declare const zIngestMode: z.ZodEnum<{
+    browser: "browser";
+    server: "server";
+}>;
+type IngestMode = z.infer<typeof zIngestMode>;
+/**
+ * Why a single event in a batch was dropped. These are permanent: re-sending
+ * the same row produces the same rejection, so a forwarder should count it as
+ * skipped and advance its cursor rather than retry.
+ */
+declare const INGEST_REJECTION_REASONS: readonly ["validation_failed", "reserved_name", "duplicate_in_batch"];
+declare const zIngestRejectionReason: z.ZodEnum<{
+    validation_failed: "validation_failed";
+    reserved_name: "reserved_name";
+    duplicate_in_batch: "duplicate_in_batch";
+}>;
+type IngestRejectionReason = z.infer<typeof zIngestRejectionReason>;
+declare const zIngestRejection: z.ZodObject<{
+    eventId: z.ZodString;
+    index: z.ZodNumber;
+    reason: z.ZodEnum<{
+        validation_failed: "validation_failed";
+        reserved_name: "reserved_name";
+        duplicate_in_batch: "duplicate_in_batch";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type IngestRejection = z.infer<typeof zIngestRejection>;
+/** 200 — accepted and handed to the materialize queue. */
+declare const zIngestOkResponse: z.ZodObject<{
+    queued: z.ZodBoolean;
+    accepted: z.ZodNumber;
+    duplicates: z.ZodNumber;
+    rejected: z.ZodArray<z.ZodObject<{
+        eventId: z.ZodString;
+        index: z.ZodNumber;
+        reason: z.ZodEnum<{
+            validation_failed: "validation_failed";
+            reserved_name: "reserved_name";
+            duplicate_in_batch: "duplicate_in_batch";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    status: z.ZodLiteral<"ok">;
+    requestId: z.ZodString;
+    mode: z.ZodEnum<{
+        browser: "browser";
+        server: "server";
+    }>;
+}, z.core.$strip>;
+/**
+ * 202 — raw events landed, but enqueueing the materialize task failed. No data
+ * is lost: the `replay-unmaterialized` cron picks these up. A forwarder should
+ * treat this as success and advance its cursor. Carries the same counts as 200
+ * so the reconciliation below works here too.
+ */
+declare const zIngestAcceptedResponse: z.ZodObject<{
+    backgroundQueued: z.ZodLiteral<false>;
+    replay: z.ZodLiteral<"unmaterialized-raw-events">;
+    accepted: z.ZodNumber;
+    duplicates: z.ZodNumber;
+    rejected: z.ZodArray<z.ZodObject<{
+        eventId: z.ZodString;
+        index: z.ZodNumber;
+        reason: z.ZodEnum<{
+            validation_failed: "validation_failed";
+            reserved_name: "reserved_name";
+            duplicate_in_batch: "duplicate_in_batch";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    status: z.ZodLiteral<"accepted">;
+    requestId: z.ZodString;
+    mode: z.ZodEnum<{
+        browser: "browser";
+        server: "server";
+    }>;
+}, z.core.$strip>;
+declare const zIngestResponse: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    queued: z.ZodBoolean;
+    accepted: z.ZodNumber;
+    duplicates: z.ZodNumber;
+    rejected: z.ZodArray<z.ZodObject<{
+        eventId: z.ZodString;
+        index: z.ZodNumber;
+        reason: z.ZodEnum<{
+            validation_failed: "validation_failed";
+            reserved_name: "reserved_name";
+            duplicate_in_batch: "duplicate_in_batch";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    status: z.ZodLiteral<"ok">;
+    requestId: z.ZodString;
+    mode: z.ZodEnum<{
+        browser: "browser";
+        server: "server";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    backgroundQueued: z.ZodLiteral<false>;
+    replay: z.ZodLiteral<"unmaterialized-raw-events">;
+    accepted: z.ZodNumber;
+    duplicates: z.ZodNumber;
+    rejected: z.ZodArray<z.ZodObject<{
+        eventId: z.ZodString;
+        index: z.ZodNumber;
+        reason: z.ZodEnum<{
+            validation_failed: "validation_failed";
+            reserved_name: "reserved_name";
+            duplicate_in_batch: "duplicate_in_batch";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    status: z.ZodLiteral<"accepted">;
+    requestId: z.ZodString;
+    mode: z.ZodEnum<{
+        browser: "browser";
+        server: "server";
+    }>;
+}, z.core.$strip>], "status">;
+type IngestOkResponse = z.infer<typeof zIngestOkResponse>;
+type IngestAcceptedResponse = z.infer<typeof zIngestAcceptedResponse>;
+type IngestResponse = z.infer<typeof zIngestResponse>;
+/**
+ * The reconciliation a forwarder runs on every 2xx:
+ *
+ *     accepted + duplicates + rejected.length === events sent
+ *
+ * A mismatch means the server silently dropped something, which is exactly the
+ * failure mode this contract exists to make impossible to miss.
+ */
+declare function reconcileIngestResponse(response: IngestResponse, sentCount: number): boolean;
+/**
+ * Stable machine-readable codes. Branch on these, never on `error`/`message`,
+ * which are prose and may be reworded.
+ */
+declare const INGEST_ERROR_CODES: readonly ["unauthorized", "invalid_json", "payload_too_large", "empty_batch", "alias_unsupported", "project_without_organization", "validation_failed", "rate_limited", "quota_exceeded", "internal_error"];
+declare const zIngestErrorCode: z.ZodEnum<{
+    unauthorized: "unauthorized";
+    validation_failed: "validation_failed";
+    rate_limited: "rate_limited";
+    internal_error: "internal_error";
+    invalid_json: "invalid_json";
+    payload_too_large: "payload_too_large";
+    empty_batch: "empty_batch";
+    alias_unsupported: "alias_unsupported";
+    project_without_organization: "project_without_organization";
+    quota_exceeded: "quota_exceeded";
+}>;
+type IngestErrorCode = z.infer<typeof zIngestErrorCode>;
+declare const zIngestError: z.ZodObject<{
+    status: z.ZodNumber;
+    code: z.ZodEnum<{
+        unauthorized: "unauthorized";
+        validation_failed: "validation_failed";
+        rate_limited: "rate_limited";
+        internal_error: "internal_error";
+        invalid_json: "invalid_json";
+        payload_too_large: "payload_too_large";
+        empty_batch: "empty_batch";
+        alias_unsupported: "alias_unsupported";
+        project_without_organization: "project_without_organization";
+        quota_exceeded: "quota_exceeded";
+    }>;
+    error: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+    errors: z.ZodOptional<z.ZodUnknown>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type IngestError = z.infer<typeof zIngestError>;
+
+export { type IDecrementPayload, type IIdentifyPayload, type IIncrementPayload, INGEST_ERROR_CODES, INGEST_MODES, INGEST_REJECTION_REASONS, type ITrackHandlerPayload, type ITrackPayload, type IngestAcceptedResponse, type IngestError, type IngestErrorCode, type IngestMode, type IngestOkResponse, type IngestRejection, type IngestRejectionReason, type IngestResponse, MAX_TRACK_PAYLOAD_BYTES, RESERVED_EVENT_NAMES, reconcileIngestResponse, zDecrementPayload, zIdentifyPayload, zIncrementPayload, zIngestAcceptedResponse, zIngestError, zIngestErrorCode, zIngestMode, zIngestOkResponse, zIngestRejection, zIngestRejectionReason, zIngestResponse, zTrackHandlerPayload, zTrackPayload };