@uploadista/observability 0.0.3 → 0.0.4

package/dist/index.d.cts

@@ -0,0 +1,736 @@
+import { Context, Effect, Layer, Metric, Option } from "effect";
+import * as effect_MetricKeyType19 from "effect/MetricKeyType";
+import * as effect_MetricState19 from "effect/MetricState";
+import * as effect_Tracer0 from "effect/Tracer";
+import * as _effect_opentelemetry_Resource0 from "@effect/opentelemetry/Resource";
+import * as effect_Metric0 from "effect/Metric";
+
+//#region src/core/metrics.d.ts
+declare const createUploadMetrics: (storageType: string) => {
+  uploadRequestsTotal: Metric.Metric.Counter<number>;
+  uploadPartsTotal: Metric.Metric.Counter<number>;
+  uploadSuccessTotal: Metric.Metric.Counter<number>;
+  uploadErrorsTotal: Metric.Metric.Counter<number>;
+  apiCallsTotal: Metric.Metric.Counter<number>;
+};
+declare const createUploadHistograms: (storageType: string) => {
+  uploadDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partUploadDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  fileSizeHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partSizeHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+};
+declare const createUploadGauges: (storageType: string) => {
+  activeUploadsGauge: Metric.Metric.Gauge<number>;
+  uploadThroughputGauge: Metric.Metric.Gauge<number>;
+};
+declare const createUploadSummaries: (storageType: string) => {
+  uploadLatencySummary: Metric.Metric.Summary<number>;
+};
+declare const createStorageMetrics: (storageType: string) => {
+  uploadLatencySummary: Metric.Metric.Summary<number>;
+  activeUploadsGauge: Metric.Metric.Gauge<number>;
+  uploadThroughputGauge: Metric.Metric.Gauge<number>;
+  uploadDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partUploadDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  fileSizeHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partSizeHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  uploadRequestsTotal: Metric.Metric.Counter<number>;
+  uploadPartsTotal: Metric.Metric.Counter<number>;
+  uploadSuccessTotal: Metric.Metric.Counter<number>;
+  uploadErrorsTotal: Metric.Metric.Counter<number>;
+  apiCallsTotal: Metric.Metric.Counter<number>;
+};
+type StorageMetrics = ReturnType<typeof createStorageMetrics>;
+//#endregion
+//#region src/core/errors.d.ts
+type StorageErrorCategory = "network_error" | "authentication_error" | "authorization_error" | "throttling_error" | "server_error" | "client_error" | "unknown_error";
+declare const classifyStorageError: (error: unknown) => StorageErrorCategory;
+declare const createStorageErrorClassifier: (storageType: string, customErrorMapping?: (error: unknown) => StorageErrorCategory | null) => (error: unknown) => StorageErrorCategory;
+declare const trackStorageError: (storageType: string, metrics: StorageMetrics, operation: string, error: unknown, context?: Record<string, unknown>, errorClassifier?: (error: unknown) => StorageErrorCategory) => Effect.Effect<void, never, never>;
+declare const createStorageErrorTracker: (storageType: string, metrics: StorageMetrics, customErrorClassifier?: (error: unknown) => StorageErrorCategory | null) => (operation: string, error: unknown, context?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+//#endregion
+//#region src/core/layers.d.ts
+/**
+ * Core observability service providing tracing, metrics, and logging capabilities
+ */
+interface ObservabilityService {
+  readonly serviceName: string;
+  readonly enabled: boolean;
+}
+declare const Observability_base: Context.TagClass<Observability, "Observability", ObservabilityService>;
+/**
+ * Observability service tag for Effect Context
+ */
+declare class Observability extends Observability_base {}
+/**
+ * Storage observability service extending base observability with storage-specific metrics
+ */
+interface StorageObservabilityService extends ObservabilityService {
+  readonly storageType: string;
+  readonly metrics: StorageMetrics;
+}
+declare const StorageObservability_base: Context.TagClass<StorageObservability, "StorageObservability", StorageObservabilityService>;
+/**
+ * Storage observability service tag
+ */
+declare class StorageObservability extends StorageObservability_base {}
+/**
+ * Upload observability service for upload-specific operations
+ */
+interface UploadObservabilityService extends ObservabilityService {
+  readonly metrics: {
+    uploadCreated: Effect.Effect<void>;
+    uploadCompleted: Effect.Effect<void>;
+    uploadFailed: Effect.Effect<void>;
+    chunkUploaded: Effect.Effect<void>;
+  };
+}
+declare const UploadObservability_base: Context.TagClass<UploadObservability, "UploadObservability", UploadObservabilityService>;
+/**
+ * Upload observability service tag
+ */
+declare class UploadObservability extends UploadObservability_base {}
+/**
+ * Flow observability service for flow execution operations
+ */
+interface FlowObservabilityService extends ObservabilityService {
+  readonly metrics: {
+    flowStarted: Effect.Effect<void>;
+    flowCompleted: Effect.Effect<void>;
+    flowFailed: Effect.Effect<void>;
+    nodeExecuted: Effect.Effect<void>;
+  };
+}
+declare const FlowObservability_base: Context.TagClass<FlowObservability, "FlowObservability", FlowObservabilityService>;
+/**
+ * Flow observability service tag
+ */
+declare class FlowObservability extends FlowObservability_base {}
+/**
+ * Create a base observability layer
+ */
+declare const makeObservabilityLayer: (serviceName: string, enabled?: boolean) => Layer.Layer<Observability>;
+/**
+ * Create a storage observability layer
+ */
+declare const makeStorageObservabilityLayer: (storageType: string, metrics: StorageMetrics, enabled?: boolean) => Layer.Layer<StorageObservability>;
+/**
+ * Create an upload observability layer
+ */
+declare const makeUploadObservabilityLayer: (enabled?: boolean) => Layer.Layer<UploadObservability>;
+/**
+ * Create a flow observability layer
+ */
+declare const makeFlowObservabilityLayer: (enabled?: boolean) => Layer.Layer<FlowObservability>;
+/**
+ * No-op observability layer (disabled)
+ */
+declare const ObservabilityDisabled: Layer.Layer<Observability, never, never>;
+/**
+ * No-op storage observability layer
+ */
+declare const StorageObservabilityDisabled: (storageType: string) => Layer.Layer<StorageObservability, never, never>;
+/**
+ * No-op upload observability layer
+ */
+declare const UploadObservabilityDisabled: Layer.Layer<UploadObservability, never, never>;
+/**
+ * No-op flow observability layer
+ */
+declare const FlowObservabilityDisabled: Layer.Layer<FlowObservability, never, never>;
+/**
+ * Check if observability is enabled in the current context
+ */
+declare const isObservabilityEnabled: Effect.Effect<boolean, never, never>;
+/**
+ * Execute an effect only if observability is enabled
+ */
+declare const whenObservabilityEnabled: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E, R | Observability>;
+//#endregion
+//#region src/core/logging.d.ts
+declare const logWithContext: (message: string, context: Record<string, unknown>) => Effect.Effect<void, never, never>;
+declare const logUploadProgress: (storageType: string, uploadId: string, progress: {
+  uploadedBytes: number;
+  totalBytes: number;
+  partNumber?: number;
+  speed?: number;
+}) => Effect.Effect<void, never, never>;
+declare const logStorageOperation: (storageType: string, operation: string, uploadId: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+declare const logUploadCompletion: (storageType: string, uploadId: string, metrics: {
+  fileSize: number;
+  totalDurationMs: number;
+  partsCount?: number;
+  averagePartSize?: number;
+  throughputBps?: number;
+  retryCount?: number;
+}) => Effect.Effect<void, never, never>;
+//#endregion
+//#region src/core/testing.d.ts
+/**
+ * Mock storage observability for testing
+ */
+declare const makeTestStorageObservability: (storageType: string) => Layer.Layer<StorageObservability>;
+/**
+ * Mock upload observability for testing
+ */
+declare const makeTestUploadObservability: () => Layer.Layer<UploadObservability>;
+/**
+ * Mock flow observability for testing
+ */
+declare const makeTestFlowObservability: () => Layer.Layer<FlowObservability>;
+/**
+ * Capture metrics snapshot from an effect for testing
+ * Note: Metric snapshots are simplified - for full metric testing,
+ * use Effect's built-in metric testing utilities
+ */
+declare const captureMetrics: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Test helper to capture metrics around effect execution
+ * This is a simplified version - for production testing,
+ * use Effect's metric testing utilities
+ */
+declare const withMetricTracking: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Test fixture for observability testing
+ */
+interface ObservabilityTestFixture {
+  readonly storageObservability: Layer.Layer<StorageObservability>;
+  readonly uploadObservability: Layer.Layer<UploadObservability>;
+  readonly flowObservability: Layer.Layer<FlowObservability>;
+}
+/**
+ * Create a complete test fixture with all observability layers
+ */
+declare const createTestFixture: (storageType?: string) => ObservabilityTestFixture;
+/**
+ * Run an effect with test observability layers
+ */
+declare const runWithTestObservability: <A, E>(effect: Effect.Effect<A, E, StorageObservability | UploadObservability | FlowObservability>, storageType?: string) => Effect.Effect<A, E>;
+//#endregion
+//#region src/core/tracing.d.ts
+declare const TracingService: Context.Tag<{
+  serviceName: string;
+}, {
+  serviceName: string;
+}>;
+declare const createTracingLayer: (options?: {
+  serviceName?: string;
+}) => Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const createStorageTracingLayer: (storageType: string) => Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const withStorageSpan: <A, E, R>(operation: string, storageType: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, effect_Tracer0.ParentSpan>>;
+declare const WebSdkLive: Layer.Layer<_effect_opentelemetry_Resource0.Resource, never, never>;
+declare const NodeSdkLive: Layer.Layer<_effect_opentelemetry_Resource0.Resource, never, never>;
+declare const WorkersSdkLive: Layer.Layer<_effect_opentelemetry_Resource0.Resource, never, never>;
+//#endregion
+//#region src/core/utilities.d.ts
+declare const withUploadMetrics: <A, E, R>(metrics: StorageMetrics, uploadId: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withApiMetrics: <A, E, R>(metrics: StorageMetrics, operation: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withTimingMetrics: <A, E, R>(metric: Metric.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const trackFileSize: <A, E, R>(metrics: StorageMetrics, fileSize: number, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const trackPartSize: <A, E, R>(metrics: StorageMetrics, partSize: number, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withActiveUploadTracking: <A, E, R>(metrics: StorageMetrics, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withThroughputTracking: <A, E, R>(metrics: StorageMetrics, bytes: number, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withStorageOperationMetrics: <A, E, R>(metrics: StorageMetrics, operation: string, uploadId: string, effect: Effect.Effect<A, E, R>, fileSize?: number) => Effect.Effect<A, E, R>;
+//#endregion
+//#region src/flow/metrics.d.ts
+/**
+ * Flow engine metrics for tracking flow execution operations
+ */
+declare const createFlowMetrics: () => {
+  flowStartedTotal: Metric.Metric.Counter<number>;
+  flowCompletedTotal: Metric.Metric.Counter<number>;
+  flowFailedTotal: Metric.Metric.Counter<number>;
+  flowPausedTotal: Metric.Metric.Counter<number>;
+  flowResumedTotal: Metric.Metric.Counter<number>;
+  nodeExecutedTotal: Metric.Metric.Counter<number>;
+  nodeSuccessTotal: Metric.Metric.Counter<number>;
+  nodeFailedTotal: Metric.Metric.Counter<number>;
+  nodeSkippedTotal: Metric.Metric.Counter<number>;
+  flowDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  nodeDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  flowNodeCountHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  parallelNodesHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  activeFlowsGauge: Metric.Metric.Gauge<number>;
+  activeNodesGauge: Metric.Metric.Gauge<number>;
+  pausedFlowsGauge: Metric.Metric.Gauge<number>;
+  flowLatencySummary: Metric.Metric.Summary<number>;
+  nodeLatencySummary: Metric.Metric.Summary<number>;
+};
+/**
+ * Type for flow metrics
+ */
+type FlowMetrics = ReturnType<typeof createFlowMetrics>;
+/**
+ * Default flow metrics instance
+ */
+declare const flowMetrics: {
+  flowStartedTotal: Metric.Metric.Counter<number>;
+  flowCompletedTotal: Metric.Metric.Counter<number>;
+  flowFailedTotal: Metric.Metric.Counter<number>;
+  flowPausedTotal: Metric.Metric.Counter<number>;
+  flowResumedTotal: Metric.Metric.Counter<number>;
+  nodeExecutedTotal: Metric.Metric.Counter<number>;
+  nodeSuccessTotal: Metric.Metric.Counter<number>;
+  nodeFailedTotal: Metric.Metric.Counter<number>;
+  nodeSkippedTotal: Metric.Metric.Counter<number>;
+  flowDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  nodeDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  flowNodeCountHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  parallelNodesHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  activeFlowsGauge: Metric.Metric.Gauge<number>;
+  activeNodesGauge: Metric.Metric.Gauge<number>;
+  pausedFlowsGauge: Metric.Metric.Gauge<number>;
+  flowLatencySummary: Metric.Metric.Summary<number>;
+  nodeLatencySummary: Metric.Metric.Summary<number>;
+};
+//#endregion
+//#region src/flow/tracing.d.ts
+/**
+ * Wrap an Effect with a flow operation span
+ */
+declare const withFlowSpan: <A, E, R>(operation: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Add flow context to the current span
+ */
+declare const withFlowContext: (context: {
+  flowId?: string;
+  flowName?: string;
+  jobId?: string;
+  nodeCount?: number;
+  storageId?: string;
+}) => Effect.Effect<void, never, never>;
+/**
+ * Add node context to the current span
+ */
+declare const withNodeContext: (context: {
+  nodeId: string;
+  nodeType: string;
+  nodeName?: string;
+  flowId?: string;
+  jobId?: string;
+}) => Effect.Effect<void, never, never>;
+/**
+ * Add execution state context to the current span
+ */
+declare const withExecutionContext: (context: {
+  executionOrder?: string[];
+  currentIndex?: number;
+  totalNodes?: number;
+  parallelCount?: number;
+}) => Effect.Effect<void, never, never>;
+//#endregion
+//#region src/flow/layers.d.ts
+/**
+ * Create a live flow observability layer with full metrics
+ */
+declare const makeFlowObservabilityLive: (serviceName?: string) => Layer.Layer<FlowObservability>;
+/**
+ * Default live flow observability layer
+ */
+declare const FlowObservabilityLive: Layer.Layer<FlowObservability, never, never>;
+/**
+ * Helper to get flow metrics from context
+ */
+declare const getFlowMetrics: Effect.Effect<{
+  flowStarted: Effect.Effect<void>;
+  flowCompleted: Effect.Effect<void>;
+  flowFailed: Effect.Effect<void>;
+  nodeExecuted: Effect.Effect<void>;
+}, never, FlowObservability>;
+/**
+ * Helper to track flow duration
+ */
+declare const withFlowDuration: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Helper to track node duration
+ */
+declare const withNodeDuration: <A, E, R>(nodeId: string, nodeType: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Helper to track active flows
+ */
+declare const trackActiveFlow: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Helper to track active nodes
+ */
+declare const trackActiveNode: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+//#endregion
+//#region src/flow/errors.d.ts
+type FlowErrorCategory = "flow_validation_error" | "node_execution_error" | "node_not_found_error" | "flow_timeout_error" | "flow_cancelled_error" | "unknown_flow_error";
+/**
+ * Classify flow execution errors
+ */
+declare const classifyFlowError: (error: unknown) => FlowErrorCategory;
+/**
+ * Track flow errors with classification
+ */
+declare const trackFlowError: <E>(error: E) => Effect.Effect<void, never, never>;
+/**
+ * Track node errors with classification
+ */
+declare const trackNodeError: <E>(nodeId: string, nodeType: string, error: E) => Effect.Effect<void, never, never>;
+//#endregion
+//#region src/flow/testing.d.ts
+/**
+ * Mock flow observability for testing
+ */
+declare const makeTestFlowObservability$1: () => Layer.Layer<FlowObservability>;
+/**
+ * Run an effect with test flow observability
+ */
+declare const runWithTestFlowObservability: <A, E>(effect: Effect.Effect<A, E, FlowObservability>) => Effect.Effect<A, E>;
+//#endregion
+//#region src/service/metrics.d.ts
+declare const MetricsService_base: Context.TagClass<MetricsService, "MetricsService", {
+  /**
+   * Record upload metrics for an organization
+   */
+  readonly recordUpload: (clientId: string, bytes: number, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+}>;
+/**
+ * Metrics Recording Service
+ *
+ * Provides access to metrics recording functionality throughout
+ * the upload and flow processing pipeline. The service is provided
+ * via Effect Layer and can be accessed using Effect.service().
+ */
+declare class MetricsService extends MetricsService_base {}
+/**
+ * No-op implementation of MetricsService that does nothing.
+ * Used when metrics are disabled or database is not available.
+ */
+declare const NoOpMetricsServiceLive: Layer.Layer<MetricsService>;
+//#endregion
+//#region src/storage/s3.d.ts
+declare const s3Metrics: {
+  uploadLatencySummary: effect_Metric0.Metric.Summary<number>;
+  activeUploadsGauge: effect_Metric0.Metric.Gauge<number>;
+  uploadThroughputGauge: effect_Metric0.Metric.Gauge<number>;
+  uploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  fileSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  uploadRequestsTotal: effect_Metric0.Metric.Counter<number>;
+  uploadPartsTotal: effect_Metric0.Metric.Counter<number>;
+  uploadSuccessTotal: effect_Metric0.Metric.Counter<number>;
+  uploadErrorsTotal: effect_Metric0.Metric.Counter<number>;
+  apiCallsTotal: effect_Metric0.Metric.Counter<number>;
+};
+declare const S3TracingLayer: Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const trackS3Error: (operation: string, error: unknown, context?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+declare const S3ObservabilityLayer: Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const withS3UploadMetrics: <A, E, R>(uploadId: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withS3ApiMetrics: <A, E, R>(operation: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withS3TimingMetrics: <A, E, R>(metric: effect_Metric0.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withS3OperationMetrics: <A, E, R>(operation: string, uploadId: string, effect: Effect.Effect<A, E, R>, fileSize?: number) => Effect.Effect<A, E, R>;
+declare const withS3Span: <A, E, R>(operation: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<unknown, unknown, unknown>;
+declare const logS3Operation: (operation: string, uploadId: string, metadata?: Record<string, unknown> | undefined) => Effect.Effect<void, never, never>;
+declare const logS3UploadProgress: (uploadId: string, progress: {
+  uploadedBytes: number;
+  totalBytes: number;
+  partNumber?: number;
+  speed?: number;
+}) => Effect.Effect<void, never, never>;
+declare const logS3UploadCompletion: (uploadId: string, metrics: {
+  fileSize: number;
+  totalDurationMs: number;
+  partsCount?: number;
+  averagePartSize?: number;
+  throughputBps?: number;
+  retryCount?: number;
+}) => Effect.Effect<void, never, never>;
+declare const logS3Context: (message: string, context: Record<string, unknown>) => Effect.Effect<void, never, never>;
+declare const s3UploadRequestsTotal: effect_Metric0.Metric.Counter<number>, s3UploadPartsTotal: effect_Metric0.Metric.Counter<number>, s3UploadSuccessTotal: effect_Metric0.Metric.Counter<number>, s3UploadErrorsTotal: effect_Metric0.Metric.Counter<number>, s3ApiCallsTotal: effect_Metric0.Metric.Counter<number>, s3UploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, s3PartUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, s3FileSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, s3PartSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, s3ActiveUploadsGauge: effect_Metric0.Metric.Gauge<number>, s3UploadThroughputGauge: effect_Metric0.Metric.Gauge<number>, s3UploadLatencySummary: effect_Metric0.Metric.Summary<number>;
+type S3Metrics = StorageMetrics;
+//#endregion
+//#region src/storage/azure.d.ts
+declare const azureMetrics: {
+  uploadLatencySummary: effect_Metric0.Metric.Summary<number>;
+  activeUploadsGauge: effect_Metric0.Metric.Gauge<number>;
+  uploadThroughputGauge: effect_Metric0.Metric.Gauge<number>;
+  uploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  fileSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  uploadRequestsTotal: effect_Metric0.Metric.Counter<number>;
+  uploadPartsTotal: effect_Metric0.Metric.Counter<number>;
+  uploadSuccessTotal: effect_Metric0.Metric.Counter<number>;
+  uploadErrorsTotal: effect_Metric0.Metric.Counter<number>;
+  apiCallsTotal: effect_Metric0.Metric.Counter<number>;
+};
+declare const AzureTracingLayer: Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const trackAzureError: (operation: string, error: unknown, context?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+declare const AzureObservabilityLayer: Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const withAzureUploadMetrics: <A, E, R>(uploadId: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withAzureApiMetrics: <A, E, R>(operation: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withAzureTimingMetrics: <A, E, R>(metric: effect_Metric0.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withAzureOperationMetrics: <A, E, R>(operation: string, uploadId: string, effect: Effect.Effect<A, E, R>, fileSize?: number) => Effect.Effect<A, E, R>;
+declare const withAzureSpan: <A, E, R>(operation: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<unknown, unknown, unknown>;
+declare const logAzureOperation: (operation: string, uploadId: string, metadata?: Record<string, unknown> | undefined) => Effect.Effect<void, never, never>;
+declare const logAzureUploadProgress: (uploadId: string, progress: {
+  uploadedBytes: number;
+  totalBytes: number;
+  partNumber?: number;
+  speed?: number;
+}) => Effect.Effect<void, never, never>;
+declare const logAzureUploadCompletion: (uploadId: string, metrics: {
+  fileSize: number;
+  totalDurationMs: number;
+  partsCount?: number;
+  averagePartSize?: number;
+  throughputBps?: number;
+  retryCount?: number;
+}) => Effect.Effect<void, never, never>;
+declare const logAzureContext: (message: string, context: Record<string, unknown>) => Effect.Effect<void, never, never>;
+declare const azureUploadRequestsTotal: effect_Metric0.Metric.Counter<number>, azureUploadPartsTotal: effect_Metric0.Metric.Counter<number>, azureUploadSuccessTotal: effect_Metric0.Metric.Counter<number>, azureUploadErrorsTotal: effect_Metric0.Metric.Counter<number>, azureApiCallsTotal: effect_Metric0.Metric.Counter<number>, azureUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, azurePartUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, azureFileSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, azurePartSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, azureActiveUploadsGauge: effect_Metric0.Metric.Gauge<number>, azureUploadThroughputGauge: effect_Metric0.Metric.Gauge<number>, azureUploadLatencySummary: effect_Metric0.Metric.Summary<number>;
+type AzureMetrics = StorageMetrics;
+//#endregion
+//#region src/storage/gcs.d.ts
+declare const gcsMetrics: {
+  uploadLatencySummary: effect_Metric0.Metric.Summary<number>;
+  activeUploadsGauge: effect_Metric0.Metric.Gauge<number>;
+  uploadThroughputGauge: effect_Metric0.Metric.Gauge<number>;
+  uploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  fileSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  uploadRequestsTotal: effect_Metric0.Metric.Counter<number>;
+  uploadPartsTotal: effect_Metric0.Metric.Counter<number>;
+  uploadSuccessTotal: effect_Metric0.Metric.Counter<number>;
+  uploadErrorsTotal: effect_Metric0.Metric.Counter<number>;
+  apiCallsTotal: effect_Metric0.Metric.Counter<number>;
+};
+declare const GCSTracingLayer: Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const trackGCSError: (operation: string, error: unknown, context?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+declare const GCSObservabilityLayer: Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const withGCSUploadMetrics: <A, E, R>(uploadId: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withGCSApiMetrics: <A, E, R>(operation: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withGCSTimingMetrics: <A, E, R>(metric: effect_Metric0.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withGCSOperationMetrics: <A, E, R>(operation: string, uploadId: string, effect: Effect.Effect<A, E, R>, fileSize?: number) => Effect.Effect<A, E, R>;
+declare const withGCSSpan: <A, E, R>(operation: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<unknown, unknown, unknown>;
+declare const logGCSOperation: (operation: string, uploadId: string, metadata?: Record<string, unknown> | undefined) => Effect.Effect<void, never, never>;
+declare const logGCSUploadProgress: (uploadId: string, progress: {
+  uploadedBytes: number;
+  totalBytes: number;
+  partNumber?: number;
+  speed?: number;
+}) => Effect.Effect<void, never, never>;
+declare const logGCSUploadCompletion: (uploadId: string, metrics: {
+  fileSize: number;
+  totalDurationMs: number;
+  partsCount?: number;
+  averagePartSize?: number;
+  throughputBps?: number;
+  retryCount?: number;
+}) => Effect.Effect<void, never, never>;
+declare const logGCSContext: (message: string, context: Record<string, unknown>) => Effect.Effect<void, never, never>;
+declare const gcsUploadRequestsTotal: effect_Metric0.Metric.Counter<number>, gcsUploadPartsTotal: effect_Metric0.Metric.Counter<number>, gcsUploadSuccessTotal: effect_Metric0.Metric.Counter<number>, gcsUploadErrorsTotal: effect_Metric0.Metric.Counter<number>, gcsApiCallsTotal: effect_Metric0.Metric.Counter<number>, gcsUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, gcsPartUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, gcsFileSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, gcsPartSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, gcsActiveUploadsGauge: effect_Metric0.Metric.Gauge<number>, gcsUploadThroughputGauge: effect_Metric0.Metric.Gauge<number>, gcsUploadLatencySummary: effect_Metric0.Metric.Summary<number>;
+type GCSMetrics = StorageMetrics;
+//#endregion
+//#region src/storage/filesystem.d.ts
+declare const filesystemMetrics: {
+  uploadLatencySummary: effect_Metric0.Metric.Summary<number>;
+  activeUploadsGauge: effect_Metric0.Metric.Gauge<number>;
+  uploadThroughputGauge: effect_Metric0.Metric.Gauge<number>;
+  uploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  fileSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  partSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  uploadRequestsTotal: effect_Metric0.Metric.Counter<number>;
+  uploadPartsTotal: effect_Metric0.Metric.Counter<number>;
+  uploadSuccessTotal: effect_Metric0.Metric.Counter<number>;
+  uploadErrorsTotal: effect_Metric0.Metric.Counter<number>;
+  apiCallsTotal: effect_Metric0.Metric.Counter<number>;
+};
+declare const FilesystemTracingLayer: Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const trackFilesystemError: (operation: string, error: unknown, context?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+declare const FilesystemObservabilityLayer: Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const withFilesystemUploadMetrics: <A, E, R>(uploadId: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withFilesystemApiMetrics: <A, E, R>(operation: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withFilesystemTimingMetrics: <A, E, R>(metric: effect_Metric0.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withFilesystemOperationMetrics: <A, E, R>(operation: string, uploadId: string, effect: Effect.Effect<A, E, R>, fileSize?: number) => Effect.Effect<A, E, R>;
+declare const withFilesystemSpan: <A, E, R>(operation: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<unknown, unknown, unknown>;
+declare const logFilesystemOperation: (operation: string, uploadId: string, metadata?: Record<string, unknown> | undefined) => Effect.Effect<void, never, never>;
+declare const logFilesystemUploadProgress: (uploadId: string, progress: {
+  uploadedBytes: number;
+  totalBytes: number;
+  partNumber?: number;
+  speed?: number;
+}) => Effect.Effect<void, never, never>;
+declare const logFilesystemUploadCompletion: (uploadId: string, metrics: {
+  fileSize: number;
+  totalDurationMs: number;
+  partsCount?: number;
+  averagePartSize?: number;
+  throughputBps?: number;
+  retryCount?: number;
+}) => Effect.Effect<void, never, never>;
+declare const logFilesystemContext: (message: string, context: Record<string, unknown>) => Effect.Effect<void, never, never>;
+declare const filesystemUploadRequestsTotal: effect_Metric0.Metric.Counter<number>, filesystemUploadPartsTotal: effect_Metric0.Metric.Counter<number>, filesystemUploadSuccessTotal: effect_Metric0.Metric.Counter<number>, filesystemUploadErrorsTotal: effect_Metric0.Metric.Counter<number>, filesystemApiCallsTotal: effect_Metric0.Metric.Counter<number>, filesystemUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, filesystemPartUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, filesystemFileSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, filesystemPartSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>, filesystemActiveUploadsGauge: effect_Metric0.Metric.Gauge<number>, filesystemUploadThroughputGauge: effect_Metric0.Metric.Gauge<number>, filesystemUploadLatencySummary: effect_Metric0.Metric.Summary<number>;
+type FilesystemMetrics = StorageMetrics;
+//#endregion
+//#region src/upload/metrics.d.ts
+/**
+ * Upload server metrics for tracking upload operations
+ */
+declare const createUploadServerMetrics: () => {
+  uploadCreatedTotal: Metric.Metric.Counter<number>;
+  uploadCompletedTotal: Metric.Metric.Counter<number>;
+  uploadFailedTotal: Metric.Metric.Counter<number>;
+  chunkUploadedTotal: Metric.Metric.Counter<number>;
+  uploadFromUrlTotal: Metric.Metric.Counter<number>;
+  uploadFromUrlSuccessTotal: Metric.Metric.Counter<number>;
+  uploadFromUrlFailedTotal: Metric.Metric.Counter<number>;
+  uploadDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  chunkUploadDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  uploadFileSizeHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  chunkSizeHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  activeUploadsGauge: Metric.Metric.Gauge<number>;
+  uploadThroughputGauge: Metric.Metric.Gauge<number>;
+  uploadLatencySummary: Metric.Metric.Summary<number>;
+  chunkLatencySummary: Metric.Metric.Summary<number>;
+};
+/**
+ * Type for upload server metrics
+ */
+type UploadServerMetrics = ReturnType<typeof createUploadServerMetrics>;
+/**
+ * Default upload server metrics instance
+ */
+declare const uploadServerMetrics: {
+  uploadCreatedTotal: Metric.Metric.Counter<number>;
+  uploadCompletedTotal: Metric.Metric.Counter<number>;
+  uploadFailedTotal: Metric.Metric.Counter<number>;
+  chunkUploadedTotal: Metric.Metric.Counter<number>;
+  uploadFromUrlTotal: Metric.Metric.Counter<number>;
+  uploadFromUrlSuccessTotal: Metric.Metric.Counter<number>;
+  uploadFromUrlFailedTotal: Metric.Metric.Counter<number>;
+  uploadDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  chunkUploadDurationHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  uploadFileSizeHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  chunkSizeHistogram: Metric.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  activeUploadsGauge: Metric.Metric.Gauge<number>;
+  uploadThroughputGauge: Metric.Metric.Gauge<number>;
+  uploadLatencySummary: Metric.Metric.Summary<number>;
+  chunkLatencySummary: Metric.Metric.Summary<number>;
+};
+//#endregion
+//#region src/upload/tracing.d.ts
+/**
+ * Wrap an Effect with an upload operation span
+ */
+declare const withUploadSpan: <A, E, R>(operation: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Add upload context to the current span
+ */
+declare const withUploadContext: (context: {
+  uploadId?: string;
+  fileName?: string;
+  fileSize?: number;
+  storageId?: string;
+  mimeType?: string;
+}) => Effect.Effect<void, never, never>;
+/**
+ * Add chunk context to the current span
+ */
+declare const withChunkContext: (context: {
+  uploadId: string;
+  chunkSize: number;
+  offset: number;
+  totalSize?: number;
+}) => Effect.Effect<void, never, never>;
+//#endregion
+//#region src/upload/layers.d.ts
+/**
+ * Create a live upload observability layer with full metrics
+ */
+declare const makeUploadObservabilityLive: (serviceName?: string) => Layer.Layer<UploadObservability>;
+/**
+ * Default live upload observability layer
+ */
+declare const UploadObservabilityLive: Layer.Layer<UploadObservability, never, never>;
+/**
+ * Helper to get upload metrics from context
+ */
+declare const getUploadMetrics: Effect.Effect<{
+  uploadCreated: Effect.Effect<void>;
+  uploadCompleted: Effect.Effect<void>;
+  uploadFailed: Effect.Effect<void>;
+  chunkUploaded: Effect.Effect<void>;
+}, never, UploadObservability>;
+/**
+ * Helper to track upload duration
+ */
+declare const withUploadDuration: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | UploadObservability>;
+/**
+ * Helper to track chunk upload duration
+ */
+declare const withChunkDuration: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+//#endregion
+//#region src/upload/errors.d.ts
+type UploadErrorCategory = "network_error" | "authentication_error" | "authorization_error" | "validation_error" | "size_limit_error" | "storage_error" | "abort_error" | "unknown_error";
+/**
+ * Classify upload errors into standard categories
+ */
+declare const classifyUploadError: (error: unknown) => UploadErrorCategory;
+/**
+ * Track upload errors with metrics and structured logging
+ */
+declare const trackUploadError: (metrics: UploadServerMetrics, operation: string, error: unknown, context?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+/**
+ * Create a custom error classifier for upload operations
+ */
+declare const createUploadErrorClassifier: (customErrorMapping?: (error: unknown) => UploadErrorCategory | null) => (error: unknown) => UploadErrorCategory;
+//#endregion
+//#region src/upload/testing.d.ts
+/**
+ * Create a test upload observability layer that doesn't actually emit metrics
+ * but validates that the observability system is wired correctly
+ */
+declare const UploadObservabilityTest: Layer.Layer<UploadObservability, never, never>;
+/**
+ * Get metrics for validation (useful for testing metric definitions)
+ */
+declare const getTestMetrics: () => {
+  uploadCreatedTotal: effect_Metric0.Metric.Counter<number>;
+  uploadCompletedTotal: effect_Metric0.Metric.Counter<number>;
+  uploadFailedTotal: effect_Metric0.Metric.Counter<number>;
+  chunkUploadedTotal: effect_Metric0.Metric.Counter<number>;
+  uploadFromUrlTotal: effect_Metric0.Metric.Counter<number>;
+  uploadFromUrlSuccessTotal: effect_Metric0.Metric.Counter<number>;
+  uploadFromUrlFailedTotal: effect_Metric0.Metric.Counter<number>;
+  uploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  chunkUploadDurationHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  uploadFileSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  chunkSizeHistogram: effect_Metric0.Metric<effect_MetricKeyType19.MetricKeyType.Histogram, number, effect_MetricState19.MetricState.Histogram>;
+  activeUploadsGauge: effect_Metric0.Metric.Gauge<number>;
+  uploadThroughputGauge: effect_Metric0.Metric.Gauge<number>;
+  uploadLatencySummary: effect_Metric0.Metric.Summary<number>;
+  chunkLatencySummary: effect_Metric0.Metric.Summary<number>;
+};
+/**
+ * Validate that all required metrics exist
+ */
+declare const validateMetricsExist: () => boolean;
+//#endregion
+export { AzureMetrics, AzureObservabilityLayer, AzureTracingLayer, FilesystemMetrics, FilesystemObservabilityLayer, FilesystemTracingLayer, FlowErrorCategory, FlowMetrics, FlowObservability, FlowObservabilityDisabled, FlowObservabilityLive, FlowObservabilityService, GCSMetrics, GCSObservabilityLayer, GCSTracingLayer, MetricsService, NoOpMetricsServiceLive, NodeSdkLive, Observability, ObservabilityDisabled, ObservabilityService, ObservabilityTestFixture, S3Metrics, S3ObservabilityLayer, S3TracingLayer, StorageErrorCategory, StorageMetrics, StorageObservability, StorageObservabilityDisabled, StorageObservabilityService, TracingService, UploadErrorCategory, UploadObservability, UploadObservabilityDisabled, UploadObservabilityLive, UploadObservabilityService, UploadObservabilityTest, UploadServerMetrics, WebSdkLive, WorkersSdkLive, azureActiveUploadsGauge, azureApiCallsTotal, azureFileSizeHistogram, azureMetrics, azurePartSizeHistogram, azurePartUploadDurationHistogram, azureUploadDurationHistogram, azureUploadErrorsTotal, azureUploadLatencySummary, azureUploadPartsTotal, azureUploadRequestsTotal, azureUploadSuccessTotal, azureUploadThroughputGauge, captureMetrics, classifyFlowError, classifyStorageError, classifyUploadError, createFlowMetrics, createStorageErrorClassifier, createStorageErrorTracker, createStorageMetrics, createStorageTracingLayer, createTestFixture, createTracingLayer, createUploadErrorClassifier, createUploadGauges, createUploadHistograms, createUploadMetrics, createUploadServerMetrics, createUploadSummaries, filesystemActiveUploadsGauge, filesystemApiCallsTotal, filesystemFileSizeHistogram, filesystemMetrics, filesystemPartSizeHistogram, filesystemPartUploadDurationHistogram, filesystemUploadDurationHistogram, filesystemUploadErrorsTotal, filesystemUploadLatencySummary, filesystemUploadPartsTotal, filesystemUploadRequestsTotal, filesystemUploadSuccessTotal, filesystemUploadThroughputGauge, flowMetrics, gcsActiveUploadsGauge, gcsApiCallsTotal, gcsFileSizeHistogram, gcsMetrics, gcsPartSizeHistogram, gcsPartUploadDurationHistogram, gcsUploadDurationHistogram, gcsUploadErrorsTotal, gcsUploadLatencySummary, gcsUploadPartsTotal, gcsUploadRequestsTotal, gcsUploadSuccessTotal, gcsUploadThroughputGauge, getFlowMetrics, getTestMetrics, getUploadMetrics, isObservabilityEnabled, logAzureContext, logAzureOperation, logAzureUploadCompletion, logAzureUploadProgress, logFilesystemContext, logFilesystemOperation, logFilesystemUploadCompletion, logFilesystemUploadProgress, logGCSContext, logGCSOperation, logGCSUploadCompletion, logGCSUploadProgress, logS3Context, logS3Operation, logS3UploadCompletion, logS3UploadProgress, logStorageOperation, logUploadCompletion, logUploadProgress, logWithContext, makeFlowObservabilityLayer, makeFlowObservabilityLive, makeObservabilityLayer, makeStorageObservabilityLayer, makeTestFlowObservability, makeTestFlowObservability$1 as makeTestFlowObservabilityUtil, makeTestStorageObservability, makeTestUploadObservability, makeUploadObservabilityLayer, makeUploadObservabilityLive, runWithTestFlowObservability, runWithTestObservability, s3ActiveUploadsGauge, s3ApiCallsTotal, s3FileSizeHistogram, s3Metrics, s3PartSizeHistogram, s3PartUploadDurationHistogram, s3UploadDurationHistogram, s3UploadErrorsTotal, s3UploadLatencySummary, s3UploadPartsTotal, s3UploadRequestsTotal, s3UploadSuccessTotal, s3UploadThroughputGauge, trackActiveFlow, trackActiveNode, trackAzureError, trackFileSize, trackFilesystemError, trackFlowError, trackGCSError, trackNodeError, trackPartSize, trackS3Error, trackStorageError, trackUploadError, uploadServerMetrics, validateMetricsExist, whenObservabilityEnabled, withActiveUploadTracking, withApiMetrics, withAzureApiMetrics, withAzureOperationMetrics, withAzureSpan, withAzureTimingMetrics, withAzureUploadMetrics, withChunkContext, withChunkDuration, withExecutionContext, withFilesystemApiMetrics, withFilesystemOperationMetrics, withFilesystemSpan, withFilesystemTimingMetrics, withFilesystemUploadMetrics, withFlowContext, withFlowDuration, withFlowSpan, withGCSApiMetrics, withGCSOperationMetrics, withGCSSpan, withGCSTimingMetrics, withGCSUploadMetrics, withMetricTracking, withNodeContext, withNodeDuration, withS3ApiMetrics, withS3OperationMetrics, withS3Span, withS3TimingMetrics, withS3UploadMetrics, withStorageOperationMetrics, withStorageSpan, withThroughputTracking, withTimingMetrics, withUploadContext, withUploadDuration, withUploadMetrics, withUploadSpan };
+//# sourceMappingURL=index.d.cts.map