@pome-sh/checks 0.1.0

package/dist/_types/wire/otel/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * otel — OpenTelemetry-native trace surface (Open Telemetry Integration, M1).
+ *
+ * Barrel re-export. The golden-fixture corpus under `./fixtures/` is a
+ * test/dev artifact and is intentionally NOT re-exported from the public barrel.
+ *
+ * OWNERSHIP BOUNDARY (settled at FDRS-653; supersedes the earlier
+ * "pome-cloud mirrors this directory verbatim" claim, which no longer held):
+ *   - FORMAT schemas are canonical HERE, in `pome-sh/pome-twins`
+ *     `@pome-sh/shared-types` v0.5.0+ (now `@pome-sh/wire`): `span-event`, `event-schema`,
+ *     `semconv`, `nano`, `project`, `map-span`, `legacy-shim`, and the
+ *     `fixtures/` corpus. pome-cloud CONSUMES this surface (FDRS-654 swaps it
+ *     onto the published package); it does not fork it.
+ *   - INGEST-side utilities are cloud-owned consumers and intentionally do NOT
+ *     live here: OTLP wire decoding (`decode-otlp.ts`), redaction/allowlist
+ *     processors, storage helpers, and the raw OTLP envelope capture tooling +
+ *     captured envelope fixtures that feed the decoder.
+ */
+export * from "./semconv.js";
+export * from "./nano.js";
+export * from "./project.js";
+export * from "./span-event.js";
+export * from "./map-span.js";
+export * from "./legacy-shim.js";
+export * from "./event-schema.js";

package/dist/_types/wire/otel/legacy-shim.d.ts

