@objectstack/spec 0.6.0 → 0.7.1

package/dist/system/tracing.zod.d.ts

@@ -0,0 +1,1881 @@
+import { z } from 'zod';
+/**
+ * Tracing Protocol - Distributed Tracing & Observability
+ *
+ * Comprehensive distributed tracing based on OpenTelemetry standards:
+ * - Trace context propagation
+ * - Span creation and management
+ * - Sampling strategies
+ * - Integration with tracing backends (Jaeger, Zipkin, etc.)
+ * - W3C Trace Context standard compliance
+ */
+/**
+ * Trace State Schema
+ * W3C Trace Context tracestate header
+ */
+export declare const TraceStateSchema: z.ZodObject<{
+    /**
+     * Vendor-specific key-value pairs
+     */
+    entries: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    entries: Record<string, string>;
+}, {
+    entries: Record<string, string>;
+}>;
+export type TraceState = z.infer<typeof TraceStateSchema>;
+/**
+ * Trace Flags Enum
+ * W3C Trace Context trace flags
+ */
+export declare const TraceFlagsSchema: z.ZodNumber;
+export type TraceFlags = z.infer<typeof TraceFlagsSchema>;
+/**
+ * Trace Context Schema
+ * W3C Trace Context standard
+ */
+export declare const TraceContextSchema: z.ZodObject<{
+    /**
+     * Trace ID (128-bit identifier, 32 hex chars)
+     */
+    traceId: z.ZodString;
+    /**
+     * Span ID (64-bit identifier, 16 hex chars)
+     */
+    spanId: z.ZodString;
+    /**
+     * Trace flags (8-bit)
+     */
+    traceFlags: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /**
+     * Trace state (vendor-specific)
+     */
+    traceState: z.ZodOptional<z.ZodObject<{
+        /**
+         * Vendor-specific key-value pairs
+         */
+        entries: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        entries: Record<string, string>;
+    }, {
+        entries: Record<string, string>;
+    }>>;
+    /**
+     * Parent span ID
+     */
+    parentSpanId: z.ZodOptional<z.ZodString>;
+    /**
+     * Is sampled
+     */
+    sampled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Remote context (from incoming request)
+     */
+    remote: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    traceId: string;
+    spanId: string;
+    traceFlags: number;
+    sampled: boolean;
+    remote: boolean;
+    parentSpanId?: string | undefined;
+    traceState?: {
+        entries: Record<string, string>;
+    } | undefined;
+}, {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string | undefined;
+    traceFlags?: number | undefined;
+    traceState?: {
+        entries: Record<string, string>;
+    } | undefined;
+    sampled?: boolean | undefined;
+    remote?: boolean | undefined;
+}>;
+export type TraceContext = z.infer<typeof TraceContextSchema>;
+/**
+ * Span Kind Enum
+ * OpenTelemetry span kinds
+ */
+export declare const SpanKind: z.ZodEnum<["internal", "server", "client", "producer", "consumer"]>;
+export type SpanKind = z.infer<typeof SpanKind>;
+/**
+ * Span Status Enum
+ * OpenTelemetry span status
+ */
+export declare const SpanStatus: z.ZodEnum<["unset", "ok", "error"]>;
+export type SpanStatus = z.infer<typeof SpanStatus>;
+/**
+ * Span Attribute Value Schema
+ */
+export declare const SpanAttributeValueSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>;
+export type SpanAttributeValue = z.infer<typeof SpanAttributeValueSchema>;
+/**
+ * Span Attributes Schema
+ * OpenTelemetry semantic conventions
+ */
+export declare const SpanAttributesSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>>;
+export type SpanAttributes = z.infer<typeof SpanAttributesSchema>;
+/**
+ * Span Event Schema
+ */
+export declare const SpanEventSchema: z.ZodObject<{
+    /**
+     * Event name
+     */
+    name: z.ZodString;
+    /**
+     * Event timestamp (ISO 8601)
+     */
+    timestamp: z.ZodString;
+    /**
+     * Event attributes
+     */
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    timestamp: string;
+    attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+}, {
+    name: string;
+    timestamp: string;
+    attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+}>;
+export type SpanEvent = z.infer<typeof SpanEventSchema>;
+/**
+ * Span Link Schema
+ * Links to other spans
+ */
+export declare const SpanLinkSchema: z.ZodObject<{
+    /**
+     * Linked trace context
+     */
+    context: z.ZodObject<{
+        /**
+         * Trace ID (128-bit identifier, 32 hex chars)
+         */
+        traceId: z.ZodString;
+        /**
+         * Span ID (64-bit identifier, 16 hex chars)
+         */
+        spanId: z.ZodString;
+        /**
+         * Trace flags (8-bit)
+         */
+        traceFlags: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Trace state (vendor-specific)
+         */
+        traceState: z.ZodOptional<z.ZodObject<{
+            /**
+             * Vendor-specific key-value pairs
+             */
+            entries: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            entries: Record<string, string>;
+        }, {
+            entries: Record<string, string>;
+        }>>;
+        /**
+         * Parent span ID
+         */
+        parentSpanId: z.ZodOptional<z.ZodString>;
+        /**
+         * Is sampled
+         */
+        sampled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Remote context (from incoming request)
+         */
+        remote: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        traceId: string;
+        spanId: string;
+        traceFlags: number;
+        sampled: boolean;
+        remote: boolean;
+        parentSpanId?: string | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+    }, {
+        traceId: string;
+        spanId: string;
+        parentSpanId?: string | undefined;
+        traceFlags?: number | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+        sampled?: boolean | undefined;
+        remote?: boolean | undefined;
+    }>;
+    /**
+     * Link attributes
+     */
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>>>;
+}, "strip", z.ZodTypeAny, {
+    context: {
+        traceId: string;
+        spanId: string;
+        traceFlags: number;
+        sampled: boolean;
+        remote: boolean;
+        parentSpanId?: string | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+    };
+    attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+}, {
+    context: {
+        traceId: string;
+        spanId: string;
+        parentSpanId?: string | undefined;
+        traceFlags?: number | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+        sampled?: boolean | undefined;
+        remote?: boolean | undefined;
+    };
+    attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+}>;
+export type SpanLink = z.infer<typeof SpanLinkSchema>;
+/**
+ * Span Schema
+ * OpenTelemetry span representation
+ */
+export declare const SpanSchema: z.ZodObject<{
+    /**
+     * Trace context
+     */
+    context: z.ZodObject<{
+        /**
+         * Trace ID (128-bit identifier, 32 hex chars)
+         */
+        traceId: z.ZodString;
+        /**
+         * Span ID (64-bit identifier, 16 hex chars)
+         */
+        spanId: z.ZodString;
+        /**
+         * Trace flags (8-bit)
+         */
+        traceFlags: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Trace state (vendor-specific)
+         */
+        traceState: z.ZodOptional<z.ZodObject<{
+            /**
+             * Vendor-specific key-value pairs
+             */
+            entries: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            entries: Record<string, string>;
+        }, {
+            entries: Record<string, string>;
+        }>>;
+        /**
+         * Parent span ID
+         */
+        parentSpanId: z.ZodOptional<z.ZodString>;
+        /**
+         * Is sampled
+         */
+        sampled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Remote context (from incoming request)
+         */
+        remote: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        traceId: string;
+        spanId: string;
+        traceFlags: number;
+        sampled: boolean;
+        remote: boolean;
+        parentSpanId?: string | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+    }, {
+        traceId: string;
+        spanId: string;
+        parentSpanId?: string | undefined;
+        traceFlags?: number | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+        sampled?: boolean | undefined;
+        remote?: boolean | undefined;
+    }>;
+    /**
+     * Span name
+     */
+    name: z.ZodString;
+    /**
+     * Span kind
+     */
+    kind: z.ZodDefault<z.ZodOptional<z.ZodEnum<["internal", "server", "client", "producer", "consumer"]>>>;
+    /**
+     * Start time (ISO 8601)
+     */
+    startTime: z.ZodString;
+    /**
+     * End time (ISO 8601)
+     */
+    endTime: z.ZodOptional<z.ZodString>;
+    /**
+     * Duration in milliseconds
+     */
+    duration: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Span status
+     */
+    status: z.ZodOptional<z.ZodObject<{
+        code: z.ZodEnum<["unset", "ok", "error"]>;
+        message: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "error" | "unset" | "ok";
+        message?: string | undefined;
+    }, {
+        code: "error" | "unset" | "ok";
+        message?: string | undefined;
+    }>>;
+    /**
+     * Span attributes
+     */
+    attributes: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>>>>;
+    /**
+     * Span events
+     */
+    events: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /**
+         * Event name
+         */
+        name: z.ZodString;
+        /**
+         * Event timestamp (ISO 8601)
+         */
+        timestamp: z.ZodString;
+        /**
+         * Event attributes
+         */
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        timestamp: string;
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+    }, {
+        name: string;
+        timestamp: string;
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+    }>, "many">>>;
+    /**
+     * Span links
+     */
+    links: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /**
+         * Linked trace context
+         */
+        context: z.ZodObject<{
+            /**
+             * Trace ID (128-bit identifier, 32 hex chars)
+             */
+            traceId: z.ZodString;
+            /**
+             * Span ID (64-bit identifier, 16 hex chars)
+             */
+            spanId: z.ZodString;
+            /**
+             * Trace flags (8-bit)
+             */
+            traceFlags: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            /**
+             * Trace state (vendor-specific)
+             */
+            traceState: z.ZodOptional<z.ZodObject<{
+                /**
+                 * Vendor-specific key-value pairs
+                 */
+                entries: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                entries: Record<string, string>;
+            }, {
+                entries: Record<string, string>;
+            }>>;
+            /**
+             * Parent span ID
+             */
+            parentSpanId: z.ZodOptional<z.ZodString>;
+            /**
+             * Is sampled
+             */
+            sampled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            /**
+             * Remote context (from incoming request)
+             */
+            remote: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            traceId: string;
+            spanId: string;
+            traceFlags: number;
+            sampled: boolean;
+            remote: boolean;
+            parentSpanId?: string | undefined;
+            traceState?: {
+                entries: Record<string, string>;
+            } | undefined;
+        }, {
+            traceId: string;
+            spanId: string;
+            parentSpanId?: string | undefined;
+            traceFlags?: number | undefined;
+            traceState?: {
+                entries: Record<string, string>;
+            } | undefined;
+            sampled?: boolean | undefined;
+            remote?: boolean | undefined;
+        }>;
+        /**
+         * Link attributes
+         */
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>>>;
+    }, "strip", z.ZodTypeAny, {
+        context: {
+            traceId: string;
+            spanId: string;
+            traceFlags: number;
+            sampled: boolean;
+            remote: boolean;
+            parentSpanId?: string | undefined;
+            traceState?: {
+                entries: Record<string, string>;
+            } | undefined;
+        };
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+    }, {
+        context: {
+            traceId: string;
+            spanId: string;
+            parentSpanId?: string | undefined;
+            traceFlags?: number | undefined;
+            traceState?: {
+                entries: Record<string, string>;
+            } | undefined;
+            sampled?: boolean | undefined;
+            remote?: boolean | undefined;
+        };
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+    }>, "many">>>;
+    /**
+     * Resource attributes
+     */
+    resource: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>>>;
+    /**
+     * Instrumentation library
+     */
+    instrumentationLibrary: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    events: {
+        name: string;
+        timestamp: string;
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+    }[];
+    attributes: Record<string, string | number | boolean | string[] | number[] | boolean[]>;
+    context: {
+        traceId: string;
+        spanId: string;
+        traceFlags: number;
+        sampled: boolean;
+        remote: boolean;
+        parentSpanId?: string | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+    };
+    startTime: string;
+    kind: "internal" | "server" | "client" | "producer" | "consumer";
+    links: {
+        context: {
+            traceId: string;
+            spanId: string;
+            traceFlags: number;
+            sampled: boolean;
+            remote: boolean;
+            parentSpanId?: string | undefined;
+            traceState?: {
+                entries: Record<string, string>;
+            } | undefined;
+        };
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+    }[];
+    status?: {
+        code: "error" | "unset" | "ok";
+        message?: string | undefined;
+    } | undefined;
+    duration?: number | undefined;
+    endTime?: string | undefined;
+    resource?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+    instrumentationLibrary?: {
+        name: string;
+        version?: string | undefined;
+    } | undefined;
+}, {
+    name: string;
+    context: {
+        traceId: string;
+        spanId: string;
+        parentSpanId?: string | undefined;
+        traceFlags?: number | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+        sampled?: boolean | undefined;
+        remote?: boolean | undefined;
+    };
+    startTime: string;
+    status?: {
+        code: "error" | "unset" | "ok";
+        message?: string | undefined;
+    } | undefined;
+    events?: {
+        name: string;
+        timestamp: string;
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+    }[] | undefined;
+    attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+    duration?: number | undefined;
+    endTime?: string | undefined;
+    kind?: "internal" | "server" | "client" | "producer" | "consumer" | undefined;
+    links?: {
+        context: {
+            traceId: string;
+            spanId: string;
+            parentSpanId?: string | undefined;
+            traceFlags?: number | undefined;
+            traceState?: {
+                entries: Record<string, string>;
+            } | undefined;
+            sampled?: boolean | undefined;
+            remote?: boolean | undefined;
+        };
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+    }[] | undefined;
+    resource?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+    instrumentationLibrary?: {
+        name: string;
+        version?: string | undefined;
+    } | undefined;
+}>;
+export type Span = z.infer<typeof SpanSchema>;
+/**
+ * Sampling Decision Enum
+ */
+export declare const SamplingDecision: z.ZodEnum<["drop", "record_only", "record_and_sample"]>;
+export type SamplingDecision = z.infer<typeof SamplingDecision>;
+/**
+ * Sampling Strategy Type Enum
+ */
+export declare const SamplingStrategyType: z.ZodEnum<["always_on", "always_off", "trace_id_ratio", "rate_limiting", "parent_based", "probability", "composite", "custom"]>;
+export type SamplingStrategyType = z.infer<typeof SamplingStrategyType>;
+/**
+ * Trace Sampling Configuration Schema
+ */
+export declare const TraceSamplingConfigSchema: z.ZodObject<{
+    /**
+     * Sampling strategy type
+     */
+    type: z.ZodEnum<["always_on", "always_off", "trace_id_ratio", "rate_limiting", "parent_based", "probability", "composite", "custom"]>;
+    /**
+     * Sample ratio (0.0 to 1.0) for trace_id_ratio and probability strategies
+     */
+    ratio: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Rate limit (traces per second) for rate_limiting strategy
+     */
+    rateLimit: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Parent-based configuration
+     */
+    parentBased: z.ZodOptional<z.ZodObject<{
+        /**
+         * Sampler to use when parent is sampled
+         */
+        whenParentSampled: z.ZodDefault<z.ZodOptional<z.ZodEnum<["always_on", "always_off", "trace_id_ratio", "rate_limiting", "parent_based", "probability", "composite", "custom"]>>>;
+        /**
+         * Sampler to use when parent is not sampled
+         */
+        whenParentNotSampled: z.ZodDefault<z.ZodOptional<z.ZodEnum<["always_on", "always_off", "trace_id_ratio", "rate_limiting", "parent_based", "probability", "composite", "custom"]>>>;
+        /**
+         * Sampler to use when there is no parent (root span)
+         */
+        root: z.ZodDefault<z.ZodOptional<z.ZodEnum<["always_on", "always_off", "trace_id_ratio", "rate_limiting", "parent_based", "probability", "composite", "custom"]>>>;
+        /**
+         * Root sampler ratio
+         */
+        rootRatio: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        whenParentSampled: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        whenParentNotSampled: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        root: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        rootRatio: number;
+    }, {
+        whenParentSampled?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+        whenParentNotSampled?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+        root?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+        rootRatio?: number | undefined;
+    }>>;
+    /**
+     * Composite sampling (multiple strategies)
+     */
+    composite: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        strategy: z.ZodEnum<["always_on", "always_off", "trace_id_ratio", "rate_limiting", "parent_based", "probability", "composite", "custom"]>;
+        ratio: z.ZodOptional<z.ZodNumber>;
+        condition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        condition?: Record<string, any> | undefined;
+        ratio?: number | undefined;
+    }, {
+        strategy: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        condition?: Record<string, any> | undefined;
+        ratio?: number | undefined;
+    }>, "many">>;
+    /**
+     * Sampling rules
+     */
+    rules: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /**
+         * Rule name
+         */
+        name: z.ZodString;
+        /**
+         * Match condition
+         */
+        match: z.ZodOptional<z.ZodObject<{
+            /**
+             * Service name pattern
+             */
+            service: z.ZodOptional<z.ZodString>;
+            /**
+             * Span name pattern (regex)
+             */
+            spanName: z.ZodOptional<z.ZodString>;
+            /**
+             * Attribute filters
+             */
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            attributes?: Record<string, any> | undefined;
+            service?: string | undefined;
+            spanName?: string | undefined;
+        }, {
+            attributes?: Record<string, any> | undefined;
+            service?: string | undefined;
+            spanName?: string | undefined;
+        }>>;
+        /**
+         * Sampling decision for matching spans
+         */
+        decision: z.ZodEnum<["drop", "record_only", "record_and_sample"]>;
+        /**
+         * Sample rate for this rule
+         */
+        rate: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        decision: "drop" | "record_only" | "record_and_sample";
+        rate?: number | undefined;
+        match?: {
+            attributes?: Record<string, any> | undefined;
+            service?: string | undefined;
+            spanName?: string | undefined;
+        } | undefined;
+    }, {
+        name: string;
+        decision: "drop" | "record_only" | "record_and_sample";
+        rate?: number | undefined;
+        match?: {
+            attributes?: Record<string, any> | undefined;
+            service?: string | undefined;
+            spanName?: string | undefined;
+        } | undefined;
+    }>, "many">>>;
+    /**
+     * Custom sampler ID (for custom strategy)
+     */
+    customSamplerId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+    rules: {
+        name: string;
+        decision: "drop" | "record_only" | "record_and_sample";
+        rate?: number | undefined;
+        match?: {
+            attributes?: Record<string, any> | undefined;
+            service?: string | undefined;
+            spanName?: string | undefined;
+        } | undefined;
+    }[];
+    rateLimit?: number | undefined;
+    ratio?: number | undefined;
+    composite?: {
+        strategy: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        condition?: Record<string, any> | undefined;
+        ratio?: number | undefined;
+    }[] | undefined;
+    parentBased?: {
+        whenParentSampled: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        whenParentNotSampled: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        root: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        rootRatio: number;
+    } | undefined;
+    customSamplerId?: string | undefined;
+}, {
+    type: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+    rules?: {
+        name: string;
+        decision: "drop" | "record_only" | "record_and_sample";
+        rate?: number | undefined;
+        match?: {
+            attributes?: Record<string, any> | undefined;
+            service?: string | undefined;
+            spanName?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    rateLimit?: number | undefined;
+    ratio?: number | undefined;
+    composite?: {
+        strategy: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        condition?: Record<string, any> | undefined;
+        ratio?: number | undefined;
+    }[] | undefined;
+    parentBased?: {
+        whenParentSampled?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+        whenParentNotSampled?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+        root?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+        rootRatio?: number | undefined;
+    } | undefined;
+    customSamplerId?: string | undefined;
+}>;
+export type TraceSamplingConfig = z.infer<typeof TraceSamplingConfigSchema>;
+/**
+ * Trace Context Propagation Format Enum
+ */
+export declare const TracePropagationFormat: z.ZodEnum<["w3c", "b3", "b3_multi", "jaeger", "xray", "ottrace", "custom"]>;
+export type TracePropagationFormat = z.infer<typeof TracePropagationFormat>;
+/**
+ * Trace Context Propagation Schema
+ */
+export declare const TraceContextPropagationSchema: z.ZodObject<{
+    /**
+     * Propagation formats (in priority order)
+     */
+    formats: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["w3c", "b3", "b3_multi", "jaeger", "xray", "ottrace", "custom"]>, "many">>>;
+    /**
+     * Extract context from incoming requests
+     */
+    extract: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Inject context into outgoing requests
+     */
+    inject: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Custom header mappings
+     */
+    headers: z.ZodOptional<z.ZodObject<{
+        /**
+         * Trace ID header name
+         */
+        traceId: z.ZodOptional<z.ZodString>;
+        /**
+         * Span ID header name
+         */
+        spanId: z.ZodOptional<z.ZodString>;
+        /**
+         * Trace flags header name
+         */
+        traceFlags: z.ZodOptional<z.ZodString>;
+        /**
+         * Trace state header name
+         */
+        traceState: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        traceId?: string | undefined;
+        spanId?: string | undefined;
+        traceFlags?: string | undefined;
+        traceState?: string | undefined;
+    }, {
+        traceId?: string | undefined;
+        spanId?: string | undefined;
+        traceFlags?: string | undefined;
+        traceState?: string | undefined;
+    }>>;
+    /**
+     * Baggage propagation
+     */
+    baggage: z.ZodOptional<z.ZodObject<{
+        /**
+         * Enable baggage propagation
+         */
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Maximum baggage size in bytes
+         */
+        maxSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Allowed baggage keys (whitelist)
+         */
+        allowedKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        maxSize: number;
+        allowedKeys?: string[] | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        maxSize?: number | undefined;
+        allowedKeys?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    formats: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[];
+    extract: boolean;
+    inject: boolean;
+    headers?: {
+        traceId?: string | undefined;
+        spanId?: string | undefined;
+        traceFlags?: string | undefined;
+        traceState?: string | undefined;
+    } | undefined;
+    baggage?: {
+        enabled: boolean;
+        maxSize: number;
+        allowedKeys?: string[] | undefined;
+    } | undefined;
+}, {
+    headers?: {
+        traceId?: string | undefined;
+        spanId?: string | undefined;
+        traceFlags?: string | undefined;
+        traceState?: string | undefined;
+    } | undefined;
+    formats?: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[] | undefined;
+    extract?: boolean | undefined;
+    inject?: boolean | undefined;
+    baggage?: {
+        enabled?: boolean | undefined;
+        maxSize?: number | undefined;
+        allowedKeys?: string[] | undefined;
+    } | undefined;
+}>;
+export type TraceContextPropagation = z.infer<typeof TraceContextPropagationSchema>;
+/**
+ * OpenTelemetry Exporter Type Enum
+ */
+export declare const OtelExporterType: z.ZodEnum<["otlp_http", "otlp_grpc", "jaeger", "zipkin", "console", "datadog", "honeycomb", "lightstep", "newrelic", "custom"]>;
+export type OtelExporterType = z.infer<typeof OtelExporterType>;
+/**
+ * OpenTelemetry Compatibility Schema
+ */
+export declare const OpenTelemetryCompatibilitySchema: z.ZodObject<{
+    /**
+     * OpenTelemetry SDK version
+     */
+    sdkVersion: z.ZodOptional<z.ZodString>;
+    /**
+     * Exporter configuration
+     */
+    exporter: z.ZodObject<{
+        /**
+         * Exporter type
+         */
+        type: z.ZodEnum<["otlp_http", "otlp_grpc", "jaeger", "zipkin", "console", "datadog", "honeycomb", "lightstep", "newrelic", "custom"]>;
+        /**
+         * Endpoint URL
+         */
+        endpoint: z.ZodOptional<z.ZodString>;
+        /**
+         * Protocol version
+         */
+        protocol: z.ZodOptional<z.ZodString>;
+        /**
+         * Headers
+         */
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /**
+         * Timeout in milliseconds
+         */
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Compression
+         */
+        compression: z.ZodDefault<z.ZodOptional<z.ZodEnum<["none", "gzip"]>>>;
+        /**
+         * Batch configuration
+         */
+        batch: z.ZodOptional<z.ZodObject<{
+            /**
+             * Maximum batch size
+             */
+            maxBatchSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            /**
+             * Maximum queue size
+             */
+            maxQueueSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            /**
+             * Export timeout in milliseconds
+             */
+            exportTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            /**
+             * Scheduled delay in milliseconds
+             */
+            scheduledDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            maxBatchSize: number;
+            maxQueueSize: number;
+            exportTimeout: number;
+            scheduledDelay: number;
+        }, {
+            maxBatchSize?: number | undefined;
+            maxQueueSize?: number | undefined;
+            exportTimeout?: number | undefined;
+            scheduledDelay?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "custom" | "console" | "datadog" | "jaeger" | "otlp_http" | "otlp_grpc" | "zipkin" | "honeycomb" | "lightstep" | "newrelic";
+        timeout: number;
+        compression: "none" | "gzip";
+        headers?: Record<string, string> | undefined;
+        batch?: {
+            maxBatchSize: number;
+            maxQueueSize: number;
+            exportTimeout: number;
+            scheduledDelay: number;
+        } | undefined;
+        endpoint?: string | undefined;
+        protocol?: string | undefined;
+    }, {
+        type: "custom" | "console" | "datadog" | "jaeger" | "otlp_http" | "otlp_grpc" | "zipkin" | "honeycomb" | "lightstep" | "newrelic";
+        headers?: Record<string, string> | undefined;
+        timeout?: number | undefined;
+        batch?: {
+            maxBatchSize?: number | undefined;
+            maxQueueSize?: number | undefined;
+            exportTimeout?: number | undefined;
+            scheduledDelay?: number | undefined;
+        } | undefined;
+        endpoint?: string | undefined;
+        compression?: "none" | "gzip" | undefined;
+        protocol?: string | undefined;
+    }>;
+    /**
+     * Resource attributes (service identification)
+     */
+    resource: z.ZodObject<{
+        /**
+         * Service name
+         */
+        serviceName: z.ZodString;
+        /**
+         * Service version
+         */
+        serviceVersion: z.ZodOptional<z.ZodString>;
+        /**
+         * Service instance ID
+         */
+        serviceInstanceId: z.ZodOptional<z.ZodString>;
+        /**
+         * Service namespace
+         */
+        serviceNamespace: z.ZodOptional<z.ZodString>;
+        /**
+         * Deployment environment
+         */
+        deploymentEnvironment: z.ZodOptional<z.ZodString>;
+        /**
+         * Additional resource attributes
+         */
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>>>;
+    }, "strip", z.ZodTypeAny, {
+        serviceName: string;
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+        serviceVersion?: string | undefined;
+        serviceInstanceId?: string | undefined;
+        serviceNamespace?: string | undefined;
+        deploymentEnvironment?: string | undefined;
+    }, {
+        serviceName: string;
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+        serviceVersion?: string | undefined;
+        serviceInstanceId?: string | undefined;
+        serviceNamespace?: string | undefined;
+        deploymentEnvironment?: string | undefined;
+    }>;
+    /**
+     * Instrumentation configuration
+     */
+    instrumentation: z.ZodOptional<z.ZodObject<{
+        /**
+         * Auto-instrumentation enabled
+         */
+        autoInstrumentation: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Instrumentation libraries to enable
+         */
+        libraries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Instrumentation libraries to disable
+         */
+        disabledLibraries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        autoInstrumentation: boolean;
+        libraries?: string[] | undefined;
+        disabledLibraries?: string[] | undefined;
+    }, {
+        autoInstrumentation?: boolean | undefined;
+        libraries?: string[] | undefined;
+        disabledLibraries?: string[] | undefined;
+    }>>;
+    /**
+     * Semantic conventions version
+     */
+    semanticConventionsVersion: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    resource: {
+        serviceName: string;
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+        serviceVersion?: string | undefined;
+        serviceInstanceId?: string | undefined;
+        serviceNamespace?: string | undefined;
+        deploymentEnvironment?: string | undefined;
+    };
+    exporter: {
+        type: "custom" | "console" | "datadog" | "jaeger" | "otlp_http" | "otlp_grpc" | "zipkin" | "honeycomb" | "lightstep" | "newrelic";
+        timeout: number;
+        compression: "none" | "gzip";
+        headers?: Record<string, string> | undefined;
+        batch?: {
+            maxBatchSize: number;
+            maxQueueSize: number;
+            exportTimeout: number;
+            scheduledDelay: number;
+        } | undefined;
+        endpoint?: string | undefined;
+        protocol?: string | undefined;
+    };
+    sdkVersion?: string | undefined;
+    instrumentation?: {
+        autoInstrumentation: boolean;
+        libraries?: string[] | undefined;
+        disabledLibraries?: string[] | undefined;
+    } | undefined;
+    semanticConventionsVersion?: string | undefined;
+}, {
+    resource: {
+        serviceName: string;
+        attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+        serviceVersion?: string | undefined;
+        serviceInstanceId?: string | undefined;
+        serviceNamespace?: string | undefined;
+        deploymentEnvironment?: string | undefined;
+    };
+    exporter: {
+        type: "custom" | "console" | "datadog" | "jaeger" | "otlp_http" | "otlp_grpc" | "zipkin" | "honeycomb" | "lightstep" | "newrelic";
+        headers?: Record<string, string> | undefined;
+        timeout?: number | undefined;
+        batch?: {
+            maxBatchSize?: number | undefined;
+            maxQueueSize?: number | undefined;
+            exportTimeout?: number | undefined;
+            scheduledDelay?: number | undefined;
+        } | undefined;
+        endpoint?: string | undefined;
+        compression?: "none" | "gzip" | undefined;
+        protocol?: string | undefined;
+    };
+    sdkVersion?: string | undefined;
+    instrumentation?: {
+        autoInstrumentation?: boolean | undefined;
+        libraries?: string[] | undefined;
+        disabledLibraries?: string[] | undefined;
+    } | undefined;
+    semanticConventionsVersion?: string | undefined;
+}>;
+export type OpenTelemetryCompatibility = z.infer<typeof OpenTelemetryCompatibilitySchema>;
+/**
+ * Tracing Configuration Schema
+ */
+export declare const TracingConfigSchema: z.ZodObject<{
+    /**
+     * Configuration name
+     */
+    name: z.ZodString;
+    /**
+     * Display label
+     */
+    label: z.ZodString;
+    /**
+     * Enable tracing
+     */
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Sampling configuration
+     */
+    sampling: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        /**
+         * Sampling strategy type
+         */
+        type: z.ZodEnum<["always_on", "always_off", "trace_id_ratio", "rate_limiting", "parent_based", "probability", "composite", "custom"]>;
+        /**
+         * Sample ratio (0.0 to 1.0) for trace_id_ratio and probability strategies
+         */
+        ratio: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Rate limit (traces per second) for rate_limiting strategy
+         */
+        rateLimit: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Parent-based configuration
+         */
+        parentBased: z.ZodOptional<z.ZodObject<{
+            /**
+             * Sampler to use when parent is sampled
+             */
+            whenParentSampled: z.ZodDefault<z.ZodOptional<z.ZodEnum<["always_on", "always_off", "trace_id_ratio", "rate_limiting", "parent_based", "probability", "composite", "custom"]>>>;
+            /**
+             * Sampler to use when parent is not sampled
+             */
+            whenParentNotSampled: z.ZodDefault<z.ZodOptional<z.ZodEnum<["always_on", "always_off", "trace_id_ratio", "rate_limiting", "parent_based", "probability", "composite", "custom"]>>>;
+            /**
+             * Sampler to use when there is no parent (root span)
+             */
+            root: z.ZodDefault<z.ZodOptional<z.ZodEnum<["always_on", "always_off", "trace_id_ratio", "rate_limiting", "parent_based", "probability", "composite", "custom"]>>>;
+            /**
+             * Root sampler ratio
+             */
+            rootRatio: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            whenParentSampled: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            whenParentNotSampled: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            root: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            rootRatio: number;
+        }, {
+            whenParentSampled?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+            whenParentNotSampled?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+            root?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+            rootRatio?: number | undefined;
+        }>>;
+        /**
+         * Composite sampling (multiple strategies)
+         */
+        composite: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            strategy: z.ZodEnum<["always_on", "always_off", "trace_id_ratio", "rate_limiting", "parent_based", "probability", "composite", "custom"]>;
+            ratio: z.ZodOptional<z.ZodNumber>;
+            condition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            strategy: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            condition?: Record<string, any> | undefined;
+            ratio?: number | undefined;
+        }, {
+            strategy: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            condition?: Record<string, any> | undefined;
+            ratio?: number | undefined;
+        }>, "many">>;
+        /**
+         * Sampling rules
+         */
+        rules: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            /**
+             * Rule name
+             */
+            name: z.ZodString;
+            /**
+             * Match condition
+             */
+            match: z.ZodOptional<z.ZodObject<{
+                /**
+                 * Service name pattern
+                 */
+                service: z.ZodOptional<z.ZodString>;
+                /**
+                 * Span name pattern (regex)
+                 */
+                spanName: z.ZodOptional<z.ZodString>;
+                /**
+                 * Attribute filters
+                 */
+                attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                attributes?: Record<string, any> | undefined;
+                service?: string | undefined;
+                spanName?: string | undefined;
+            }, {
+                attributes?: Record<string, any> | undefined;
+                service?: string | undefined;
+                spanName?: string | undefined;
+            }>>;
+            /**
+             * Sampling decision for matching spans
+             */
+            decision: z.ZodEnum<["drop", "record_only", "record_and_sample"]>;
+            /**
+             * Sample rate for this rule
+             */
+            rate: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            decision: "drop" | "record_only" | "record_and_sample";
+            rate?: number | undefined;
+            match?: {
+                attributes?: Record<string, any> | undefined;
+                service?: string | undefined;
+                spanName?: string | undefined;
+            } | undefined;
+        }, {
+            name: string;
+            decision: "drop" | "record_only" | "record_and_sample";
+            rate?: number | undefined;
+            match?: {
+                attributes?: Record<string, any> | undefined;
+                service?: string | undefined;
+                spanName?: string | undefined;
+            } | undefined;
+        }>, "many">>>;
+        /**
+         * Custom sampler ID (for custom strategy)
+         */
+        customSamplerId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        rules: {
+            name: string;
+            decision: "drop" | "record_only" | "record_and_sample";
+            rate?: number | undefined;
+            match?: {
+                attributes?: Record<string, any> | undefined;
+                service?: string | undefined;
+                spanName?: string | undefined;
+            } | undefined;
+        }[];
+        rateLimit?: number | undefined;
+        ratio?: number | undefined;
+        composite?: {
+            strategy: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            condition?: Record<string, any> | undefined;
+            ratio?: number | undefined;
+        }[] | undefined;
+        parentBased?: {
+            whenParentSampled: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            whenParentNotSampled: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            root: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            rootRatio: number;
+        } | undefined;
+        customSamplerId?: string | undefined;
+    }, {
+        type: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        rules?: {
+            name: string;
+            decision: "drop" | "record_only" | "record_and_sample";
+            rate?: number | undefined;
+            match?: {
+                attributes?: Record<string, any> | undefined;
+                service?: string | undefined;
+                spanName?: string | undefined;
+            } | undefined;
+        }[] | undefined;
+        rateLimit?: number | undefined;
+        ratio?: number | undefined;
+        composite?: {
+            strategy: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            condition?: Record<string, any> | undefined;
+            ratio?: number | undefined;
+        }[] | undefined;
+        parentBased?: {
+            whenParentSampled?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+            whenParentNotSampled?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+            root?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+            rootRatio?: number | undefined;
+        } | undefined;
+        customSamplerId?: string | undefined;
+    }>>>;
+    /**
+     * Context propagation
+     */
+    propagation: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        /**
+         * Propagation formats (in priority order)
+         */
+        formats: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["w3c", "b3", "b3_multi", "jaeger", "xray", "ottrace", "custom"]>, "many">>>;
+        /**
+         * Extract context from incoming requests
+         */
+        extract: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Inject context into outgoing requests
+         */
+        inject: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Custom header mappings
+         */
+        headers: z.ZodOptional<z.ZodObject<{
+            /**
+             * Trace ID header name
+             */
+            traceId: z.ZodOptional<z.ZodString>;
+            /**
+             * Span ID header name
+             */
+            spanId: z.ZodOptional<z.ZodString>;
+            /**
+             * Trace flags header name
+             */
+            traceFlags: z.ZodOptional<z.ZodString>;
+            /**
+             * Trace state header name
+             */
+            traceState: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            traceId?: string | undefined;
+            spanId?: string | undefined;
+            traceFlags?: string | undefined;
+            traceState?: string | undefined;
+        }, {
+            traceId?: string | undefined;
+            spanId?: string | undefined;
+            traceFlags?: string | undefined;
+            traceState?: string | undefined;
+        }>>;
+        /**
+         * Baggage propagation
+         */
+        baggage: z.ZodOptional<z.ZodObject<{
+            /**
+             * Enable baggage propagation
+             */
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            /**
+             * Maximum baggage size in bytes
+             */
+            maxSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            /**
+             * Allowed baggage keys (whitelist)
+             */
+            allowedKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            maxSize: number;
+            allowedKeys?: string[] | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            maxSize?: number | undefined;
+            allowedKeys?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        formats: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[];
+        extract: boolean;
+        inject: boolean;
+        headers?: {
+            traceId?: string | undefined;
+            spanId?: string | undefined;
+            traceFlags?: string | undefined;
+            traceState?: string | undefined;
+        } | undefined;
+        baggage?: {
+            enabled: boolean;
+            maxSize: number;
+            allowedKeys?: string[] | undefined;
+        } | undefined;
+    }, {
+        headers?: {
+            traceId?: string | undefined;
+            spanId?: string | undefined;
+            traceFlags?: string | undefined;
+            traceState?: string | undefined;
+        } | undefined;
+        formats?: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[] | undefined;
+        extract?: boolean | undefined;
+        inject?: boolean | undefined;
+        baggage?: {
+            enabled?: boolean | undefined;
+            maxSize?: number | undefined;
+            allowedKeys?: string[] | undefined;
+        } | undefined;
+    }>>>;
+    /**
+     * OpenTelemetry configuration
+     */
+    openTelemetry: z.ZodOptional<z.ZodObject<{
+        /**
+         * OpenTelemetry SDK version
+         */
+        sdkVersion: z.ZodOptional<z.ZodString>;
+        /**
+         * Exporter configuration
+         */
+        exporter: z.ZodObject<{
+            /**
+             * Exporter type
+             */
+            type: z.ZodEnum<["otlp_http", "otlp_grpc", "jaeger", "zipkin", "console", "datadog", "honeycomb", "lightstep", "newrelic", "custom"]>;
+            /**
+             * Endpoint URL
+             */
+            endpoint: z.ZodOptional<z.ZodString>;
+            /**
+             * Protocol version
+             */
+            protocol: z.ZodOptional<z.ZodString>;
+            /**
+             * Headers
+             */
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            /**
+             * Timeout in milliseconds
+             */
+            timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            /**
+             * Compression
+             */
+            compression: z.ZodDefault<z.ZodOptional<z.ZodEnum<["none", "gzip"]>>>;
+            /**
+             * Batch configuration
+             */
+            batch: z.ZodOptional<z.ZodObject<{
+                /**
+                 * Maximum batch size
+                 */
+                maxBatchSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+                /**
+                 * Maximum queue size
+                 */
+                maxQueueSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+                /**
+                 * Export timeout in milliseconds
+                 */
+                exportTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+                /**
+                 * Scheduled delay in milliseconds
+                 */
+                scheduledDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            }, "strip", z.ZodTypeAny, {
+                maxBatchSize: number;
+                maxQueueSize: number;
+                exportTimeout: number;
+                scheduledDelay: number;
+            }, {
+                maxBatchSize?: number | undefined;
+                maxQueueSize?: number | undefined;
+                exportTimeout?: number | undefined;
+                scheduledDelay?: number | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "custom" | "console" | "datadog" | "jaeger" | "otlp_http" | "otlp_grpc" | "zipkin" | "honeycomb" | "lightstep" | "newrelic";
+            timeout: number;
+            compression: "none" | "gzip";
+            headers?: Record<string, string> | undefined;
+            batch?: {
+                maxBatchSize: number;
+                maxQueueSize: number;
+                exportTimeout: number;
+                scheduledDelay: number;
+            } | undefined;
+            endpoint?: string | undefined;
+            protocol?: string | undefined;
+        }, {
+            type: "custom" | "console" | "datadog" | "jaeger" | "otlp_http" | "otlp_grpc" | "zipkin" | "honeycomb" | "lightstep" | "newrelic";
+            headers?: Record<string, string> | undefined;
+            timeout?: number | undefined;
+            batch?: {
+                maxBatchSize?: number | undefined;
+                maxQueueSize?: number | undefined;
+                exportTimeout?: number | undefined;
+                scheduledDelay?: number | undefined;
+            } | undefined;
+            endpoint?: string | undefined;
+            compression?: "none" | "gzip" | undefined;
+            protocol?: string | undefined;
+        }>;
+        /**
+         * Resource attributes (service identification)
+         */
+        resource: z.ZodObject<{
+            /**
+             * Service name
+             */
+            serviceName: z.ZodString;
+            /**
+             * Service version
+             */
+            serviceVersion: z.ZodOptional<z.ZodString>;
+            /**
+             * Service instance ID
+             */
+            serviceInstanceId: z.ZodOptional<z.ZodString>;
+            /**
+             * Service namespace
+             */
+            serviceNamespace: z.ZodOptional<z.ZodString>;
+            /**
+             * Deployment environment
+             */
+            deploymentEnvironment: z.ZodOptional<z.ZodString>;
+            /**
+             * Additional resource attributes
+             */
+            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">]>>>;
+        }, "strip", z.ZodTypeAny, {
+            serviceName: string;
+            attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+            serviceVersion?: string | undefined;
+            serviceInstanceId?: string | undefined;
+            serviceNamespace?: string | undefined;
+            deploymentEnvironment?: string | undefined;
+        }, {
+            serviceName: string;
+            attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+            serviceVersion?: string | undefined;
+            serviceInstanceId?: string | undefined;
+            serviceNamespace?: string | undefined;
+            deploymentEnvironment?: string | undefined;
+        }>;
+        /**
+         * Instrumentation configuration
+         */
+        instrumentation: z.ZodOptional<z.ZodObject<{
+            /**
+             * Auto-instrumentation enabled
+             */
+            autoInstrumentation: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            /**
+             * Instrumentation libraries to enable
+             */
+            libraries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /**
+             * Instrumentation libraries to disable
+             */
+            disabledLibraries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            autoInstrumentation: boolean;
+            libraries?: string[] | undefined;
+            disabledLibraries?: string[] | undefined;
+        }, {
+            autoInstrumentation?: boolean | undefined;
+            libraries?: string[] | undefined;
+            disabledLibraries?: string[] | undefined;
+        }>>;
+        /**
+         * Semantic conventions version
+         */
+        semanticConventionsVersion: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        resource: {
+            serviceName: string;
+            attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+            serviceVersion?: string | undefined;
+            serviceInstanceId?: string | undefined;
+            serviceNamespace?: string | undefined;
+            deploymentEnvironment?: string | undefined;
+        };
+        exporter: {
+            type: "custom" | "console" | "datadog" | "jaeger" | "otlp_http" | "otlp_grpc" | "zipkin" | "honeycomb" | "lightstep" | "newrelic";
+            timeout: number;
+            compression: "none" | "gzip";
+            headers?: Record<string, string> | undefined;
+            batch?: {
+                maxBatchSize: number;
+                maxQueueSize: number;
+                exportTimeout: number;
+                scheduledDelay: number;
+            } | undefined;
+            endpoint?: string | undefined;
+            protocol?: string | undefined;
+        };
+        sdkVersion?: string | undefined;
+        instrumentation?: {
+            autoInstrumentation: boolean;
+            libraries?: string[] | undefined;
+            disabledLibraries?: string[] | undefined;
+        } | undefined;
+        semanticConventionsVersion?: string | undefined;
+    }, {
+        resource: {
+            serviceName: string;
+            attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+            serviceVersion?: string | undefined;
+            serviceInstanceId?: string | undefined;
+            serviceNamespace?: string | undefined;
+            deploymentEnvironment?: string | undefined;
+        };
+        exporter: {
+            type: "custom" | "console" | "datadog" | "jaeger" | "otlp_http" | "otlp_grpc" | "zipkin" | "honeycomb" | "lightstep" | "newrelic";
+            headers?: Record<string, string> | undefined;
+            timeout?: number | undefined;
+            batch?: {
+                maxBatchSize?: number | undefined;
+                maxQueueSize?: number | undefined;
+                exportTimeout?: number | undefined;
+                scheduledDelay?: number | undefined;
+            } | undefined;
+            endpoint?: string | undefined;
+            compression?: "none" | "gzip" | undefined;
+            protocol?: string | undefined;
+        };
+        sdkVersion?: string | undefined;
+        instrumentation?: {
+            autoInstrumentation?: boolean | undefined;
+            libraries?: string[] | undefined;
+            disabledLibraries?: string[] | undefined;
+        } | undefined;
+        semanticConventionsVersion?: string | undefined;
+    }>>;
+    /**
+     * Span limits
+     */
+    spanLimits: z.ZodOptional<z.ZodObject<{
+        /**
+         * Maximum number of attributes per span
+         */
+        maxAttributes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Maximum number of events per span
+         */
+        maxEvents: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Maximum number of links per span
+         */
+        maxLinks: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Maximum attribute value length
+         */
+        maxAttributeValueLength: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttributes: number;
+        maxEvents: number;
+        maxLinks: number;
+        maxAttributeValueLength: number;
+    }, {
+        maxAttributes?: number | undefined;
+        maxEvents?: number | undefined;
+        maxLinks?: number | undefined;
+        maxAttributeValueLength?: number | undefined;
+    }>>;
+    /**
+     * Trace ID generator
+     */
+    traceIdGenerator: z.ZodDefault<z.ZodOptional<z.ZodEnum<["random", "uuid", "custom"]>>>;
+    /**
+     * Custom trace ID generator ID
+     */
+    customTraceIdGeneratorId: z.ZodOptional<z.ZodString>;
+    /**
+     * Performance configuration
+     */
+    performance: z.ZodOptional<z.ZodObject<{
+        /**
+         * Async span export
+         */
+        asyncExport: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Background export interval in milliseconds
+         */
+        exportInterval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        asyncExport: boolean;
+        exportInterval: number;
+    }, {
+        asyncExport?: boolean | undefined;
+        exportInterval?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    label: string;
+    name: string;
+    sampling: {
+        type: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        rules: {
+            name: string;
+            decision: "drop" | "record_only" | "record_and_sample";
+            rate?: number | undefined;
+            match?: {
+                attributes?: Record<string, any> | undefined;
+                service?: string | undefined;
+                spanName?: string | undefined;
+            } | undefined;
+        }[];
+        rateLimit?: number | undefined;
+        ratio?: number | undefined;
+        composite?: {
+            strategy: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            condition?: Record<string, any> | undefined;
+            ratio?: number | undefined;
+        }[] | undefined;
+        parentBased?: {
+            whenParentSampled: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            whenParentNotSampled: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            root: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            rootRatio: number;
+        } | undefined;
+        customSamplerId?: string | undefined;
+    };
+    propagation: {
+        formats: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[];
+        extract: boolean;
+        inject: boolean;
+        headers?: {
+            traceId?: string | undefined;
+            spanId?: string | undefined;
+            traceFlags?: string | undefined;
+            traceState?: string | undefined;
+        } | undefined;
+        baggage?: {
+            enabled: boolean;
+            maxSize: number;
+            allowedKeys?: string[] | undefined;
+        } | undefined;
+    };
+    traceIdGenerator: "custom" | "uuid" | "random";
+    performance?: {
+        asyncExport: boolean;
+        exportInterval: number;
+    } | undefined;
+    openTelemetry?: {
+        resource: {
+            serviceName: string;
+            attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+            serviceVersion?: string | undefined;
+            serviceInstanceId?: string | undefined;
+            serviceNamespace?: string | undefined;
+            deploymentEnvironment?: string | undefined;
+        };
+        exporter: {
+            type: "custom" | "console" | "datadog" | "jaeger" | "otlp_http" | "otlp_grpc" | "zipkin" | "honeycomb" | "lightstep" | "newrelic";
+            timeout: number;
+            compression: "none" | "gzip";
+            headers?: Record<string, string> | undefined;
+            batch?: {
+                maxBatchSize: number;
+                maxQueueSize: number;
+                exportTimeout: number;
+                scheduledDelay: number;
+            } | undefined;
+            endpoint?: string | undefined;
+            protocol?: string | undefined;
+        };
+        sdkVersion?: string | undefined;
+        instrumentation?: {
+            autoInstrumentation: boolean;
+            libraries?: string[] | undefined;
+            disabledLibraries?: string[] | undefined;
+        } | undefined;
+        semanticConventionsVersion?: string | undefined;
+    } | undefined;
+    spanLimits?: {
+        maxAttributes: number;
+        maxEvents: number;
+        maxLinks: number;
+        maxAttributeValueLength: number;
+    } | undefined;
+    customTraceIdGeneratorId?: string | undefined;
+}, {
+    label: string;
+    name: string;
+    enabled?: boolean | undefined;
+    sampling?: {
+        type: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+        rules?: {
+            name: string;
+            decision: "drop" | "record_only" | "record_and_sample";
+            rate?: number | undefined;
+            match?: {
+                attributes?: Record<string, any> | undefined;
+                service?: string | undefined;
+                spanName?: string | undefined;
+            } | undefined;
+        }[] | undefined;
+        rateLimit?: number | undefined;
+        ratio?: number | undefined;
+        composite?: {
+            strategy: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite";
+            condition?: Record<string, any> | undefined;
+            ratio?: number | undefined;
+        }[] | undefined;
+        parentBased?: {
+            whenParentSampled?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+            whenParentNotSampled?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+            root?: "custom" | "always_on" | "always_off" | "trace_id_ratio" | "rate_limiting" | "parent_based" | "probability" | "composite" | undefined;
+            rootRatio?: number | undefined;
+        } | undefined;
+        customSamplerId?: string | undefined;
+    } | undefined;
+    performance?: {
+        asyncExport?: boolean | undefined;
+        exportInterval?: number | undefined;
+    } | undefined;
+    propagation?: {
+        headers?: {
+            traceId?: string | undefined;
+            spanId?: string | undefined;
+            traceFlags?: string | undefined;
+            traceState?: string | undefined;
+        } | undefined;
+        formats?: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[] | undefined;
+        extract?: boolean | undefined;
+        inject?: boolean | undefined;
+        baggage?: {
+            enabled?: boolean | undefined;
+            maxSize?: number | undefined;
+            allowedKeys?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    openTelemetry?: {
+        resource: {
+            serviceName: string;
+            attributes?: Record<string, string | number | boolean | string[] | number[] | boolean[]> | undefined;
+            serviceVersion?: string | undefined;
+            serviceInstanceId?: string | undefined;
+            serviceNamespace?: string | undefined;
+            deploymentEnvironment?: string | undefined;
+        };
+        exporter: {
+            type: "custom" | "console" | "datadog" | "jaeger" | "otlp_http" | "otlp_grpc" | "zipkin" | "honeycomb" | "lightstep" | "newrelic";
+            headers?: Record<string, string> | undefined;
+            timeout?: number | undefined;
+            batch?: {
+                maxBatchSize?: number | undefined;
+                maxQueueSize?: number | undefined;
+                exportTimeout?: number | undefined;
+                scheduledDelay?: number | undefined;
+            } | undefined;
+            endpoint?: string | undefined;
+            compression?: "none" | "gzip" | undefined;
+            protocol?: string | undefined;
+        };
+        sdkVersion?: string | undefined;
+        instrumentation?: {
+            autoInstrumentation?: boolean | undefined;
+            libraries?: string[] | undefined;
+            disabledLibraries?: string[] | undefined;
+        } | undefined;
+        semanticConventionsVersion?: string | undefined;
+    } | undefined;
+    spanLimits?: {
+        maxAttributes?: number | undefined;
+        maxEvents?: number | undefined;
+        maxLinks?: number | undefined;
+        maxAttributeValueLength?: number | undefined;
+    } | undefined;
+    traceIdGenerator?: "custom" | "uuid" | "random" | undefined;
+    customTraceIdGeneratorId?: string | undefined;
+}>;
+export type TracingConfig = z.infer<typeof TracingConfigSchema>;
+//# sourceMappingURL=tracing.zod.d.ts.map