@kopai/core 0.0.0

package/dist/index.mjs

@@ -0,0 +1,971 @@
+import { t as __exportAll } from "./chunk-Bo1DHCg-.mjs";
+import z$1, { z } from "zod";
+
+//#region src/denormalized-signals-zod.ts
+var denormalized_signals_zod_exports = /* @__PURE__ */ __exportAll({
+	otelExponentialHistogramSchema: () => otelExponentialHistogramSchema,
+	otelGaugeSchema: () => otelGaugeSchema,
+	otelHistogramSchema: () => otelHistogramSchema,
+	otelLogsSchema: () => otelLogsSchema,
+	otelMetricsSchema: () => otelMetricsSchema,
+	otelSumSchema: () => otelSumSchema,
+	otelSummarySchema: () => otelSummarySchema,
+	otelTracesSchema: () => otelTracesSchema
+});
+const attributeValue = z.union([
+	z.string(),
+	z.number(),
+	z.boolean()
+]);
+const otelTracesSchema = z.object({
+	SpanId: z.string().describe("Unique identifier for a span within a trace. The ID is an 8-byte array."),
+	Timestamp: z.string().describe("Start time of the span. UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970. Expressed as string in JSON."),
+	TraceId: z.string().describe("Unique identifier for a trace. All spans from the same trace share the same trace_id. The ID is a 16-byte array."),
+	Duration: z.string().optional().describe("Duration of the span in nanoseconds (end_time - start_time). Expressed as string in JSON."),
+	"Events.Attributes": z.array(z.record(z.string(), attributeValue)).optional().describe("Attribute key/value pairs on the event (one object per event)."),
+	"Events.Name": z.array(z.string()).optional().describe("Name of the event. Semantically required to be non-empty."),
+	"Events.Timestamp": z.array(z.string()).optional().describe("Time the event occurred (nanoseconds). Expressed as strings in JSON."),
+	"Links.Attributes": z.array(z.record(z.string(), attributeValue)).optional().describe("Attribute key/value pairs on the link (one object per link)."),
+	"Links.SpanId": z.array(z.string()).optional().describe("Unique identifier for the linked span. The ID is an 8-byte array."),
+	"Links.TraceId": z.array(z.string()).optional().describe("Unique identifier of a trace that the linked span is part of. The ID is a 16-byte array."),
+	"Links.TraceState": z.array(z.string()).optional().describe("The trace_state associated with the link."),
+	ParentSpanId: z.string().optional().describe("The span_id of this span's parent span. Empty if this is a root span."),
+	ResourceAttributes: z.record(z.string(), attributeValue).optional().describe("Attributes that describe the resource."),
+	ScopeName: z.string().optional().describe("Name denoting the instrumentation scope."),
+	ScopeVersion: z.string().optional().describe("Version of the instrumentation scope."),
+	ServiceName: z.string().optional().describe("Service name from resource attributes (service.name)."),
+	SpanAttributes: z.record(z.string(), attributeValue).optional().describe("Key/value pairs describing the span."),
+	SpanKind: z.string().optional().describe("Type of span (INTERNAL, SERVER, CLIENT, PRODUCER, CONSUMER). Used to identify relationships between spans."),
+	SpanName: z.string().optional().describe("Description of the span's operation. E.g., qualified method name or file name with line number."),
+	StatusCode: z.string().optional().describe("Status code (UNSET, OK, ERROR)."),
+	StatusMessage: z.string().optional().describe("Developer-facing human readable error message."),
+	TraceState: z.string().optional().describe("Conveys information about request position in multiple distributed tracing graphs. W3C trace-context format.")
+});
+const otelLogsSchema = z.object({
+	Timestamp: z.string().describe("Time when the event occurred. UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970. Expressed as string in JSON."),
+	Body: z.string().optional().describe("Body of the log record. Can be a human-readable string message or structured data."),
+	LogAttributes: z.record(z.string(), attributeValue).optional().describe("Additional attributes that describe the specific event occurrence."),
+	ResourceAttributes: z.record(z.string(), attributeValue).optional().describe("Attributes that describe the resource."),
+	ResourceSchemaUrl: z.string().optional().describe("Schema URL for the resource data."),
+	ScopeAttributes: z.record(z.string(), attributeValue).optional().describe("Attributes of the instrumentation scope."),
+	ScopeName: z.string().optional().describe("Name denoting the instrumentation scope."),
+	ScopeSchemaUrl: z.string().optional().describe("Schema URL for the scope data."),
+	ScopeVersion: z.string().optional().describe("Version of the instrumentation scope."),
+	ServiceName: z.string().optional().describe("Service name from resource attributes (service.name)."),
+	SeverityNumber: z.number().optional().describe("Numerical value of the severity, normalized to values described in Log Data Model."),
+	SeverityText: z.string().optional().describe("Severity text (also known as log level). Original string representation as known at the source."),
+	SpanId: z.string().optional().describe("Unique identifier for a span within a trace. The ID is an 8-byte array."),
+	TraceFlags: z.number().optional().describe("Bit field. 8 least significant bits are trace flags as defined in W3C Trace Context."),
+	TraceId: z.string().optional().describe("Unique identifier for a trace. All logs from the same trace share the same trace_id. The ID is a 16-byte array.")
+});
+const metricsBaseSchema = z.object({
+	TimeUnix: z.string().describe("Time when the data point was recorded. UNIX Epoch time in nanoseconds. Expressed as string in JSON."),
+	StartTimeUnix: z.string().describe("Start time for cumulative/delta metrics. UNIX Epoch time in nanoseconds. Expressed as string in JSON."),
+	Attributes: z.record(z.string(), attributeValue).optional().describe("Key/value pairs that uniquely identify the timeseries."),
+	MetricName: z.string().optional().describe("The name of the metric."),
+	MetricDescription: z.string().optional().describe("A description of the metric, which can be used in documentation."),
+	MetricUnit: z.string().optional().describe("The unit in which the metric value is reported (UCUM format)."),
+	ResourceAttributes: z.record(z.string(), attributeValue).optional().describe("Attributes that describe the resource."),
+	ResourceSchemaUrl: z.string().optional().describe("Schema URL for the resource data."),
+	ScopeAttributes: z.record(z.string(), attributeValue).optional().describe("Attributes of the instrumentation scope."),
+	ScopeDroppedAttrCount: z.number().optional().describe("Number of attributes dropped from the scope."),
+	ScopeName: z.string().optional().describe("Name denoting the instrumentation scope."),
+	ScopeSchemaUrl: z.string().optional().describe("Schema URL for the scope data."),
+	ScopeVersion: z.string().optional().describe("Version of the instrumentation scope."),
+	ServiceName: z.string().optional().describe("Service name from resource attributes (service.name)."),
+	"Exemplars.FilteredAttributes": z.array(z.record(z.string(), attributeValue)).optional().describe("Filtered attributes of exemplars."),
+	"Exemplars.SpanId": z.array(z.string()).optional().describe("Span IDs associated with exemplars."),
+	"Exemplars.TimeUnix": z.array(z.string()).optional().describe("Timestamps of exemplars (nanoseconds). Expressed as strings in JSON."),
+	"Exemplars.TraceId": z.array(z.string()).optional().describe("Trace IDs associated with exemplars."),
+	"Exemplars.Value": z.array(z.number()).optional().describe("Values of exemplars.")
+});
+const otelGaugeSchema = metricsBaseSchema.extend({
+	MetricType: z.literal("Gauge").describe("Gauge metric type."),
+	Value: z.number().describe("Current scalar value."),
+	Flags: z.number().optional().describe("Flags that apply to this data point (see DataPointFlags).")
+});
+const otelSumSchema = metricsBaseSchema.extend({
+	MetricType: z.literal("Sum").describe("Sum metric type."),
+	Value: z.number().describe("Scalar sum value."),
+	Flags: z.number().optional().describe("Flags that apply to this data point (see DataPointFlags)."),
+	AggTemporality: z.string().optional().describe("Aggregation temporality (DELTA or CUMULATIVE)."),
+	IsMonotonic: z.number().optional().describe("Whether the sum is monotonic (0 = false, 1 = true).")
+});
+const otelHistogramSchema = metricsBaseSchema.extend({
+	MetricType: z.literal("Histogram").describe("Histogram metric type."),
+	Count: z.number().optional().describe("Number of values in the histogram."),
+	Sum: z.number().optional().describe("Sum of all values."),
+	Min: z.number().nullable().optional().describe("Minimum value recorded."),
+	Max: z.number().nullable().optional().describe("Maximum value recorded."),
+	BucketCounts: z.array(z.number()).optional().describe("Count of values in each bucket."),
+	ExplicitBounds: z.array(z.number()).optional().describe("Bucket boundaries."),
+	AggTemporality: z.string().optional().describe("Aggregation temporality (DELTA or CUMULATIVE).")
+});
+const otelExponentialHistogramSchema = metricsBaseSchema.extend({
+	MetricType: z.literal("ExponentialHistogram").describe("Exponential histogram metric type."),
+	Count: z.number().optional().describe("Number of values in the histogram."),
+	Sum: z.number().optional().describe("Sum of all values."),
+	Min: z.number().nullable().optional().describe("Minimum value recorded."),
+	Max: z.number().nullable().optional().describe("Maximum value recorded."),
+	Scale: z.number().optional().describe("Resolution of the histogram. Boundaries are at powers of base."),
+	ZeroCount: z.number().optional().describe("Count of values that are exactly zero."),
+	PositiveBucketCounts: z.array(z.number()).optional().describe("Counts for positive value buckets."),
+	PositiveOffset: z.number().optional().describe("Offset for positive bucket indices."),
+	NegativeBucketCounts: z.array(z.number()).optional().describe("Counts for negative value buckets."),
+	NegativeOffset: z.number().optional().describe("Offset for negative bucket indices."),
+	AggTemporality: z.string().optional().describe("Aggregation temporality (DELTA or CUMULATIVE).")
+});
+const otelSummarySchema = metricsBaseSchema.extend({
+	MetricType: z.literal("Summary").describe("Summary metric type."),
+	Count: z.number().optional().describe("Number of values in the summary."),
+	Sum: z.number().optional().describe("Sum of all values."),
+	"ValueAtQuantiles.Quantile": z.array(z.number()).optional().describe("Quantile values (0.0 to 1.0)."),
+	"ValueAtQuantiles.Value": z.array(z.number()).optional().describe("Values at each quantile.")
+});
+const otelMetricsSchema = z.discriminatedUnion("MetricType", [
+	otelGaugeSchema,
+	otelSumSchema,
+	otelHistogramSchema,
+	otelExponentialHistogramSchema,
+	otelSummarySchema
+]);
+
+//#endregion
+//#region src/telemetry-datasource.ts
+var telemetry_datasource_exports = {};
+
+//#endregion
+//#region src/otlp-generated.ts
+var otlp_generated_exports = /* @__PURE__ */ __exportAll({
+	AggregationTemporality: () => AggregationTemporality,
+	DataPointFlags: () => DataPointFlags,
+	LogRecordFlags: () => LogRecordFlags,
+	SeverityNumber: () => SeverityNumber,
+	SpanFlags: () => SpanFlags,
+	SpanKind: () => SpanKind,
+	StatusCode: () => StatusCode
+});
+/**
+* SpanFlags represents constants used to interpret the
+* Span.flags field, which is protobuf 'fixed32' type and is to
+* be used as bit-fields. Each non-zero value defined in this enum is
+* a bit-mask.  To extract the bit-field, for example, use an
+* expression like:
+*
+*   (span.flags & SPAN_FLAGS_TRACE_FLAGS_MASK)
+*
+* See https://www.w3.org/TR/trace-context-2/#trace-flags for the flag definitions.
+*
+* Note that Span flags were introduced in version 1.1 of the
+* OpenTelemetry protocol.  Older Span producers do not set this
+* field, consequently consumers should not rely on the absence of a
+* particular flag bit to indicate the presence of a particular feature.
+*/
+let SpanFlags = /* @__PURE__ */ function(SpanFlags) {
+	/**
+	* SPAN_FLAGS_DO_NOT_USE - The zero value for the enum. Should not be used for comparisons.
+	* Instead use bitwise "and" with the appropriate mask as shown above.
+	*/
+	SpanFlags[SpanFlags["SPAN_FLAGS_DO_NOT_USE"] = 0] = "SPAN_FLAGS_DO_NOT_USE";
+	/** SPAN_FLAGS_TRACE_FLAGS_MASK - Bits 0-7 are used for trace flags. */
+	SpanFlags[SpanFlags["SPAN_FLAGS_TRACE_FLAGS_MASK"] = 255] = "SPAN_FLAGS_TRACE_FLAGS_MASK";
+	/**
+	* SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK - Bits 8 and 9 are used to indicate that the parent span or link span is remote.
+	* Bit 8 (`HAS_IS_REMOTE`) indicates whether the value is known.
+	* Bit 9 (`IS_REMOTE`) indicates whether the span or link is remote.
+	*/
+	SpanFlags[SpanFlags["SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK"] = 256] = "SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK";
+	SpanFlags[SpanFlags["SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK"] = 512] = "SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK";
+	SpanFlags[SpanFlags["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return SpanFlags;
+}({});
+/**
+* SpanKind is the type of span. Can be used to specify additional relationships between spans
+* in addition to a parent/child relationship.
+*/
+let SpanKind = /* @__PURE__ */ function(SpanKind) {
+	/**
+	* SPAN_KIND_UNSPECIFIED - Unspecified. Do NOT use as default.
+	* Implementations MAY assume SpanKind to be INTERNAL when receiving UNSPECIFIED.
+	*/
+	SpanKind[SpanKind["SPAN_KIND_UNSPECIFIED"] = 0] = "SPAN_KIND_UNSPECIFIED";
+	/**
+	* SPAN_KIND_INTERNAL - Indicates that the span represents an internal operation within an application,
+	* as opposed to an operation happening at the boundaries. Default value.
+	*/
+	SpanKind[SpanKind["SPAN_KIND_INTERNAL"] = 1] = "SPAN_KIND_INTERNAL";
+	/**
+	* SPAN_KIND_SERVER - Indicates that the span covers server-side handling of an RPC or other
+	* remote network request.
+	*/
+	SpanKind[SpanKind["SPAN_KIND_SERVER"] = 2] = "SPAN_KIND_SERVER";
+	/** SPAN_KIND_CLIENT - Indicates that the span describes a request to some remote service. */
+	SpanKind[SpanKind["SPAN_KIND_CLIENT"] = 3] = "SPAN_KIND_CLIENT";
+	/**
+	* SPAN_KIND_PRODUCER - Indicates that the span describes a producer sending a message to a broker.
+	* Unlike CLIENT and SERVER, there is often no direct critical path latency relationship
+	* between producer and consumer spans. A PRODUCER span ends when the message was accepted
+	* by the broker while the logical processing of the message might span a much longer time.
+	*/
+	SpanKind[SpanKind["SPAN_KIND_PRODUCER"] = 4] = "SPAN_KIND_PRODUCER";
+	/**
+	* SPAN_KIND_CONSUMER - Indicates that the span describes consumer receiving a message from a broker.
+	* Like the PRODUCER kind, there is often no direct critical path latency relationship
+	* between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["SPAN_KIND_CONSUMER"] = 5] = "SPAN_KIND_CONSUMER";
+	SpanKind[SpanKind["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return SpanKind;
+}({});
+/**
+* For the semantics of status codes see
+* https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#set-status
+*/
+let StatusCode = /* @__PURE__ */ function(StatusCode) {
+	/** STATUS_CODE_UNSET - The default status. */
+	StatusCode[StatusCode["STATUS_CODE_UNSET"] = 0] = "STATUS_CODE_UNSET";
+	/**
+	* STATUS_CODE_OK - The Span has been validated by an Application developer or Operator to
+	* have completed successfully.
+	*/
+	StatusCode[StatusCode["STATUS_CODE_OK"] = 1] = "STATUS_CODE_OK";
+	/** STATUS_CODE_ERROR - The Span contains an error. */
+	StatusCode[StatusCode["STATUS_CODE_ERROR"] = 2] = "STATUS_CODE_ERROR";
+	StatusCode[StatusCode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return StatusCode;
+}({});
+/** Possible values for LogRecord.SeverityNumber. */
+let SeverityNumber = /* @__PURE__ */ function(SeverityNumber) {
+	/** SEVERITY_NUMBER_UNSPECIFIED - UNSPECIFIED is the default SeverityNumber, it MUST NOT be used. */
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_UNSPECIFIED"] = 0] = "SEVERITY_NUMBER_UNSPECIFIED";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_TRACE"] = 1] = "SEVERITY_NUMBER_TRACE";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_TRACE2"] = 2] = "SEVERITY_NUMBER_TRACE2";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_TRACE3"] = 3] = "SEVERITY_NUMBER_TRACE3";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_TRACE4"] = 4] = "SEVERITY_NUMBER_TRACE4";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_DEBUG"] = 5] = "SEVERITY_NUMBER_DEBUG";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_DEBUG2"] = 6] = "SEVERITY_NUMBER_DEBUG2";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_DEBUG3"] = 7] = "SEVERITY_NUMBER_DEBUG3";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_DEBUG4"] = 8] = "SEVERITY_NUMBER_DEBUG4";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_INFO"] = 9] = "SEVERITY_NUMBER_INFO";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_INFO2"] = 10] = "SEVERITY_NUMBER_INFO2";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_INFO3"] = 11] = "SEVERITY_NUMBER_INFO3";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_INFO4"] = 12] = "SEVERITY_NUMBER_INFO4";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_WARN"] = 13] = "SEVERITY_NUMBER_WARN";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_WARN2"] = 14] = "SEVERITY_NUMBER_WARN2";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_WARN3"] = 15] = "SEVERITY_NUMBER_WARN3";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_WARN4"] = 16] = "SEVERITY_NUMBER_WARN4";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_ERROR"] = 17] = "SEVERITY_NUMBER_ERROR";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_ERROR2"] = 18] = "SEVERITY_NUMBER_ERROR2";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_ERROR3"] = 19] = "SEVERITY_NUMBER_ERROR3";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_ERROR4"] = 20] = "SEVERITY_NUMBER_ERROR4";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_FATAL"] = 21] = "SEVERITY_NUMBER_FATAL";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_FATAL2"] = 22] = "SEVERITY_NUMBER_FATAL2";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_FATAL3"] = 23] = "SEVERITY_NUMBER_FATAL3";
+	SeverityNumber[SeverityNumber["SEVERITY_NUMBER_FATAL4"] = 24] = "SEVERITY_NUMBER_FATAL4";
+	SeverityNumber[SeverityNumber["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return SeverityNumber;
+}({});
+/**
+* LogRecordFlags represents constants used to interpret the
+* LogRecord.flags field, which is protobuf 'fixed32' type and is to
+* be used as bit-fields. Each non-zero value defined in this enum is
+* a bit-mask.  To extract the bit-field, for example, use an
+* expression like:
+*
+*   (logRecord.flags & LOG_RECORD_FLAGS_TRACE_FLAGS_MASK)
+*/
+let LogRecordFlags = /* @__PURE__ */ function(LogRecordFlags) {
+	/**
+	* LOG_RECORD_FLAGS_DO_NOT_USE - The zero value for the enum. Should not be used for comparisons.
+	* Instead use bitwise "and" with the appropriate mask as shown above.
+	*/
+	LogRecordFlags[LogRecordFlags["LOG_RECORD_FLAGS_DO_NOT_USE"] = 0] = "LOG_RECORD_FLAGS_DO_NOT_USE";
+	/** LOG_RECORD_FLAGS_TRACE_FLAGS_MASK - Bits 0-7 are used for trace flags. */
+	LogRecordFlags[LogRecordFlags["LOG_RECORD_FLAGS_TRACE_FLAGS_MASK"] = 255] = "LOG_RECORD_FLAGS_TRACE_FLAGS_MASK";
+	LogRecordFlags[LogRecordFlags["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return LogRecordFlags;
+}({});
+/**
+* AggregationTemporality defines how a metric aggregator reports aggregated
+* values. It describes how those values relate to the time interval over
+* which they are aggregated.
+*/
+let AggregationTemporality = /* @__PURE__ */ function(AggregationTemporality) {
+	/** AGGREGATION_TEMPORALITY_UNSPECIFIED - UNSPECIFIED is the default AggregationTemporality, it MUST not be used. */
+	AggregationTemporality[AggregationTemporality["AGGREGATION_TEMPORALITY_UNSPECIFIED"] = 0] = "AGGREGATION_TEMPORALITY_UNSPECIFIED";
+	/**
+	* AGGREGATION_TEMPORALITY_DELTA - DELTA is an AggregationTemporality for a metric aggregator which reports
+	* changes since last report time. Successive metrics contain aggregation of
+	* values from continuous and non-overlapping intervals.
+	*
+	* The values for a DELTA metric are based only on the time interval
+	* associated with one measurement cycle. There is no dependency on
+	* previous measurements like is the case for CUMULATIVE metrics.
+	*
+	* For example, consider a system measuring the number of requests that
+	* it receives and reports the sum of these requests every second as a
+	* DELTA metric:
+	*
+	*   1. The system starts receiving at time=t_0.
+	*   2. A request is received, the system measures 1 request.
+	*   3. A request is received, the system measures 1 request.
+	*   4. A request is received, the system measures 1 request.
+	*   5. The 1 second collection cycle ends. A metric is exported for the
+	*      number of requests received over the interval of time t_0 to
+	*      t_0+1 with a value of 3.
+	*   6. A request is received, the system measures 1 request.
+	*   7. A request is received, the system measures 1 request.
+	*   8. The 1 second collection cycle ends. A metric is exported for the
+	*      number of requests received over the interval of time t_0+1 to
+	*      t_0+2 with a value of 2.
+	*/
+	AggregationTemporality[AggregationTemporality["AGGREGATION_TEMPORALITY_DELTA"] = 1] = "AGGREGATION_TEMPORALITY_DELTA";
+	/**
+	* AGGREGATION_TEMPORALITY_CUMULATIVE - CUMULATIVE is an AggregationTemporality for a metric aggregator which
+	* reports changes since a fixed start time. This means that current values
+	* of a CUMULATIVE metric depend on all previous measurements since the
+	* start time. Because of this, the sender is required to retain this state
+	* in some form. If this state is lost or invalidated, the CUMULATIVE metric
+	* values MUST be reset and a new fixed start time following the last
+	* reported measurement time sent MUST be used.
+	*
+	* For example, consider a system measuring the number of requests that
+	* it receives and reports the sum of these requests every second as a
+	* CUMULATIVE metric:
+	*
+	*   1. The system starts receiving at time=t_0.
+	*   2. A request is received, the system measures 1 request.
+	*   3. A request is received, the system measures 1 request.
+	*   4. A request is received, the system measures 1 request.
+	*   5. The 1 second collection cycle ends. A metric is exported for the
+	*      number of requests received over the interval of time t_0 to
+	*      t_0+1 with a value of 3.
+	*   6. A request is received, the system measures 1 request.
+	*   7. A request is received, the system measures 1 request.
+	*   8. The 1 second collection cycle ends. A metric is exported for the
+	*      number of requests received over the interval of time t_0 to
+	*      t_0+2 with a value of 5.
+	*   9. The system experiences a fault and loses state.
+	*   10. The system recovers and resumes receiving at time=t_1.
+	*   11. A request is received, the system measures 1 request.
+	*   12. The 1 second collection cycle ends. A metric is exported for the
+	*      number of requests received over the interval of time t_1 to
+	*      t_0+1 with a value of 1.
+	*
+	* Note: Even though, when reporting changes since last report time, using
+	* CUMULATIVE is valid, it is not recommended. This may cause problems for
+	* systems that do not use start_time to determine when the aggregation
+	* value was reset (e.g. Prometheus).
+	*/
+	AggregationTemporality[AggregationTemporality["AGGREGATION_TEMPORALITY_CUMULATIVE"] = 2] = "AGGREGATION_TEMPORALITY_CUMULATIVE";
+	AggregationTemporality[AggregationTemporality["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return AggregationTemporality;
+}({});
+/**
+* DataPointFlags is defined as a protobuf 'uint32' type and is to be used as a
+* bit-field representing 32 distinct boolean flags.  Each flag defined in this
+* enum is a bit-mask.  To test the presence of a single flag in the flags of
+* a data point, for example, use an expression like:
+*
+*   (point.flags & DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK) == DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK
+*/
+let DataPointFlags = /* @__PURE__ */ function(DataPointFlags) {
+	/**
+	* DATA_POINT_FLAGS_DO_NOT_USE - The zero value for the enum. Should not be used for comparisons.
+	* Instead use bitwise "and" with the appropriate mask as shown above.
+	*/
+	DataPointFlags[DataPointFlags["DATA_POINT_FLAGS_DO_NOT_USE"] = 0] = "DATA_POINT_FLAGS_DO_NOT_USE";
+	/**
+	* DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK - This DataPoint is valid but has no recorded value.  This value
+	* SHOULD be used to reflect explicitly missing data in a series, as
+	* for an equivalent to the Prometheus "staleness marker".
+	*/
+	DataPointFlags[DataPointFlags["DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK"] = 1] = "DATA_POINT_FLAGS_NO_RECORDED_VALUE_MASK";
+	DataPointFlags[DataPointFlags["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+	return DataPointFlags;
+}({});
+
+//#endregion
+//#region src/otlp-metrics-generated.ts
+var otlp_metrics_generated_exports = {};
+
+//#endregion
+//#region src/otlp-zod.ts
+var otlp_zod_exports = /* @__PURE__ */ __exportAll({
+	aggregationTemporalitySchema: () => aggregationTemporalitySchema,
+	anyValueSchema: () => anyValueSchema,
+	arrayValueSchema: () => arrayValueSchema,
+	dataPointFlagsSchema: () => dataPointFlagsSchema,
+	entityRefSchema: () => entityRefSchema,
+	exponentialHistogramDataPointBucketsSchema: () => exponentialHistogramDataPointBucketsSchema$1,
+	instrumentationScopeSchema: () => instrumentationScopeSchema,
+	keyValueListSchema: () => keyValueListSchema,
+	keyValueSchema: () => keyValueSchema,
+	logRecordFlagsSchema: () => logRecordFlagsSchema,
+	logRecordSchema: () => logRecordSchema,
+	logsDataSchema: () => logsDataSchema,
+	resourceLogsSchema: () => resourceLogsSchema,
+	resourceSchema: () => resourceSchema,
+	resourceSpansSchema: () => resourceSpansSchema,
+	scopeLogsSchema: () => scopeLogsSchema,
+	scopeSpansSchema: () => scopeSpansSchema,
+	severityNumberSchema: () => severityNumberSchema,
+	spanEventSchema: () => spanEventSchema,
+	spanFlagsSchema: () => spanFlagsSchema,
+	spanKindSchema: () => spanKindSchema,
+	spanLinkSchema: () => spanLinkSchema,
+	spanSchema: () => spanSchema,
+	statusCodeSchema: () => statusCodeSchema,
+	statusSchema: () => statusSchema,
+	summaryDataPointSchema: () => summaryDataPointSchema$1,
+	summaryDataPointValueAtQuantileSchema: () => summaryDataPointValueAtQuantileSchema$1,
+	summarySchema: () => summarySchema$1,
+	tracesDataSchema: () => tracesDataSchema
+});
+const entityRefSchema = z.object({
+	schemaUrl: z.union([z.string(), z.undefined()]).optional(),
+	type: z.union([z.string(), z.undefined()]).optional(),
+	idKeys: z.union([z.array(z.string()), z.undefined()]).optional(),
+	descriptionKeys: z.union([z.array(z.string()), z.undefined()]).optional()
+});
+const spanFlagsSchema = z.enum(SpanFlags);
+const spanKindSchema = z.enum(SpanKind);
+const statusCodeSchema = z.enum(StatusCode);
+const severityNumberSchema = z.enum(SeverityNumber);
+const logRecordFlagsSchema = z.enum(LogRecordFlags);
+const aggregationTemporalitySchema = z.union([z.enum(AggregationTemporality), z.number()]);
+const dataPointFlagsSchema = z.union([z.enum(DataPointFlags), z.number()]);
+const exponentialHistogramDataPointBucketsSchema$1 = z.object({
+	offset: z.union([z.number(), z.undefined()]).optional(),
+	bucketCounts: z.union([z.array(z.union([z.string(), z.number()])), z.undefined()]).optional()
+});
+const summaryDataPointValueAtQuantileSchema$1 = z.object({
+	quantile: z.union([z.number(), z.undefined()]).optional(),
+	value: z.union([z.number(), z.undefined()]).optional()
+});
+const statusSchema = z.object({
+	message: z.union([z.string(), z.undefined()]).optional(),
+	code: z.union([statusCodeSchema, z.undefined()]).optional()
+});
+const anyValueSchema = z.lazy(() => z.object({
+	stringValue: z.union([z.string(), z.undefined()]).optional(),
+	boolValue: z.union([z.boolean(), z.undefined()]).optional(),
+	intValue: z.union([
+		z.string(),
+		z.number(),
+		z.undefined()
+	]).optional(),
+	doubleValue: z.union([z.number(), z.undefined()]).optional(),
+	arrayValue: z.union([arrayValueSchema, z.undefined()]).optional(),
+	kvlistValue: z.union([keyValueListSchema, z.undefined()]).optional(),
+	bytesValue: z.union([z.string(), z.undefined()]).optional()
+}));
+const arrayValueSchema = z.lazy(() => z.object({ values: z.union([z.array(anyValueSchema), z.undefined()]).optional() }));
+const keyValueListSchema = z.lazy(() => z.object({ values: z.union([z.array(keyValueSchema), z.undefined()]).optional() }));
+const keyValueSchema = z.lazy(() => z.object({
+	key: z.union([z.string(), z.undefined()]).optional(),
+	value: z.union([anyValueSchema, z.undefined()]).optional()
+}));
+const instrumentationScopeSchema = z.lazy(() => z.object({
+	name: z.union([z.string(), z.undefined()]).optional(),
+	version: z.union([z.string(), z.undefined()]).optional(),
+	attributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	droppedAttributesCount: z.union([z.number(), z.undefined()]).optional()
+}));
+const resourceSchema = z.lazy(() => z.object({
+	attributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	droppedAttributesCount: z.union([z.number(), z.undefined()]).optional(),
+	entityRefs: z.union([z.array(entityRefSchema), z.undefined()]).optional()
+}));
+const tracesDataSchema = z.lazy(() => z.object({ resourceSpans: z.union([z.array(resourceSpansSchema), z.undefined()]).optional() }));
+const resourceSpansSchema = z.lazy(() => z.object({
+	resource: z.union([resourceSchema, z.undefined()]).optional(),
+	scopeSpans: z.union([z.array(scopeSpansSchema), z.undefined()]).optional(),
+	schemaUrl: z.union([z.string(), z.undefined()]).optional()
+}));
+const scopeSpansSchema = z.lazy(() => z.object({
+	scope: z.union([instrumentationScopeSchema, z.undefined()]).optional(),
+	spans: z.union([z.array(spanSchema), z.undefined()]).optional(),
+	schemaUrl: z.union([z.string(), z.undefined()]).optional()
+}));
+const spanSchema = z.lazy(() => z.object({
+	traceId: z.union([z.string(), z.undefined()]).optional(),
+	spanId: z.union([z.string(), z.undefined()]).optional(),
+	traceState: z.union([z.string(), z.undefined()]).optional(),
+	parentSpanId: z.union([z.string(), z.undefined()]).optional(),
+	flags: z.union([z.number(), z.undefined()]).optional(),
+	name: z.union([z.string(), z.undefined()]).optional(),
+	kind: z.union([spanKindSchema, z.undefined()]).optional(),
+	startTimeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	endTimeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	attributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	droppedAttributesCount: z.union([z.number(), z.undefined()]).optional(),
+	events: z.union([z.array(spanEventSchema), z.undefined()]).optional(),
+	droppedEventsCount: z.union([z.number(), z.undefined()]).optional(),
+	links: z.union([z.array(spanLinkSchema), z.undefined()]).optional(),
+	droppedLinksCount: z.union([z.number(), z.undefined()]).optional(),
+	status: z.union([statusSchema, z.undefined()]).optional()
+}));
+const spanEventSchema = z.lazy(() => z.object({
+	timeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	name: z.union([z.string(), z.undefined()]).optional(),
+	attributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	droppedAttributesCount: z.union([z.number(), z.undefined()]).optional()
+}));
+const spanLinkSchema = z.lazy(() => z.object({
+	traceId: z.union([z.string(), z.undefined()]).optional(),
+	spanId: z.union([z.string(), z.undefined()]).optional(),
+	traceState: z.union([z.string(), z.undefined()]).optional(),
+	attributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	droppedAttributesCount: z.union([z.number(), z.undefined()]).optional(),
+	flags: z.union([z.number(), z.undefined()]).optional()
+}));
+const logsDataSchema = z.lazy(() => z.object({ resourceLogs: z.union([z.array(resourceLogsSchema), z.undefined()]).optional() }));
+const resourceLogsSchema = z.lazy(() => z.object({
+	resource: z.union([resourceSchema, z.undefined()]).optional(),
+	scopeLogs: z.union([z.array(scopeLogsSchema), z.undefined()]).optional(),
+	schemaUrl: z.union([z.string(), z.undefined()]).optional()
+}));
+const scopeLogsSchema = z.lazy(() => z.object({
+	scope: z.union([instrumentationScopeSchema, z.undefined()]).optional(),
+	logRecords: z.union([z.array(logRecordSchema), z.undefined()]).optional(),
+	schemaUrl: z.union([z.string(), z.undefined()]).optional()
+}));
+const logRecordSchema = z.lazy(() => z.object({
+	timeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	observedTimeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	severityNumber: z.union([severityNumberSchema, z.undefined()]).optional(),
+	severityText: z.union([z.string(), z.undefined()]).optional(),
+	body: z.union([anyValueSchema, z.undefined()]).optional(),
+	attributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	droppedAttributesCount: z.union([z.number(), z.undefined()]).optional(),
+	flags: z.union([z.number(), z.undefined()]).optional(),
+	traceId: z.union([z.string(), z.undefined()]).optional(),
+	spanId: z.union([z.string(), z.undefined()]).optional(),
+	eventName: z.union([z.string(), z.undefined()]).optional()
+}));
+const summarySchema$1 = z.lazy(() => z.object({ dataPoints: z.union([z.array(summaryDataPointSchema$1), z.undefined()]).optional() }));
+const summaryDataPointSchema$1 = z.lazy(() => z.object({
+	attributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	startTimeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	timeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	count: z.union([
+		z.string(),
+		z.number(),
+		z.undefined()
+	]).optional(),
+	sum: z.union([z.number(), z.undefined()]).optional(),
+	quantileValues: z.union([z.array(summaryDataPointValueAtQuantileSchema$1), z.undefined()]).optional(),
+	flags: z.union([z.number(), z.undefined()]).optional()
+}));
+
+//#endregion
+//#region src/otlp-metrics-zod.ts
+var otlp_metrics_zod_exports = /* @__PURE__ */ __exportAll({
+	exemplarSchema: () => exemplarSchema,
+	exponentialHistogramDataPointBucketsSchema: () => exponentialHistogramDataPointBucketsSchema,
+	exponentialHistogramDataPointSchema: () => exponentialHistogramDataPointSchema,
+	exponentialHistogramSchema: () => exponentialHistogramSchema,
+	gaugeSchema: () => gaugeSchema,
+	histogramDataPointSchema: () => histogramDataPointSchema,
+	histogramSchema: () => histogramSchema,
+	metricSchema: () => metricSchema,
+	metricsDataSchema: () => metricsDataSchema,
+	numberDataPointSchema: () => numberDataPointSchema,
+	resourceMetricsSchema: () => resourceMetricsSchema,
+	scopeMetricsSchema: () => scopeMetricsSchema,
+	sumSchema: () => sumSchema,
+	summaryDataPointSchema: () => summaryDataPointSchema,
+	summaryDataPointValueAtQuantileSchema: () => summaryDataPointValueAtQuantileSchema,
+	summarySchema: () => summarySchema
+});
+/**
+* Represents the value at a given quantile of a distribution.
+*
+* To record Min and Max values following conventions are used:
+* - The 1.0 quantile is equivalent to the maximum value observed.
+* - The 0.0 quantile is equivalent to the minimum value observed.
+*
+* See the following issue for more context:
+* https://github.com/open-telemetry/opentelemetry-proto/issues/125
+*/
+const summaryDataPointValueAtQuantileSchema = z.object({
+	quantile: z.union([z.number(), z.undefined()]).optional(),
+	value: z.union([z.number(), z.undefined()]).optional()
+});
+/**
+* Buckets are a set of bucket counts, encoded in a contiguous array
+* of counts.
+*/
+const exponentialHistogramDataPointBucketsSchema = z.object({
+	offset: z.union([z.number(), z.undefined()]).optional(),
+	bucketCounts: z.union([z.array(z.union([z.string(), z.number()])), z.undefined()]).optional()
+});
+/**
+* A representation of an exemplar, which is a sample input measurement.
+* Exemplars also hold information about the environment when the measurement
+* was recorded, for example the span and trace ID of the active span when the
+* exemplar was recorded.
+*/
+const exemplarSchema = z.lazy(() => z.object({
+	filteredAttributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	timeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	asDouble: z.union([z.number(), z.undefined()]).optional(),
+	asInt: z.union([z.string(), z.undefined()]).optional(),
+	spanId: z.union([z.string(), z.undefined()]).optional(),
+	traceId: z.union([z.instanceof(Uint8Array), z.undefined()]).optional()
+}));
+/**
+* NumberDataPoint is a single data point in a timeseries that describes the
+* time-varying scalar value of a metric.
+*/
+const numberDataPointSchema = z.lazy(() => z.object({
+	attributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	startTimeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	timeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	asDouble: z.union([z.number(), z.undefined()]).optional(),
+	asInt: z.union([z.string(), z.undefined()]).optional(),
+	exemplars: z.union([z.array(exemplarSchema), z.undefined()]).optional(),
+	flags: z.union([z.number(), z.undefined()]).optional()
+}));
+/**
+* HistogramDataPoint is a single data point in a timeseries that describes the
+* time-varying values of a Histogram. A Histogram contains summary statistics
+* for a population of values, it may optionally contain the distribution of
+* those values across a set of buckets.
+*
+* If the histogram contains the distribution of values, then both
+* "explicit_bounds" and "bucket counts" fields must be defined.
+* If the histogram does not contain the distribution of values, then both
+* "explicit_bounds" and "bucket_counts" must be omitted and only "count" and
+* "sum" are known.
+*/
+const histogramDataPointSchema = z.lazy(() => z.object({
+	attributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	startTimeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	timeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	count: z.union([
+		z.string(),
+		z.number(),
+		z.undefined()
+	]).optional(),
+	sum: z.union([z.number(), z.undefined()]).optional(),
+	bucketCounts: z.union([z.array(z.union([z.string(), z.number()])), z.undefined()]).optional(),
+	explicitBounds: z.union([z.array(z.number()), z.undefined()]).optional(),
+	exemplars: z.union([z.array(exemplarSchema), z.undefined()]).optional(),
+	flags: z.union([z.number(), z.undefined()]).optional(),
+	min: z.union([z.number(), z.undefined()]).optional(),
+	max: z.union([z.number(), z.undefined()]).optional()
+}));
+/**
+* ExponentialHistogramDataPoint is a single data point in a timeseries that describes the
+* time-varying values of a ExponentialHistogram of double values. A ExponentialHistogram contains
+* summary statistics for a population of values, it may optionally contain the
+* distribution of those values across a set of buckets.
+*/
+const exponentialHistogramDataPointSchema = z.lazy(() => z.object({
+	attributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	startTimeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	timeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	count: z.union([
+		z.string(),
+		z.number(),
+		z.undefined()
+	]).optional(),
+	sum: z.union([z.number(), z.undefined()]).optional(),
+	scale: z.union([z.number(), z.undefined()]).optional(),
+	zeroCount: z.union([
+		z.string(),
+		z.number(),
+		z.undefined()
+	]).optional(),
+	positive: z.union([exponentialHistogramDataPointBucketsSchema, z.undefined()]).optional(),
+	negative: z.union([exponentialHistogramDataPointBucketsSchema, z.undefined()]).optional(),
+	flags: z.union([z.number(), z.undefined()]).optional(),
+	exemplars: z.union([z.array(exemplarSchema), z.undefined()]).optional(),
+	min: z.union([z.number(), z.undefined()]).optional(),
+	max: z.union([z.number(), z.undefined()]).optional(),
+	zeroThreshold: z.union([z.number(), z.undefined()]).optional()
+}));
+/**
+* SummaryDataPoint is a single data point in a timeseries that describes the
+* time-varying values of a Summary metric. The count and sum fields represent
+* cumulative values.
+*/
+const summaryDataPointSchema = z.lazy(() => z.object({
+	attributes: z.union([z.array(keyValueSchema), z.undefined()]).optional(),
+	startTimeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	timeUnixNano: z.union([z.string(), z.undefined()]).optional(),
+	count: z.union([
+		z.string(),
+		z.number(),
+		z.undefined()
+	]).optional(),
+	sum: z.union([z.number(), z.undefined()]).optional(),
+	quantileValues: z.union([z.array(summaryDataPointValueAtQuantileSchema), z.undefined()]).optional(),
+	flags: z.union([z.number(), z.undefined()]).optional()
+}));
+/**
+* Gauge represents the type of a scalar metric that always exports the
+* "current value" for every data point. It should be used for an "unknown"
+* aggregation.
+*
+* A Gauge does not support different aggregation temporalities. Given the
+* aggregation is unknown, points cannot be combined using the same
+* aggregation, regardless of aggregation temporalities. Therefore,
+* AggregationTemporality is not included. Consequently, this also means
+* "StartTimeUnixNano" is ignored for all data points.
+*/
+const gaugeSchema = z.lazy(() => z.object({ dataPoints: z.union([z.array(numberDataPointSchema), z.undefined()]).optional() }));
+/**
+* Sum represents the type of a scalar metric that is calculated as a sum of all
+* reported measurements over a time interval.
+*/
+const sumSchema = z.lazy(() => z.object({
+	dataPoints: z.union([z.array(numberDataPointSchema), z.undefined()]).optional(),
+	aggregationTemporality: z.union([aggregationTemporalitySchema, z.undefined()]).optional(),
+	isMonotonic: z.union([z.boolean(), z.undefined()]).optional()
+}));
+/**
+* Histogram represents the type of a metric that is calculated by aggregating
+* as a Histogram of all reported measurements over a time interval.
+*/
+const histogramSchema = z.lazy(() => z.object({
+	dataPoints: z.union([z.array(histogramDataPointSchema), z.undefined()]).optional(),
+	aggregationTemporality: z.union([aggregationTemporalitySchema, z.undefined()]).optional()
+}));
+/**
+* ExponentialHistogram represents the type of a metric that is calculated by aggregating
+* as a ExponentialHistogram of all reported double measurements over a time interval.
+*/
+const exponentialHistogramSchema = z.lazy(() => z.object({
+	dataPoints: z.union([z.array(exponentialHistogramDataPointSchema), z.undefined()]).optional(),
+	aggregationTemporality: z.union([aggregationTemporalitySchema, z.undefined()]).optional()
+}));
+/**
+* Summary metric data are used to convey quantile summaries,
+* a Prometheus (see: https://prometheus.io/docs/concepts/metric_types/#summary)
+* and OpenMetrics (see: https://github.com/prometheus/OpenMetrics/blob/4dbf6075567ab43296eed941037c12951faafb92/protos/prometheus.proto#L45)
+* data type. These data points cannot always be merged in a meaningful way.
+* While they can be useful in some applications, histogram data points are
+* recommended for new applications.
+* Summary metrics do not have an aggregation temporality field. This is
+* because the count and sum fields of a SummaryDataPoint are assumed to be
+* cumulative values.
+*/
+const summarySchema = z.lazy(() => z.object({ dataPoints: z.union([z.array(summaryDataPointSchema), z.undefined()]).optional() }));
+/**
+* Defines a Metric which has one or more timeseries.  The following is a
+* brief summary of the Metric data model.  For more details, see:
+*
+*   https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/data-model.md
+*
+* The data model and relation between entities is shown in the
+* diagram below. Here, "DataPoint" is the term used to refer to any
+* one of the specific data point value types, and "points" is the term used
+* to refer to any one of the lists of points contained in the Metric.
+*
+* - Metric is composed of a metadata and data.
+* - Metadata part contains a name, description, unit.
+* - Data is one of the possible types (Sum, Gauge, Histogram, Summary).
+* - DataPoint contains timestamps, attributes, and one of the possible value type
+*   fields.
+*
+*    Metric
+*  +------------+
+*  |name        |
+*  |description |
+*  |unit        |     +------------------------------------+
+*  |data        |---> |Gauge, Sum, Histogram, Summary, ... |
+*  +------------+     +------------------------------------+
+*
+*    Data [One of Gauge, Sum, Histogram, Summary, ...]
+*  +-----------+
+*  |...        |  // Metadata about the Data.
+*  |points     |--+
+*  +-----------+  |
+*                 |      +---------------------------+
+*                 |      |DataPoint 1                |
+*                 v      |+------+------+   +------+ |
+*              +-----+   ||label |label |...|label | |
+*              |  1  |-->||value1|value2|...|valueN| |
+*              +-----+   |+------+------+   +------+ |
+*              |  .  |   |+-----+                    |
+*              |  .  |   ||value|                    |
+*              |  .  |   |+-----+                    |
+*              |  .  |   +---------------------------+
+*              |  .  |                   .
+*              |  .  |                   .
+*              |  .  |                   .
+*              |  .  |   +---------------------------+
+*              |  .  |   |DataPoint M                |
+*              +-----+   |+------+------+   +------+ |
+*              |  M  |-->||label |label |...|label | |
+*              +-----+   ||value1|value2|...|valueN| |
+*                        |+------+------+   +------+ |
+*                        |+-----+                    |
+*                        ||value|                    |
+*                        |+-----+                    |
+*                        +---------------------------+
+*
+* Each distinct type of DataPoint represents the output of a specific
+* aggregation function, the result of applying the DataPoint's
+* associated function of to one or more measurements.
+*
+* All DataPoint types have three common fields:
+* - Attributes includes key-value pairs associated with the data point
+* - TimeUnixNano is required, set to the end time of the aggregation
+* - StartTimeUnixNano is optional, but strongly encouraged for DataPoints
+*   having an AggregationTemporality field, as discussed below.
+*
+* Both TimeUnixNano and StartTimeUnixNano values are expressed as
+* UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970.
+*
+* # TimeUnixNano
+*
+* This field is required, having consistent interpretation across
+* DataPoint types.  TimeUnixNano is the moment corresponding to when
+* the data point's aggregate value was captured.
+*
+* Data points with the 0 value for TimeUnixNano SHOULD be rejected
+* by consumers.
+*
+* # StartTimeUnixNano
+*
+* StartTimeUnixNano in general allows detecting when a sequence of
+* observations is unbroken.  This field indicates to consumers the
+* start time for points with cumulative and delta
+* AggregationTemporality, and it should be included whenever possible
+* to support correct rate calculation.  Although it may be omitted
+* when the start time is truly unknown, setting StartTimeUnixNano is
+* strongly encouraged.
+*/
+const metricSchema = z.lazy(() => z.object({
+	name: z.union([z.string(), z.undefined()]).optional(),
+	description: z.union([z.string(), z.undefined()]).optional(),
+	unit: z.union([z.string(), z.undefined()]).optional(),
+	gauge: z.union([gaugeSchema, z.undefined()]).optional(),
+	sum: z.union([sumSchema, z.undefined()]).optional(),
+	histogram: z.union([histogramSchema, z.undefined()]).optional(),
+	exponentialHistogram: z.union([exponentialHistogramSchema, z.undefined()]).optional(),
+	summary: z.union([summarySchema, z.undefined()]).optional(),
+	metadata: z.union([z.array(keyValueSchema), z.undefined()]).optional()
+}));
+/** A collection of Metrics produced by an Scope. */
+const scopeMetricsSchema = z.lazy(() => z.object({
+	scope: z.union([instrumentationScopeSchema, z.undefined()]).optional(),
+	metrics: z.union([z.array(metricSchema), z.undefined()]).optional(),
+	schemaUrl: z.union([z.string(), z.undefined()]).optional()
+}));
+/** A collection of ScopeMetrics from a Resource. */
+const resourceMetricsSchema = z.lazy(() => z.object({
+	resource: z.union([resourceSchema, z.undefined()]).optional(),
+	scopeMetrics: z.union([z.array(scopeMetricsSchema), z.undefined()]).optional(),
+	schemaUrl: z.union([z.string(), z.undefined()]).optional()
+}));
+/**
+* MetricsData represents the metrics data that can be stored in a persistent
+* storage, OR can be embedded by other protocols that transfer OTLP metrics
+* data but do not implement the OTLP protocol.
+*
+* MetricsData
+* └─── ResourceMetrics
+*   ├── Resource
+*   ├── SchemaURL
+*   └── ScopeMetrics
+*      ├── Scope
+*      ├── SchemaURL
+*      └── Metric
+*         ├── Name
+*         ├── Description
+*         ├── Unit
+*         └── data
+*            ├── Gauge
+*            ├── Sum
+*            ├── Histogram
+*            ├── ExponentialHistogram
+*            └── Summary
+*
+* The main difference between this message and collector protocol is that
+* in this message there will not be any "control" or "metadata" specific to
+* OTLP protocol.
+*
+* When new fields are added into this message, the OTLP request MUST be updated
+* as well.
+*/
+const metricsDataSchema = z.lazy(() => z.object({ resourceMetrics: z.union([z.array(resourceMetricsSchema), z.undefined()]).optional() }));
+
+//#endregion
+//#region src/data-filters-zod.ts
+var data_filters_zod_exports = /* @__PURE__ */ __exportAll({
+	logsDataFilterSchema: () => logsDataFilterSchema,
+	metricsDataFilterSchema: () => metricsDataFilterSchema,
+	tracesDataFilterSchema: () => tracesDataFilterSchema
+});
+const tracesDataFilterSchema = z$1.object({
+	traceId: z$1.string().optional().describe("Unique identifier for a trace. All spans from the same trace share the same trace_id. The ID is a 16-byte array."),
+	spanId: z$1.string().optional().describe("Unique identifier for a span within a trace. The ID is an 8-byte array."),
+	parentSpanId: z$1.string().optional().describe("The span_id of this span's parent span. Empty if this is a root span."),
+	serviceName: z$1.string().optional().describe("Service name from resource attributes (service.name)."),
+	spanName: z$1.string().optional().describe("Description of the span's operation. E.g., qualified method name or file name with line number."),
+	spanKind: z$1.string().optional().describe("Type of span (INTERNAL, SERVER, CLIENT, PRODUCER, CONSUMER). Used to identify relationships between spans."),
+	statusCode: z$1.string().optional().describe("Status code (UNSET, OK, ERROR)."),
+	scopeName: z$1.string().optional().describe("Name denoting the instrumentation scope."),
+	timestampMin: z$1.string().optional().describe("Minimum start time of the span. UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970. Expressed as string in JSON."),
+	timestampMax: z$1.string().optional().describe("Maximum start time of the span. UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970. Expressed as string in JSON."),
+	durationMin: z$1.string().optional().describe("Minimum duration of the span in nanoseconds (end_time - start_time). Expressed as string in JSON."),
+	durationMax: z$1.string().optional().describe("Maximum duration of the span in nanoseconds (end_time - start_time). Expressed as string in JSON."),
+	spanAttributes: z$1.record(z$1.string(), z$1.string()).optional().describe("Key/value pairs describing the span."),
+	resourceAttributes: z$1.record(z$1.string(), z$1.string()).optional().describe("Attributes that describe the resource."),
+	eventsAttributes: z$1.record(z$1.string(), z$1.string()).optional().describe("Attribute key/value pairs on the event."),
+	linksAttributes: z$1.record(z$1.string(), z$1.string()).optional().describe("Attribute key/value pairs on the link."),
+	limit: z$1.number().int().positive().max(1e3).optional().describe("Max items to return. Default determined by datasource."),
+	cursor: z$1.string().optional().describe("Opaque cursor from previous response for next page."),
+	sortOrder: z$1.enum(["ASC", "DESC"]).optional().describe("Sort by timestamp. ASC = oldest first, DESC = newest first.")
+});
+const logsDataFilterSchema = z$1.object({
+	traceId: z$1.string().optional().describe("Unique identifier for a trace. All logs from the same trace share the same trace_id. The ID is a 16-byte array."),
+	spanId: z$1.string().optional().describe("Unique identifier for a span within a trace. The ID is an 8-byte array."),
+	serviceName: z$1.string().optional().describe("Service name from resource attributes (service.name)."),
+	scopeName: z$1.string().optional().describe("Name denoting the instrumentation scope."),
+	severityText: z$1.string().optional().describe("Severity text (also known as log level). Original string representation as known at the source."),
+	severityNumberMin: z$1.number().optional().describe("Minimum severity number (inclusive). Normalized to values described in Log Data Model."),
+	severityNumberMax: z$1.number().optional().describe("Maximum severity number (inclusive). Normalized to values described in Log Data Model."),
+	bodyContains: z$1.string().optional().describe("Filter logs where body contains this substring."),
+	timestampMin: z$1.string().optional().describe("Minimum time when the event occurred. UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970. Expressed as string in JSON."),
+	timestampMax: z$1.string().optional().describe("Maximum time when the event occurred. UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January 1970. Expressed as string in JSON."),
+	logAttributes: z$1.record(z$1.string(), z$1.string()).optional().describe("Additional attributes that describe the specific event occurrence."),
+	resourceAttributes: z$1.record(z$1.string(), z$1.string()).optional().describe("Attributes that describe the resource."),
+	scopeAttributes: z$1.record(z$1.string(), z$1.string()).optional().describe("Attributes of the instrumentation scope."),
+	limit: z$1.number().int().positive().max(1e3).optional().describe("Max items to return. Default determined by datasource."),
+	cursor: z$1.string().optional().describe("Opaque cursor from previous response for next page."),
+	sortOrder: z$1.enum(["ASC", "DESC"]).optional().describe("Sort by timestamp. ASC = oldest first, DESC = newest first.")
+});
+const metricsDataFilterSchema = z$1.object({
+	metricType: z$1.enum([
+		"Gauge",
+		"Sum",
+		"Histogram",
+		"ExponentialHistogram",
+		"Summary"
+	]).describe("Metric type to query."),
+	metricName: z$1.string().optional().describe("The name of the metric."),
+	serviceName: z$1.string().optional().describe("Service name from resource attributes (service.name)."),
+	scopeName: z$1.string().optional().describe("Name denoting the instrumentation scope."),
+	timeUnixMin: z$1.string().optional().describe("Minimum time when the data point was recorded. UNIX Epoch time in nanoseconds. Expressed as string in JSON."),
+	timeUnixMax: z$1.string().optional().describe("Maximum time when the data point was recorded. UNIX Epoch time in nanoseconds. Expressed as string in JSON."),
+	attributes: z$1.record(z$1.string(), z$1.string()).optional().describe("Key/value pairs that uniquely identify the timeseries."),
+	resourceAttributes: z$1.record(z$1.string(), z$1.string()).optional().describe("Attributes that describe the resource."),
+	scopeAttributes: z$1.record(z$1.string(), z$1.string()).optional().describe("Attributes of the instrumentation scope."),
+	limit: z$1.number().int().positive().max(1e3).optional().describe("Max items to return. Default determined by datasource."),
+	cursor: z$1.string().optional().describe("Opaque cursor from previous response for next page."),
+	sortOrder: z$1.enum(["ASC", "DESC"]).optional().describe("Sort by timestamp. ASC = oldest first, DESC = newest first.")
+});
+
+//#endregion
+//#region src/index.ts
+const name = "@kopai/core";
+
+//#endregion
+export { data_filters_zod_exports as dataFilterSchemas, telemetry_datasource_exports as datasource, denormalized_signals_zod_exports as denormalizedSignals, name, otlp_generated_exports as otlp, otlp_metrics_generated_exports as otlpMetrics, otlp_metrics_zod_exports as otlpMetricsZod, otlp_zod_exports as otlpZod };
+//# sourceMappingURL=index.mjs.map