@@ -0,0 +1,105 @@
+/**
+ * otel/legacy-shim — legacy event → `OtelSpanEvent` translation (M1.2 / FDRS-481).
+ *
+ * The compatibility layer for the transition window: the CLI keeps uploading its
+ * current JSONL (no flag day), and OTel-aware downstream (M3 correlation, the
+ * native waterfall) reads `OtelSpanEvent`. This shim translates the three legacy
+ * variants — `TwinHttpEvent`, `LlmCallEvent`, `ToolUseEvent` — up into spans so
+ * legacy and new data share one path.
+ *
+ * Guarantees:
+ *   - **Lossless.** The ENTIRE original record is preserved verbatim as a JSON
+ *     string under `attributes["pome.legacy.record_json"]` — serialized from the
+ *     raw input BEFORE Zod strips any additive fields (review finding #3). The
+ *     mapped fields are ALSO written as canonical OTel attributes, from which
+ *     the typed projections are derived by the SAME projector the schema checks.
+ *   - **Deterministic.** No clock, no randomness. Same record (+ same `run_id`
+ *     option) → byte-identical span, every run.
+ *   - **OTel-correct status** (review findings #5/#9). HTTP client spans: 1xx–3xx
+ *     leave status UNSET; 4xx/5xx and transport errors are ERROR. (OTel does not
+ *     set OK on a merely-successful span.)
+ *
+ * IDs are namespaced `legacy:<source-id>` so a stored span always declares it
+ * originated from a pre-OTel record (the canonical schema accepts either real
+ * W3C ids or `legacy:` ids).
+ *
+ * Pinned convention: the shim targets `OTEL_GENAI_SCHEMA_VERSION` (see `./semconv`).
+ */
+import { z } from "zod";
+import { type OtelSpanEvent } from "./span-event.js";
+export declare const LEGACY_SHIM_SEMCONV_VERSION: "1.42.0";
+export declare const LEGACY_ATTR_NAMESPACE: "pome.legacy";
+export declare const LEGACY_ID_PREFIX: "legacy:";
+export declare const shimmableLegacyEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ts: z.ZodString;
+    run_id: z.ZodString;
+    twin: z.ZodString;
+    request_id: z.ZodString;
+    correlation_id: z.ZodOptional<z.ZodString>;
+    task_step_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scenario_step_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    step_id: z.ZodNullable<z.ZodString>;
+    tool_call_id: z.ZodNullable<z.ZodString>;
+    method: z.ZodString;
+    path: z.ZodString;
+    request_body: z.ZodUnknown;
+    request_headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    tool: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodNumber;
+    response_body: z.ZodUnknown;
+    latency_ms: z.ZodNumber;
+    fidelity: z.ZodEnum<{
+        semantic: "semantic";
+        unsupported: "unsupported";
+    }>;
+    state_mutation: z.ZodBoolean;
+    state_delta: z.ZodNullable<z.ZodObject<{
+        before: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        after: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    idempotency_dedupe: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodNullable<z.ZodString>;
+    kind: z.ZodLiteral<"TwinHttpEvent">;
+    event_id: z.ZodString;
+    parent_event_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    parent_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"LlmCallEvent">;
+    host: z.ZodString;
+    port: z.ZodNumber;
+    latency_ms: z.ZodNumber;
+    bytes_in: z.ZodNumber;
+    bytes_out: z.ZodNumber;
+    url: z.ZodNullable<z.ZodString>;
+    method: z.ZodNullable<z.ZodString>;
+    status: z.ZodNullable<z.ZodNumber>;
+    model: z.ZodNullable<z.ZodString>;
+    prompt_tokens: z.ZodNullable<z.ZodNumber>;
+    completion_tokens: z.ZodNullable<z.ZodNumber>;
+    cost_usd: z.ZodNullable<z.ZodNumber>;
+    ts: z.ZodString;
+    event_id: z.ZodString;
+    parent_event_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    parent_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"ToolUseEvent">;
+    tool_use_id: z.ZodString;
+    tool_name: z.ZodString;
+    input: z.ZodUnknown;
+    ts: z.ZodString;
+    event_id: z.ZodString;
+    parent_event_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    parent_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>], "kind">;
+export type ShimmableLegacyEvent = z.infer<typeof shimmableLegacyEventSchema>;
+export interface LegacyShimOptions {
+    run_id?: string;
+}
+/**
+ * Translate a single legacy `TwinHttpEvent` / `LlmCallEvent` / `ToolUseEvent`
+ * into a validated `OtelSpanEvent`.
+ *
+ * Throws a typed `ZodError` if `rawRecord` is not one of those three shapes,
+ * or a plain `Error` if an LLM/tool record is missing the required `run_id`.
+ */
+export declare function shimLegacyEventToSpan(rawRecord: unknown, options?: LegacyShimOptions): OtelSpanEvent;

package/dist/_types/wire/otel/map-span.d.ts

