@objectstack/spec 0.9.1 → 1.0.0

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

@@ -14,8 +14,15 @@ import { z } from 'zod';
  * W3C Trace Context tracestate header
  */
 export declare const TraceStateSchema: z.ZodObject<{
+    /**
+     * Vendor-specific key-value pairs
+     */
     entries: z.ZodRecord<z.ZodString, z.ZodString>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    entries: Record<string, string>;
+}, {
+    entries: Record<string, string>;
+}>;
 export type TraceState = z.infer<typeof TraceStateSchema>;
 /**
  * Trace Flags Enum
@@ -28,517 +35,1847 @@ export type TraceFlags = z.infer<typeof TraceFlagsSchema>;
  * 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>;
-    }, z.core.$strip>>;
+    }, "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>>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    remote: boolean;
+    traceId: string;
+    spanId: string;
+    traceFlags: number;
+    sampled: boolean;
+    parentSpanId?: string | undefined;
+    traceState?: {
+        entries: Record<string, string>;
+    } | undefined;
+}, {
+    traceId: string;
+    spanId: string;
+    remote?: boolean | undefined;
+    parentSpanId?: string | undefined;
+    traceFlags?: number | undefined;
+    traceState?: {
+        entries: Record<string, string>;
+    } | undefined;
+    sampled?: boolean | undefined;
+}>;
 export type TraceContext = z.infer<typeof TraceContextSchema>;
 /**
  * Span Kind Enum
  * OpenTelemetry span kinds
  */
-export declare const SpanKind: z.ZodEnum<{
-    internal: "internal";
-    server: "server";
-    client: "client";
-    producer: "producer";
-    consumer: "consumer";
-}>;
+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<{
-    error: "error";
-    unset: "unset";
-    ok: "ok";
-}>;
+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<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>, z.ZodArray<z.ZodBoolean>]>;
+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<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>, z.ZodArray<z.ZodBoolean>]>>;
+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;
-    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>, z.ZodArray<z.ZodBoolean>]>>>;
-}, z.core.$strip>;
+    /**
+     * 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>;
-        }, z.core.$strip>>;
+        }, "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>>;
-    }, z.core.$strip>;
-    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>, z.ZodArray<z.ZodBoolean>]>>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        remote: boolean;
+        traceId: string;
+        spanId: string;
+        traceFlags: number;
+        sampled: boolean;
+        parentSpanId?: string | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+    }, {
+        traceId: string;
+        spanId: string;
+        remote?: boolean | undefined;
+        parentSpanId?: string | undefined;
+        traceFlags?: number | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+        sampled?: 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: {
+        remote: boolean;
+        traceId: string;
+        spanId: string;
+        traceFlags: number;
+        sampled: 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;
+        remote?: boolean | undefined;
+        parentSpanId?: string | undefined;
+        traceFlags?: number | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+        sampled?: 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>;
-        }, z.core.$strip>>;
+        }, "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>>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        remote: boolean;
+        traceId: string;
+        spanId: string;
+        traceFlags: number;
+        sampled: boolean;
+        parentSpanId?: string | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+    }, {
+        traceId: string;
+        spanId: string;
+        remote?: boolean | undefined;
+        parentSpanId?: string | undefined;
+        traceFlags?: number | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+        sampled?: boolean | undefined;
+    }>;
+    /**
+     * Span name
+     */
     name: z.ZodString;