@@ -0,0 +1,64 @@
+/**
+ * otel/map-span — pure OTel span → `OtelSpanEvent` mapping (M1.1 / FDRS-480).
+ *
+ * Deterministic: same input → byte-identical event, every run. Has no clock,
+ * no randomness; `ts` is derived from the span's start time.
+ *
+ * Input is a NORMALIZED span: real W3C trace context (lowercase-hex ids) and a
+ * flat `attributes` `Record<string, value>`. Decoding raw OTLP/JSON `AnyValue`
+ * (`{ stringValue }`, kvlist, bytes) and the `[{ key, value }]` attribute array
+ * into this flat record is M2's job (the `@opentelemetry/otlp-transformer`
+ * dependency) — keeping M1.1 free of an OTLP decoder keeps the schema
+ * self-testable.
+ *
+ * Round-trip example:
+ *
+ *   mapOtelSpanToEvent({
+ *     trace_id: "4bf92f3577b34da6a3ce929d0e0e4736",
+ *     span_id: "00f067aa0ba902b7",
+ *     name: "chat google/gemini-2.5-flash",
+ *     start_time_unix_nano: "1700000000000000000",
+ *     attributes: {
+ *       "gen_ai.provider.name": "google",
+ *       "gen_ai.request.model": "gemini-2.5-flash",
+ *       "gen_ai.usage.input_tokens": 42,
+ *     },
+ *   })
+ *   // → { ts: "2023-11-14T22:13:20.000Z", event_id: "00f067aa0ba902b7", … }
+ */
+import { z } from "zod";
+import { type OtelSpanEvent } from "./span-event.js";
+export declare const otelSpanInputSchema: z.ZodObject<{
+    trace_id: z.ZodString;
+    span_id: z.ZodString;
+    parent_span_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodString;
+    kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        UNSPECIFIED: "UNSPECIFIED";
+        INTERNAL: "INTERNAL";
+        SERVER: "SERVER";
+        CLIENT: "CLIENT";
+        PRODUCER: "PRODUCER";
+        CONSUMER: "CONSUMER";
+    }>, z.ZodNumber]>>;
+    start_time_unix_nano: z.ZodString;
+    end_time_unix_nano: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodObject<{
+        code: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            UNSET: "UNSET";
+            OK: "OK";
+            ERROR: "ERROR";
+        }>, z.ZodNumber]>>;
+        message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>>;
+}, z.core.$strip>;
+export type OtelSpanInput = z.infer<typeof otelSpanInputSchema>;
+/**
+ * Map a normalized OTLP span onto a validated `OtelSpanEvent`.
+ *
+ * Throws a `ZodError` (typed; names the offending field) when the input is
+ * malformed — a non-hex `trace_id`, an out-of-range unix-nano, a reversed span
+ * (end < start), a non-finite attribute value, etc.
+ */
+export declare function mapOtelSpanToEvent(rawSpan: unknown): OtelSpanEvent;

package/dist/_types/wire/otel/nano.d.ts

@@ -0,0 +1,26 @@
+/**
+ * otel/nano — uint64 decimal-string arithmetic + nanosecond↔ISO conversion
+ * (M1.1 / FDRS-480).
+ *
+ * OTLP encodes `*_unix_nano` timestamps as uint64 decimal STRINGS because the
+ * values exceed Number.MAX_SAFE_INTEGER. These helpers validate and compare
+ * them WITHOUT `BigInt` — the dashboard compiles this source directly under a
+ * pre-ES2020 target where `BigInt` literals fail to typecheck (review-era
+ * portability fix). Everything here is pure and deterministic.
+ */
+export declare const UINT64_MAX = "18446744073709551615";
+/** True iff `value` is a non-negative decimal integer string within uint64. */
+export declare function isUint64(value: string): boolean;
+/**
+ * Compare two uint64 decimal strings. Returns <0 if a<b, 0 if equal, >0 if a>b.
+ * Assumes both are valid digit strings (callers validate via `isUint64` first).
+ */
+export declare function compareUint64(a: string, b: string): number;
+export declare function msToNanos(millis: number): string;
+/**
+ * uint64 nanoseconds → ISO-8601 (UTC). Floors to milliseconds by dropping the
+ * last 6 decimal digits of the (uint64-validated) integer string. The resulting
+ * ms value is within Date's safe range for any valid uint64, so this never
+ * throws for input that passed `isUint64`. String-slicing avoids `BigInt`.
+ */
+export declare function nanosToIso(unixNano: string): string;

package/dist/_types/wire/otel/project.d.ts

@@ -0,0 +1,42 @@
+/**
+ * otel/project — the single attribute→projection function (M1.1 / FDRS-480).
+ *
+ * The typed `gen_ai_*` / `http_*` / `url_*` / `server_*` / `error_type` fields
+ * on an `OtelSpanEvent` are PROJECTIONS of the verbatim `attributes` bag, never
+ * an independent source of truth. This module is the ONE place that derivation
+ * lives, so:
+ *   - the span mapper (`map-span.ts`) builds projections from `attributes`,
+ *   - the legacy shim (`legacy-shim.ts`) builds them the same way, and
+ *   - the schema (`span-event.ts`) re-derives them in a `superRefine` and
+ *     rejects any event whose typed fields drift from `attributes`
+ *     (review finding #4 — projection drift; finding #7 — centralize).
+ *
+ * Pure and deterministic. Reads only the pinned attribute names from `semconv`.
+ */
+import { z } from "zod";
+export declare const otelAttributeValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+export type OtelAttributeValue = z.infer<typeof otelAttributeValueSchema>;
+export type OtelAttributeBag = Record<string, OtelAttributeValue>;
+export declare const OTEL_PROJECTION_KEYS: readonly ["gen_ai_provider_name", "gen_ai_operation_name", "gen_ai_request_model", "gen_ai_agent_name", "gen_ai_agent_id", "gen_ai_tool_name", "gen_ai_usage_input_tokens", "gen_ai_usage_output_tokens", "http_request_method", "http_response_status_code", "url_full", "url_path", "server_address", "server_port", "error_type"];
+export type OtelProjections = {
+    gen_ai_provider_name: string | null;
+    gen_ai_operation_name: string | null;
+    gen_ai_request_model: string | null;
+    gen_ai_agent_name: string | null;
+    gen_ai_agent_id: string | null;
+    gen_ai_tool_name: string | null;
+    gen_ai_usage_input_tokens: number | null;
+    gen_ai_usage_output_tokens: number | null;
+    http_request_method: string | null;
+    http_response_status_code: number | null;
+    url_full: string | null;
+    url_path: string | null;
+    server_address: string | null;
+    server_port: number | null;
+    error_type: string | null;
+};
+/**
+ * Derive the flat typed projections from a verbatim attribute bag. Canonical
+ * names win; deprecated/pre-1.27 aliases are accepted as fallbacks.
+ */
+export declare function projectAttributes(attributes: OtelAttributeBag): OtelProjections;

package/dist/_types/wire/otel/semconv.d.ts

@@ -0,0 +1,57 @@
+/**
+ * otel/semconv — pinned OpenTelemetry semantic-convention surface (M1.1 / FDRS-480).
+ *
+ * The ONE place an upstream spec change is absorbed. Every attribute name the
+ * span mapper / shim reads is a constant here; the convention versions are
+ * pinned below. When the OTel conventions move, bump the relevant version and
+ * edit the affected constant here — `map-span.ts`, `project.ts`, and the schema
+ * never hard-code an attribute string, so the blast radius is this file.
+ *
+ * Two separate pins, because the GenAI and core/HTTP conventions version
+ * independently (review finding #5 — a single "1.30.0" mislabelled a mixed
+ * surface):
+ *   - `OTEL_CORE_SEMCONV_VERSION` — the stable core conventions (HTTP client
+ *     spans, url.*, server.*, error.type) we project. Pinned to the v1.41.1
+ *     core release.
+ *   - `OTEL_GENAI_SCHEMA_VERSION` — the (still-experimental) GenAI conventions
+ *     (`gen_ai.*`). Pinned to the GenAI schema 1.42.0, which introduces
+ *     `gen_ai.provider.name` and deprecates `gen_ai.system`.
+ *
+ * Provenance for the pins:
+ *   - core:  https://github.com/open-telemetry/semantic-conventions/releases/tag/v1.41.1
+ *   - genai: https://github.com/open-telemetry/semantic-conventions/tree/main/docs/gen-ai
+ *   - http:  https://opentelemetry.io/docs/specs/semconv/http/http-spans/
+ *
+ * This module is the canonical home of the pinned OTel convention surface;
+ * pome-cloud consumes it as part of `@pome-sh/wire` (ownership
+ * boundary settled at FDRS-653 — see `./index.ts`).
+ */
+export declare const OTEL_CORE_SEMCONV_VERSION: "1.41.1";
+export type OtelCoreSemconvVersion = typeof OTEL_CORE_SEMCONV_VERSION;
+export declare const OTEL_GENAI_SCHEMA_VERSION: "1.42.0";
+export type OtelGenaiSchemaVersion = typeof OTEL_GENAI_SCHEMA_VERSION;
+export declare const OTEL_GENAI_SCHEMA_URL: "https://opentelemetry.io/schemas/1.42.0";
+export declare const GEN_AI_PROVIDER_NAME = "gen_ai.provider.name";
+export declare const GEN_AI_SYSTEM_DEPRECATED = "gen_ai.system";
+export declare const GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+export declare const GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+export declare const GEN_AI_AGENT_NAME = "gen_ai.agent.name";
+export declare const GEN_AI_AGENT_ID = "gen_ai.agent.id";
+export declare const GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+export declare const GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+export declare const GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+export declare const GEN_AI_USAGE_PROMPT_TOKENS_LEGACY = "gen_ai.usage.prompt_tokens";
+export declare const GEN_AI_USAGE_COMPLETION_TOKENS_LEGACY = "gen_ai.usage.completion_tokens";
+export declare const OPENINFERENCE_LLM_MODEL_NAME = "llm.model_name";
+export declare const OPENINFERENCE_LLM_PROVIDER = "llm.provider";
+export declare const OPENINFERENCE_LLM_SYSTEM = "llm.system";
+export declare const OPENINFERENCE_LLM_TOKEN_COUNT_PROMPT = "llm.token_count.prompt";
+export declare const OPENINFERENCE_LLM_TOKEN_COUNT_COMPLETION = "llm.token_count.completion";
+export declare const OPENINFERENCE_TOOL_NAME = "tool.name";
+export declare const HTTP_REQUEST_METHOD = "http.request.method";
+export declare const HTTP_RESPONSE_STATUS_CODE = "http.response.status_code";
+export declare const URL_FULL = "url.full";
+export declare const URL_PATH = "url.path";
+export declare const SERVER_ADDRESS = "server.address";
+export declare const SERVER_PORT = "server.port";
+export declare const ERROR_TYPE = "error.type";