-    kind: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        internal: "internal";
-        server: "server";
-        client: "client";
-        producer: "producer";
-        consumer: "consumer";
-    }>>>;
+    /**
+     * 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<{
-            error: "error";
-            unset: "unset";
-            ok: "ok";
-        }>;
+        code: z.ZodEnum<["unset", "ok", "error"]>;
         message: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    attributes: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>, z.ZodArray<z.ZodBoolean>]>>>>;
+    }, "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;
-        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>, z.ZodArray<z.ZodBoolean>]>>>;
-    }, z.core.$strip>>>>;
+        /**
+         * 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>;
-            }, z.core.$strip>>;
+            }, "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>>;
-        }, z.core.$strip>;
-        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>, z.ZodArray<z.ZodBoolean>]>>>;
-    }, z.core.$strip>>>>;
-    resource: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>, z.ZodArray<z.ZodBoolean>]>>>;
+        }, "strip", z.ZodTypeAny, {
+            remote: boolean;
+            traceId: string;
+            spanId: string;
+            traceFlags: number;
+            sampled: boolean;
+            parentSpanId?: string | undefined;
+            traceState?: {
+                entries: Record<string, string>;
+            } | undefined;
+        }, {
+            traceId: string;
+            spanId: string;
+            remote?: boolean | undefined;
+            parentSpanId?: string | undefined;
+            traceFlags?: number | undefined;
+            traceState?: {
+                entries: Record<string, string>;
+            } | undefined;
+            sampled?: 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: {
+            remote: boolean;
+            traceId: string;
+            spanId: string;
+            traceFlags: number;
+            sampled: 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;
+            remote?: boolean | undefined;
+            parentSpanId?: string | undefined;
+            traceFlags?: number | undefined;
+            traceState?: {
+                entries: Record<string, string>;
+            } | undefined;
+            sampled?: 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>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "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: {
+        remote: boolean;
+        traceId: string;
+        spanId: string;
+        traceFlags: number;
+        sampled: boolean;
+        parentSpanId?: string | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+    };
+    startTime: string;
+    kind: "server" | "internal" | "client" | "producer" | "consumer";
+    links: {
+        context: {
+            remote: boolean;
+            traceId: string;
+            spanId: string;
+            traceFlags: number;
+            sampled: 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;
+        remote?: boolean | undefined;
+        parentSpanId?: string | undefined;
+        traceFlags?: number | undefined;
+        traceState?: {
+            entries: Record<string, string>;
+        } | undefined;
+        sampled?: boolean | undefined;
+    };
+    startTime: string;
+    status?: {
+        code: "error" | "unset" | "ok";
+        message?: string | undefined;
+    } | undefined;
+    duration?: number | 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;
+    endTime?: string | undefined;
+    kind?: "server" | "internal" | "client" | "producer" | "consumer" | undefined;
+    links?: {
+        context: {
+            traceId: string;
+            spanId: string;
+            remote?: boolean | undefined;
+            parentSpanId?: string | undefined;
+            traceFlags?: number | undefined;
+            traceState?: {
+                entries: Record<string, string>;
+            } | undefined;
+            sampled?: 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: "drop";
-    record_only: "record_only";
-    record_and_sample: "record_and_sample";
-}>;
+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<{
-    custom: "custom";
-    always_on: "always_on";
-    always_off: "always_off";
-    trace_id_ratio: "trace_id_ratio";
-    rate_limiting: "rate_limiting";
-    parent_based: "parent_based";
-    probability: "probability";
-    composite: "composite";
-}>;
+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<{
-    type: z.ZodEnum<{
-        custom: "custom";
-        always_on: "always_on";
-        always_off: "always_off";
-        trace_id_ratio: "trace_id_ratio";
-        rate_limiting: "rate_limiting";
-        parent_based: "parent_based";
-        probability: "probability";
-        composite: "composite";
-    }>;
+    /**
+     * 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<{
-        whenParentSampled: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            custom: "custom";
-            always_on: "always_on";
-            always_off: "always_off";
-            trace_id_ratio: "trace_id_ratio";
-            rate_limiting: "rate_limiting";
-            parent_based: "parent_based";
-            probability: "probability";
-            composite: "composite";
-        }>>>;
-        whenParentNotSampled: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            custom: "custom";
-            always_on: "always_on";
-            always_off: "always_off";
-            trace_id_ratio: "trace_id_ratio";
-            rate_limiting: "rate_limiting";
-            parent_based: "parent_based";
-            probability: "probability";
-            composite: "composite";
-        }>>>;
-        root: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            custom: "custom";
-            always_on: "always_on";
-            always_off: "always_off";
-            trace_id_ratio: "trace_id_ratio";
-            rate_limiting: "rate_limiting";
-            parent_based: "parent_based";
-            probability: "probability";
-            composite: "composite";
-        }>>>;
+        /**
+         * 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>>;
-    }, z.core.$strip>>;
+    }, "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<{
-            custom: "custom";
-            always_on: "always_on";
-            always_off: "always_off";
-            trace_id_ratio: "trace_id_ratio";
-            rate_limiting: "rate_limiting";
-            parent_based: "parent_based";
-            probability: "probability";
-            composite: "composite";
-        }>;
+        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>>;
-    }, z.core.$strip>>>;
+    }, "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>>;
-        }, z.core.$strip>>;
-        decision: z.ZodEnum<{
-            drop: "drop";
-            record_only: "record_only";
-            record_and_sample: "record_and_sample";
-        }>;
+        }, "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>;
-    }, z.core.$strip>>>>;
+    }, "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>;
-}, z.core.$strip>;
+}, "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<{
-    custom: "custom";
-    w3c: "w3c";
-    b3: "b3";
-    b3_multi: "b3_multi";
-    jaeger: "jaeger";
-    xray: "xray";
-    ottrace: "ottrace";
-}>;
+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<{
-    formats: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        custom: "custom";
-        w3c: "w3c";
-        b3: "b3";
-        b3_multi: "b3_multi";
-        jaeger: "jaeger";
-        xray: "xray";
-        ottrace: "ottrace";
-    }>>>>;
+    /**
+     * 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>;
-    }, z.core.$strip>>;
+    }, "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>>;
-        allowedKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+        /**
+         * 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, {
+    extract: boolean;
+    formats: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[];
+    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;
+    extract?: boolean | undefined;
+    formats?: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[] | 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<{
-    custom: "custom";
-    console: "console";
-    datadog: "datadog";
-    jaeger: "jaeger";
-    otlp_http: "otlp_http";
-    otlp_grpc: "otlp_grpc";
-    zipkin: "zipkin";
-    honeycomb: "honeycomb";
-    lightstep: "lightstep";
-    newrelic: "newrelic";
-}>;
+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<{
-        type: z.ZodEnum<{
-            custom: "custom";
-            console: "console";
-            datadog: "datadog";
-            jaeger: "jaeger";
-            otlp_http: "otlp_http";
-            otlp_grpc: "otlp_grpc";
-            zipkin: "zipkin";
-            honeycomb: "honeycomb";
-            lightstep: "lightstep";
-            newrelic: "newrelic";
-        }>;
+        /**
+         * 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: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            none: "none";
-            gzip: "gzip";
-        }>>>;
+        /**
+         * 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>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+        }, "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>;
-        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>, z.ZodArray<z.ZodBoolean>]>>>;
-    }, z.core.$strip>;
+        /**
+         * 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>>;
-        libraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        disabledLibraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
+        /**
+         * 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>;
-}, z.core.$strip>;
+}, "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<{
-        type: z.ZodEnum<{
-            custom: "custom";
-            always_on: "always_on";
-            always_off: "always_off";
-            trace_id_ratio: "trace_id_ratio";
-            rate_limiting: "rate_limiting";
-            parent_based: "parent_based";
-            probability: "probability";
-            composite: "composite";
-        }>;
+        /**
+         * 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<{
-            whenParentSampled: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-                custom: "custom";
-                always_on: "always_on";
-                always_off: "always_off";
-                trace_id_ratio: "trace_id_ratio";
-                rate_limiting: "rate_limiting";
-                parent_based: "parent_based";
-                probability: "probability";
-                composite: "composite";
-            }>>>;
-            whenParentNotSampled: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-                custom: "custom";
-                always_on: "always_on";
-                always_off: "always_off";
-                trace_id_ratio: "trace_id_ratio";
-                rate_limiting: "rate_limiting";
-                parent_based: "parent_based";
-                probability: "probability";
-                composite: "composite";
-            }>>>;
-            root: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-                custom: "custom";
-                always_on: "always_on";
-                always_off: "always_off";
-                trace_id_ratio: "trace_id_ratio";
-                rate_limiting: "rate_limiting";
-                parent_based: "parent_based";
-                probability: "probability";
-                composite: "composite";
-            }>>>;
+            /**
+             * 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>>;
-        }, z.core.$strip>>;
+        }, "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<{
-                custom: "custom";
-                always_on: "always_on";
-                always_off: "always_off";
-                trace_id_ratio: "trace_id_ratio";
-                rate_limiting: "rate_limiting";
-                parent_based: "parent_based";
-                probability: "probability";
-                composite: "composite";
-            }>;
+            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>>;
-        }, z.core.$strip>>>;
+        }, "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>>;
-            }, z.core.$strip>>;
-            decision: z.ZodEnum<{
-                drop: "drop";
-                record_only: "record_only";
-                record_and_sample: "record_and_sample";
-            }>;
+            }, "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>;
-        }, z.core.$strip>>>>;
+        }, "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>;
-    }, z.core.$strip>>>;
+    }, "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<{
-        formats: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<{
-            custom: "custom";
-            w3c: "w3c";
-            b3: "b3";
-            b3_multi: "b3_multi";
-            jaeger: "jaeger";
-            xray: "xray";
-            ottrace: "ottrace";
-        }>>>>;
+        /**
+         * 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>;
-        }, z.core.$strip>>;
+        }, "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>>;
-            allowedKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>>;
+            /**
+             * 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, {
+        extract: boolean;
+        formats: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[];
+        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;
+        extract?: boolean | undefined;
+        formats?: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[] | 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<{
-            type: z.ZodEnum<{
-                custom: "custom";
-                console: "console";
-                datadog: "datadog";
-                jaeger: "jaeger";
-                otlp_http: "otlp_http";
-                otlp_grpc: "otlp_grpc";
-                zipkin: "zipkin";
-                honeycomb: "honeycomb";
-                lightstep: "lightstep";
-                newrelic: "newrelic";
-            }>;
+            /**
+             * 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: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-                none: "none";
-                gzip: "gzip";
-            }>>>;
+            /**
+             * 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>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
+            }, "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>;
-            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>, z.ZodArray<z.ZodBoolean>]>>>;
-        }, z.core.$strip>;
+            /**
+             * 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>>;
-            libraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            disabledLibraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
+            /**
+             * 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>;
-    }, z.core.$strip>>;
+    }, "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>>;
-    }, z.core.$strip>>;
-    traceIdGenerator: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        custom: "custom";
-        uuid: "uuid";
-        random: "random";
-    }>>>;
+    }, "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>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "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: {
+        extract: boolean;
+        formats: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[];
+        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;
+        extract?: boolean | undefined;
+        formats?: ("custom" | "w3c" | "b3" | "b3_multi" | "jaeger" | "xray" | "ottrace")[] | 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