package/dist/_types/wire/otel/span-event.d.ts

@@ -0,0 +1,198 @@
+/**
+ * otel/span-event — the `OtelSpanEvent` Zod schema (M1.1 / FDRS-480).
+ *
+ * The canonical internal representation of a single OpenTelemetry span, mapped
+ * onto Pome's event union. From M1 on, OTel spans are the canonical model;
+ * legacy `TwinHttpEvent` / `LlmCallEvent` / `ToolUseEvent` rows are shimmed *up*
+ * into this shape (M1.2). `OtelSpanEvent` is a non-breaking `kind` extension of
+ * the event union (composed in `./event-schema.ts`, cloud-only).
+ *
+ * Invariants enforced (review finding #4 — the schema was too weak):
+ *   - `*_unix_nano` are uint64 decimal strings WITHIN range (no overflow that
+ *     could throw a RangeError downstream).
+ *   - IDs are real W3C trace context (32-/16-char lowercase hex, non-zero) OR
+ *     an explicit `legacy:<source-id>` (the shim's namespace). Nothing else.
+ *   - `end_time_unix_nano >= start_time_unix_nano` (no reversed spans).
+ *   - `event_id === span_id` and `parent_id === parent_span_id` (the base
+ *     event-union chain mirrors span context).
+ *   - `ts` is exactly `nanosToIso(start_time_unix_nano)`.
+ *   - the typed `gen_ai_*` / `http_*` / `url_*` / `server_*` / `error_type`
+ *     fields EQUAL `projectAttributes(attributes)` — they are projections of
+ *     the verbatim bag and cannot drift from it.
+ *
+ * Field conventions: snake_case, flat. `attributes` holds the FULL verbatim
+ * attribute bag; the typed fields above are projections of it (see `project.ts`).
+ */
+import { z } from "zod";
+export declare const OTEL_SPAN_KINDS: readonly ["UNSPECIFIED", "INTERNAL", "SERVER", "CLIENT", "PRODUCER", "CONSUMER"];
+export declare const otelSpanKindSchema: z.ZodEnum<{
+    UNSPECIFIED: "UNSPECIFIED";
+    INTERNAL: "INTERNAL";
+    SERVER: "SERVER";
+    CLIENT: "CLIENT";
+    PRODUCER: "PRODUCER";
+    CONSUMER: "CONSUMER";
+}>;
+export type OtelSpanKind = z.infer<typeof otelSpanKindSchema>;
+export declare const OTEL_STATUS_CODES: readonly ["UNSET", "OK", "ERROR"];
+export declare const otelStatusCodeSchema: z.ZodEnum<{
+    UNSET: "UNSET";
+    OK: "OK";
+    ERROR: "ERROR";
+}>;
+export type OtelStatusCode = z.infer<typeof otelStatusCodeSchema>;
+export declare const unixNanoSchema: z.ZodString;
+export declare const w3cTraceIdSchema: z.ZodString;
+export declare const w3cSpanIdSchema: z.ZodString;
+export declare const canonicalTraceIdSchema: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+export declare const canonicalSpanIdSchema: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+declare const otelSpanEventObjectSchema: z.ZodObject<{
+    ts: z.ZodString;
+    event_id: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    parent_event_id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>>;
+    parent_id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>>;
+    kind: z.ZodLiteral<"OtelSpanEvent">;
+    trace_id: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    span_id: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    parent_span_id: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    name: z.ZodString;
+    span_kind: z.ZodEnum<{
+        UNSPECIFIED: "UNSPECIFIED";
+        INTERNAL: "INTERNAL";
+        SERVER: "SERVER";
+        CLIENT: "CLIENT";
+        PRODUCER: "PRODUCER";
+        CONSUMER: "CONSUMER";
+    }>;
+    start_time_unix_nano: z.ZodString;
+    end_time_unix_nano: z.ZodNullable<z.ZodString>;
+    status_code: z.ZodEnum<{
+        UNSET: "UNSET";
+        OK: "OK";
+        ERROR: "ERROR";
+    }>;
+    status_message: z.ZodNullable<z.ZodString>;
+    gen_ai_provider_name: z.ZodNullable<z.ZodString>;
+    gen_ai_operation_name: z.ZodNullable<z.ZodString>;
+    gen_ai_request_model: z.ZodNullable<z.ZodString>;
+    gen_ai_agent_name: z.ZodNullable<z.ZodString>;
+    gen_ai_agent_id: z.ZodNullable<z.ZodString>;
+    gen_ai_tool_name: z.ZodNullable<z.ZodString>;
+    gen_ai_usage_input_tokens: z.ZodNullable<z.ZodNumber>;
+    gen_ai_usage_output_tokens: z.ZodNullable<z.ZodNumber>;
+    http_request_method: z.ZodNullable<z.ZodString>;
+    http_response_status_code: z.ZodNullable<z.ZodNumber>;
+    url_full: z.ZodNullable<z.ZodString>;
+    url_path: z.ZodNullable<z.ZodString>;
+    server_address: z.ZodNullable<z.ZodString>;
+    server_port: z.ZodNullable<z.ZodNumber>;
+    error_type: z.ZodNullable<z.ZodString>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>;
+}, z.core.$strip>;
+export declare const otelSpanEventSchema: z.ZodPipe<z.ZodObject<{
+    ts: z.ZodString;
+    event_id: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    parent_event_id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>>;
+    parent_id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>>;
+    kind: z.ZodLiteral<"OtelSpanEvent">;
+    trace_id: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    span_id: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    parent_span_id: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    name: z.ZodString;
+    span_kind: z.ZodEnum<{
+        UNSPECIFIED: "UNSPECIFIED";
+        INTERNAL: "INTERNAL";
+        SERVER: "SERVER";
+        CLIENT: "CLIENT";
+        PRODUCER: "PRODUCER";
+        CONSUMER: "CONSUMER";
+    }>;
+    start_time_unix_nano: z.ZodString;
+    end_time_unix_nano: z.ZodNullable<z.ZodString>;
+    status_code: z.ZodEnum<{
+        UNSET: "UNSET";
+        OK: "OK";
+        ERROR: "ERROR";
+    }>;
+    status_message: z.ZodNullable<z.ZodString>;
+    gen_ai_provider_name: z.ZodNullable<z.ZodString>;
+    gen_ai_operation_name: z.ZodNullable<z.ZodString>;
+    gen_ai_request_model: z.ZodNullable<z.ZodString>;
+    gen_ai_agent_name: z.ZodNullable<z.ZodString>;
+    gen_ai_agent_id: z.ZodNullable<z.ZodString>;
+    gen_ai_tool_name: z.ZodNullable<z.ZodString>;
+    gen_ai_usage_input_tokens: z.ZodNullable<z.ZodNumber>;
+    gen_ai_usage_output_tokens: z.ZodNullable<z.ZodNumber>;
+    http_request_method: z.ZodNullable<z.ZodString>;
+    http_response_status_code: z.ZodNullable<z.ZodNumber>;
+    url_full: z.ZodNullable<z.ZodString>;
+    url_path: z.ZodNullable<z.ZodString>;
+    server_address: z.ZodNullable<z.ZodString>;
+    server_port: z.ZodNullable<z.ZodNumber>;
+    error_type: z.ZodNullable<z.ZodString>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>;
+}, z.core.$strip>, z.ZodTransform<{
+    parent_event_id: string | null;
+    ts: string;
+    event_id: string;
+    kind: "OtelSpanEvent";
+    trace_id: string;
+    span_id: string;
+    parent_span_id: string | null;
+    name: string;
+    span_kind: "UNSPECIFIED" | "INTERNAL" | "SERVER" | "CLIENT" | "PRODUCER" | "CONSUMER";
+    start_time_unix_nano: string;
+    end_time_unix_nano: string | null;
+    status_code: "UNSET" | "OK" | "ERROR";
+    status_message: string | null;
+    gen_ai_provider_name: string | null;
+    gen_ai_operation_name: string | null;
+    gen_ai_request_model: string | null;
+    gen_ai_agent_name: string | null;
+    gen_ai_agent_id: string | null;
+    gen_ai_tool_name: string | null;
+    gen_ai_usage_input_tokens: number | null;
+    gen_ai_usage_output_tokens: number | null;
+    http_request_method: string | null;
+    http_response_status_code: number | null;
+    url_full: string | null;
+    url_path: string | null;
+    server_address: string | null;
+    server_port: number | null;
+    error_type: string | null;
+    attributes: Record<string, string | number | boolean | (string | number | boolean)[]>;
+    parent_id?: string | null | undefined;
+}, {
+    ts: string;
+    event_id: string;
+    kind: "OtelSpanEvent";
+    trace_id: string;
+    span_id: string;
+    parent_span_id: string | null;
+    name: string;
+    span_kind: "UNSPECIFIED" | "INTERNAL" | "SERVER" | "CLIENT" | "PRODUCER" | "CONSUMER";
+    start_time_unix_nano: string;
+    end_time_unix_nano: string | null;
+    status_code: "UNSET" | "OK" | "ERROR";
+    status_message: string | null;
+    gen_ai_provider_name: string | null;
+    gen_ai_operation_name: string | null;
+    gen_ai_request_model: string | null;
+    gen_ai_agent_name: string | null;
+    gen_ai_agent_id: string | null;
+    gen_ai_tool_name: string | null;
+    gen_ai_usage_input_tokens: number | null;
+    gen_ai_usage_output_tokens: number | null;
+    http_request_method: string | null;
+    http_response_status_code: number | null;
+    url_full: string | null;
+    url_path: string | null;
+    server_address: string | null;
+    server_port: number | null;
+    error_type: string | null;
+    attributes: Record<string, string | number | boolean | (string | number | boolean)[]>;
+    parent_event_id?: string | null | undefined;
+    parent_id?: string | null | undefined;
+}>>;
+export type OtelSpanEvent = z.infer<typeof otelSpanEventObjectSchema>;
+export {};