@nativesquare/soma 0.1.0

package/dist/component/validators/daily.d.ts

@@ -0,0 +1,650 @@
+export declare const dailyValidator: {
+    connectionId: import("convex/values").VId<import("convex/values").GenericId<"connections">, "required">;
+    userId: import("convex/values").VString<string, "required">;
+    active_durations_data: import("convex/values").VObject<{
+        activity_levels_samples?: {
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }[] | undefined;
+        activity_seconds?: number | undefined;
+        inactivity_seconds?: number | undefined;
+        low_intensity_seconds?: number | undefined;
+        moderate_intensity_seconds?: number | undefined;
+        num_continuous_inactive_periods?: number | undefined;
+        rest_seconds?: number | undefined;
+        standing_hours_count?: number | undefined;
+        standing_seconds?: number | undefined;
+        vigorous_intensity_seconds?: number | undefined;
+    } | undefined, {
+        activity_levels_samples: import("convex/values").VArray<{
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }[] | undefined, import("convex/values").VObject<{
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }, {
+            timestamp: import("convex/values").VString<string | undefined, "optional">;
+            level: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "timestamp" | "level">, "optional">;
+        activity_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        inactivity_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        low_intensity_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        moderate_intensity_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        num_continuous_inactive_periods: import("convex/values").VFloat64<number | undefined, "optional">;
+        rest_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        standing_hours_count: import("convex/values").VFloat64<number | undefined, "optional">;
+        standing_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        vigorous_intensity_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+    }, "optional", "activity_levels_samples" | "activity_seconds" | "inactivity_seconds" | "low_intensity_seconds" | "moderate_intensity_seconds" | "num_continuous_inactive_periods" | "rest_seconds" | "standing_hours_count" | "standing_seconds" | "vigorous_intensity_seconds">;
+    calories_data: import("convex/values").VObject<{
+        BMR_calories?: number | undefined;
+        calorie_samples?: {
+            timestamp?: string | undefined;
+            timer_duration_seconds?: number | undefined;
+            calories?: number | undefined;
+        }[] | undefined;
+        net_activity_calories?: number | undefined;
+        net_intake_calories?: number | undefined;
+        total_burned_calories?: number | undefined;
+    } | undefined, {
+        BMR_calories: import("convex/values").VFloat64<number | undefined, "optional">;
+        calorie_samples: import("convex/values").VArray<{
+            timestamp?: string | undefined;
+            timer_duration_seconds?: number | undefined;
+            calories?: number | undefined;
+        }[] | undefined, import("convex/values").VObject<{
+            timestamp?: string | undefined;
+            timer_duration_seconds?: number | undefined;
+            calories?: number | undefined;
+        }, {
+            timestamp: import("convex/values").VString<string | undefined, "optional">;
+            calories: import("convex/values").VFloat64<number | undefined, "optional">;
+            timer_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "timestamp" | "timer_duration_seconds" | "calories">, "optional">;
+        net_activity_calories: import("convex/values").VFloat64<number | undefined, "optional">;
+        net_intake_calories: import("convex/values").VFloat64<number | undefined, "optional">;
+        total_burned_calories: import("convex/values").VFloat64<number | undefined, "optional">;
+    }, "optional", "BMR_calories" | "calorie_samples" | "net_activity_calories" | "net_intake_calories" | "total_burned_calories">;
+    data_enrichment: import("convex/values").VObject<{
+        start_time?: string | undefined;
+        cardiovascular_contributors?: {
+            contributor_name: string;
+            contributor_score: number;
+        }[] | undefined;
+        cardiovascular_score?: number | undefined;
+        immune_contributors?: {
+            contributor_name: string;
+            contributor_score: number;
+        }[] | undefined;
+        immune_index?: number | undefined;
+        readiness_contributors?: {
+            contributor_name: string;
+            contributor_score: number;
+        }[] | undefined;
+        readiness_score?: number | undefined;
+        respiratory_contributors?: {
+            contributor_name: string;
+            contributor_score: number;
+        }[] | undefined;
+        respiratory_score?: number | undefined;
+        stress_contributors?: {
+            contributor_name: string;
+            contributor_score: number;
+        }[] | undefined;
+        total_stress_score?: number | undefined;
+    } | undefined, {
+        cardiovascular_contributors: import("convex/values").VArray<{
+            contributor_name: string;
+            contributor_score: number;
+        }[] | undefined, import("convex/values").VObject<{
+            contributor_name: string;
+            contributor_score: number;
+        }, {
+            contributor_name: import("convex/values").VString<string, "required">;
+            contributor_score: import("convex/values").VFloat64<number, "required">;
+        }, "required", "contributor_name" | "contributor_score">, "optional">;
+        cardiovascular_score: import("convex/values").VFloat64<number | undefined, "optional">;
+        immune_contributors: import("convex/values").VArray<{
+            contributor_name: string;
+            contributor_score: number;
+        }[] | undefined, import("convex/values").VObject<{
+            contributor_name: string;
+            contributor_score: number;
+        }, {
+            contributor_name: import("convex/values").VString<string, "required">;
+            contributor_score: import("convex/values").VFloat64<number, "required">;
+        }, "required", "contributor_name" | "contributor_score">, "optional">;
+        immune_index: import("convex/values").VFloat64<number | undefined, "optional">;
+        readiness_contributors: import("convex/values").VArray<{
+            contributor_name: string;
+            contributor_score: number;
+        }[] | undefined, import("convex/values").VObject<{
+            contributor_name: string;
+            contributor_score: number;
+        }, {
+            contributor_name: import("convex/values").VString<string, "required">;
+            contributor_score: import("convex/values").VFloat64<number, "required">;
+        }, "required", "contributor_name" | "contributor_score">, "optional">;
+        readiness_score: import("convex/values").VFloat64<number | undefined, "optional">;
+        respiratory_contributors: import("convex/values").VArray<{
+            contributor_name: string;
+            contributor_score: number;
+        }[] | undefined, import("convex/values").VObject<{
+            contributor_name: string;
+            contributor_score: number;
+        }, {
+            contributor_name: import("convex/values").VString<string, "required">;
+            contributor_score: import("convex/values").VFloat64<number, "required">;
+        }, "required", "contributor_name" | "contributor_score">, "optional">;
+        respiratory_score: import("convex/values").VFloat64<number | undefined, "optional">;
+        start_time: import("convex/values").VString<string | undefined, "optional">;
+        stress_contributors: import("convex/values").VArray<{
+            contributor_name: string;
+            contributor_score: number;
+        }[] | undefined, import("convex/values").VObject<{
+            contributor_name: string;
+            contributor_score: number;
+        }, {
+            contributor_name: import("convex/values").VString<string, "required">;
+            contributor_score: import("convex/values").VFloat64<number, "required">;
+        }, "required", "contributor_name" | "contributor_score">, "optional">;
+        total_stress_score: import("convex/values").VFloat64<number | undefined, "optional">;
+    }, "optional", "start_time" | "cardiovascular_contributors" | "cardiovascular_score" | "immune_contributors" | "immune_index" | "readiness_contributors" | "readiness_score" | "respiratory_contributors" | "respiratory_score" | "stress_contributors" | "total_stress_score">;
+    device_data: import("convex/values").VObject<{
+        name?: string | undefined;
+        manufacturer?: string | undefined;
+        serial_number?: string | undefined;
+        software_version?: string | undefined;
+        hardware_version?: string | undefined;
+        last_upload_date?: string | undefined;
+        activation_timestamp?: string | undefined;
+        data_provided?: string[] | undefined;
+        other_devices?: {
+            name?: string | undefined;
+            manufacturer?: string | undefined;
+            serial_number?: string | undefined;
+            software_version?: string | undefined;
+            hardware_version?: string | undefined;
+            last_upload_date?: string | undefined;
+            activation_timestamp?: string | undefined;
+            data_provided?: string[] | undefined;
+        }[] | undefined;
+        sensor_state?: string | undefined;
+    } | undefined, {
+        activation_timestamp: import("convex/values").VString<string | undefined, "optional">;
+        data_provided: import("convex/values").VArray<string[] | undefined, import("convex/values").VString<string, "required">, "optional">;
+        hardware_version: import("convex/values").VString<string | undefined, "optional">;
+        last_upload_date: import("convex/values").VString<string | undefined, "optional">;
+        manufacturer: import("convex/values").VString<string | undefined, "optional">;
+        name: import("convex/values").VString<string | undefined, "optional">;
+        other_devices: import("convex/values").VArray<{
+            name?: string | undefined;
+            manufacturer?: string | undefined;
+            serial_number?: string | undefined;
+            software_version?: string | undefined;
+            hardware_version?: string | undefined;
+            last_upload_date?: string | undefined;
+            activation_timestamp?: string | undefined;
+            data_provided?: string[] | undefined;
+        }[] | undefined, import("convex/values").VObject<{
+            name?: string | undefined;
+            manufacturer?: string | undefined;
+            serial_number?: string | undefined;
+            software_version?: string | undefined;
+            hardware_version?: string | undefined;
+            last_upload_date?: string | undefined;
+            activation_timestamp?: string | undefined;
+            data_provided?: string[] | undefined;
+        }, {
+            name: import("convex/values").VString<string | undefined, "optional">;
+            manufacturer: import("convex/values").VString<string | undefined, "optional">;
+            serial_number: import("convex/values").VString<string | undefined, "optional">;
+            software_version: import("convex/values").VString<string | undefined, "optional">;
+            hardware_version: import("convex/values").VString<string | undefined, "optional">;
+            last_upload_date: import("convex/values").VString<string | undefined, "optional">;
+            activation_timestamp: import("convex/values").VString<string | undefined, "optional">;
+            data_provided: import("convex/values").VArray<string[] | undefined, import("convex/values").VString<string, "required">, "optional">;
+        }, "required", "name" | "manufacturer" | "serial_number" | "software_version" | "hardware_version" | "last_upload_date" | "activation_timestamp" | "data_provided">, "optional">;
+        serial_number: import("convex/values").VString<string | undefined, "optional">;
+        sensor_state: import("convex/values").VString<string | undefined, "optional">;
+        software_version: import("convex/values").VString<string | undefined, "optional">;
+    }, "optional", "name" | "manufacturer" | "serial_number" | "software_version" | "hardware_version" | "last_upload_date" | "activation_timestamp" | "data_provided" | "other_devices" | "sensor_state">;
+    distance_data: import("convex/values").VObject<{
+        distance_meters?: number | undefined;
+        steps?: number | undefined;
+        floors_climbed?: number | undefined;
+        detailed?: {
+            distance_samples?: {
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                distance_meters?: number | undefined;
+            }[] | undefined;
+            elevation_samples?: {
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                elev_meters?: number | undefined;
+            }[] | undefined;
+            floors_climbed_samples?: {
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                floors_climbed?: number | undefined;
+            }[] | undefined;
+            step_samples?: {
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                steps?: number | undefined;
+            }[] | undefined;
+        } | undefined;
+        elevation?: {
+            avg_meters?: number | undefined;
+            gain_actual_meters?: number | undefined;
+            gain_planned_meters?: number | undefined;
+            loss_actual_meters?: number | undefined;
+            max_meters?: number | undefined;
+            min_meters?: number | undefined;
+        } | undefined;
+        swimming?: {
+            num_laps?: number | undefined;
+            num_strokes?: number | undefined;
+            pool_length_meters?: number | undefined;
+        } | undefined;
+    } | undefined, {
+        detailed: import("convex/values").VObject<{
+            distance_samples?: {
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                distance_meters?: number | undefined;
+            }[] | undefined;
+            elevation_samples?: {
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                elev_meters?: number | undefined;
+            }[] | undefined;
+            floors_climbed_samples?: {
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                floors_climbed?: number | undefined;
+            }[] | undefined;
+            step_samples?: {
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                steps?: number | undefined;
+            }[] | undefined;
+        } | undefined, {
+            distance_samples: import("convex/values").VArray<{
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                distance_meters?: number | undefined;
+            }[] | undefined, import("convex/values").VObject<{
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                distance_meters?: number | undefined;
+            }, {
+                timestamp: import("convex/values").VString<string | undefined, "optional">;
+                distance_meters: import("convex/values").VFloat64<number | undefined, "optional">;
+                timer_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "timestamp" | "timer_duration_seconds" | "distance_meters">, "optional">;
+            elevation_samples: import("convex/values").VArray<{
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                elev_meters?: number | undefined;
+            }[] | undefined, import("convex/values").VObject<{
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                elev_meters?: number | undefined;
+            }, {
+                timestamp: import("convex/values").VString<string | undefined, "optional">;
+                elev_meters: import("convex/values").VFloat64<number | undefined, "optional">;
+                timer_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "timestamp" | "timer_duration_seconds" | "elev_meters">, "optional">;
+            floors_climbed_samples: import("convex/values").VArray<{
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                floors_climbed?: number | undefined;
+            }[] | undefined, import("convex/values").VObject<{
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                floors_climbed?: number | undefined;
+            }, {
+                timestamp: import("convex/values").VString<string | undefined, "optional">;
+                floors_climbed: import("convex/values").VFloat64<number | undefined, "optional">;
+                timer_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "timestamp" | "timer_duration_seconds" | "floors_climbed">, "optional">;
+            step_samples: import("convex/values").VArray<{
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                steps?: number | undefined;
+            }[] | undefined, import("convex/values").VObject<{
+                timestamp?: string | undefined;
+                timer_duration_seconds?: number | undefined;
+                steps?: number | undefined;
+            }, {
+                timestamp: import("convex/values").VString<string | undefined, "optional">;
+                steps: import("convex/values").VFloat64<number | undefined, "optional">;
+                timer_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "timestamp" | "timer_duration_seconds" | "steps">, "optional">;
+        }, "optional", "distance_samples" | "elevation_samples" | "floors_climbed_samples" | "step_samples">;
+        distance_meters: import("convex/values").VFloat64<number | undefined, "optional">;
+        elevation: import("convex/values").VObject<{
+            avg_meters?: number | undefined;
+            gain_actual_meters?: number | undefined;
+            gain_planned_meters?: number | undefined;
+            loss_actual_meters?: number | undefined;
+            max_meters?: number | undefined;
+            min_meters?: number | undefined;
+        } | undefined, {
+            avg_meters: import("convex/values").VFloat64<number | undefined, "optional">;
+            gain_actual_meters: import("convex/values").VFloat64<number | undefined, "optional">;
+            gain_planned_meters: import("convex/values").VFloat64<number | undefined, "optional">;
+            loss_actual_meters: import("convex/values").VFloat64<number | undefined, "optional">;
+            max_meters: import("convex/values").VFloat64<number | undefined, "optional">;
+            min_meters: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "optional", "avg_meters" | "gain_actual_meters" | "gain_planned_meters" | "loss_actual_meters" | "max_meters" | "min_meters">;
+        floors_climbed: import("convex/values").VFloat64<number | undefined, "optional">;
+        steps: import("convex/values").VFloat64<number | undefined, "optional">;
+        swimming: import("convex/values").VObject<{
+            num_laps?: number | undefined;
+            num_strokes?: number | undefined;
+            pool_length_meters?: number | undefined;
+        } | undefined, {
+            num_laps: import("convex/values").VFloat64<number | undefined, "optional">;
+            num_strokes: import("convex/values").VFloat64<number | undefined, "optional">;
+            pool_length_meters: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "optional", "num_laps" | "num_strokes" | "pool_length_meters">;
+    }, "optional", "distance_meters" | "steps" | "floors_climbed" | "detailed" | "elevation" | "swimming" | "elevation.avg_meters" | "elevation.gain_actual_meters" | "elevation.gain_planned_meters" | "elevation.loss_actual_meters" | "elevation.max_meters" | "elevation.min_meters" | "swimming.num_laps" | "swimming.num_strokes" | "swimming.pool_length_meters" | "detailed.distance_samples" | "detailed.elevation_samples" | "detailed.floors_climbed_samples" | "detailed.step_samples">;
+    heart_rate_data: import("convex/values").VObject<{
+        summary?: {
+            avg_hr_bpm?: number | undefined;
+            avg_hrv_rmssd?: number | undefined;
+            avg_hrv_sdnn?: number | undefined;
+            hr_zone_data?: {
+                zone?: number | undefined;
+                start_percentage?: number | undefined;
+                end_percentage?: number | undefined;
+                name?: string | undefined;
+                duration_seconds?: number | undefined;
+            }[] | undefined;
+            max_hr_bpm?: number | undefined;
+            min_hr_bpm?: number | undefined;
+            resting_hr_bpm?: number | undefined;
+            user_max_hr_bpm?: number | undefined;
+        } | undefined;
+        detailed?: {
+            hr_samples?: {
+                timestamp?: string | undefined;
+                bpm?: number | undefined;
+                timer_duration_seconds?: number | undefined;
+                context?: number | undefined;
+            }[] | undefined;
+            hrv_samples_rmssd?: {
+                timestamp?: string | undefined;
+                hrv_rmssd?: number | undefined;
+            }[] | undefined;
+            hrv_samples_sdnn?: {
+                timestamp?: string | undefined;
+                hrv_sdnn?: number | undefined;
+            }[] | undefined;
+        } | undefined;
+    } | undefined, {
+        detailed: import("convex/values").VObject<{
+            hr_samples?: {
+                timestamp?: string | undefined;
+                bpm?: number | undefined;
+                timer_duration_seconds?: number | undefined;
+                context?: number | undefined;
+            }[] | undefined;
+            hrv_samples_rmssd?: {
+                timestamp?: string | undefined;
+                hrv_rmssd?: number | undefined;
+            }[] | undefined;
+            hrv_samples_sdnn?: {
+                timestamp?: string | undefined;
+                hrv_sdnn?: number | undefined;
+            }[] | undefined;
+        } | undefined, {
+            hr_samples: import("convex/values").VArray<{
+                timestamp?: string | undefined;
+                bpm?: number | undefined;
+                timer_duration_seconds?: number | undefined;
+                context?: number | undefined;
+            }[] | undefined, import("convex/values").VObject<{
+                timestamp?: string | undefined;
+                bpm?: number | undefined;
+                timer_duration_seconds?: number | undefined;
+                context?: number | undefined;
+            }, {
+                timestamp: import("convex/values").VString<string | undefined, "optional">;
+                bpm: import("convex/values").VFloat64<number | undefined, "optional">;
+                timer_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+                context: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "timestamp" | "bpm" | "timer_duration_seconds" | "context">, "optional">;
+            hrv_samples_rmssd: import("convex/values").VArray<{
+                timestamp?: string | undefined;
+                hrv_rmssd?: number | undefined;
+            }[] | undefined, import("convex/values").VObject<{
+                timestamp?: string | undefined;
+                hrv_rmssd?: number | undefined;
+            }, {
+                timestamp: import("convex/values").VString<string | undefined, "optional">;
+                hrv_rmssd: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "timestamp" | "hrv_rmssd">, "optional">;
+            hrv_samples_sdnn: import("convex/values").VArray<{
+                timestamp?: string | undefined;
+                hrv_sdnn?: number | undefined;
+            }[] | undefined, import("convex/values").VObject<{
+                timestamp?: string | undefined;
+                hrv_sdnn?: number | undefined;
+            }, {
+                timestamp: import("convex/values").VString<string | undefined, "optional">;
+                hrv_sdnn: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "timestamp" | "hrv_sdnn">, "optional">;
+        }, "optional", "hr_samples" | "hrv_samples_rmssd" | "hrv_samples_sdnn">;
+        summary: import("convex/values").VObject<{
+            avg_hr_bpm?: number | undefined;
+            avg_hrv_rmssd?: number | undefined;
+            avg_hrv_sdnn?: number | undefined;
+            hr_zone_data?: {
+                zone?: number | undefined;
+                start_percentage?: number | undefined;
+                end_percentage?: number | undefined;
+                name?: string | undefined;
+                duration_seconds?: number | undefined;
+            }[] | undefined;
+            max_hr_bpm?: number | undefined;
+            min_hr_bpm?: number | undefined;
+            resting_hr_bpm?: number | undefined;
+            user_max_hr_bpm?: number | undefined;
+        } | undefined, {
+            avg_hr_bpm: import("convex/values").VFloat64<number | undefined, "optional">;
+            avg_hrv_rmssd: import("convex/values").VFloat64<number | undefined, "optional">;
+            avg_hrv_sdnn: import("convex/values").VFloat64<number | undefined, "optional">;
+            hr_zone_data: import("convex/values").VArray<{
+                zone?: number | undefined;
+                start_percentage?: number | undefined;
+                end_percentage?: number | undefined;
+                name?: string | undefined;
+                duration_seconds?: number | undefined;
+            }[] | undefined, import("convex/values").VObject<{
+                zone?: number | undefined;
+                start_percentage?: number | undefined;
+                end_percentage?: number | undefined;
+                name?: string | undefined;
+                duration_seconds?: number | undefined;
+            }, {
+                zone: import("convex/values").VFloat64<number | undefined, "optional">;
+                start_percentage: import("convex/values").VFloat64<number | undefined, "optional">;
+                end_percentage: import("convex/values").VFloat64<number | undefined, "optional">;
+                name: import("convex/values").VString<string | undefined, "optional">;
+                duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+            }, "required", "zone" | "start_percentage" | "end_percentage" | "name" | "duration_seconds">, "optional">;
+            max_hr_bpm: import("convex/values").VFloat64<number | undefined, "optional">;
+            min_hr_bpm: import("convex/values").VFloat64<number | undefined, "optional">;
+            resting_hr_bpm: import("convex/values").VFloat64<number | undefined, "optional">;
+            user_max_hr_bpm: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "optional", "avg_hr_bpm" | "avg_hrv_rmssd" | "avg_hrv_sdnn" | "hr_zone_data" | "max_hr_bpm" | "min_hr_bpm" | "resting_hr_bpm" | "user_max_hr_bpm">;
+    }, "optional", "summary" | "detailed" | "summary.avg_hr_bpm" | "summary.avg_hrv_rmssd" | "summary.avg_hrv_sdnn" | "summary.hr_zone_data" | "summary.max_hr_bpm" | "summary.min_hr_bpm" | "summary.resting_hr_bpm" | "summary.user_max_hr_bpm" | "detailed.hr_samples" | "detailed.hrv_samples_rmssd" | "detailed.hrv_samples_sdnn">;
+    MET_data: import("convex/values").VObject<{
+        MET_samples?: {
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }[] | undefined;
+        avg_level?: number | undefined;
+        num_high_intensity_minutes?: number | undefined;
+        num_inactive_minutes?: number | undefined;
+        num_low_intensity_minutes?: number | undefined;
+        num_moderate_intensity_minutes?: number | undefined;
+    } | undefined, {
+        MET_samples: import("convex/values").VArray<{
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }[] | undefined, import("convex/values").VObject<{
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }, {
+            timestamp: import("convex/values").VString<string | undefined, "optional">;
+            level: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "timestamp" | "level">, "optional">;
+        avg_level: import("convex/values").VFloat64<number | undefined, "optional">;
+        num_high_intensity_minutes: import("convex/values").VFloat64<number | undefined, "optional">;
+        num_inactive_minutes: import("convex/values").VFloat64<number | undefined, "optional">;
+        num_low_intensity_minutes: import("convex/values").VFloat64<number | undefined, "optional">;
+        num_moderate_intensity_minutes: import("convex/values").VFloat64<number | undefined, "optional">;
+    }, "optional", "MET_samples" | "avg_level" | "num_high_intensity_minutes" | "num_inactive_minutes" | "num_low_intensity_minutes" | "num_moderate_intensity_minutes">;
+    metadata: import("convex/values").VObject<{
+        timestamp_localization?: number | undefined;
+        start_time: string;
+        end_time: string;
+        upload_type: number;
+    }, {
+        end_time: import("convex/values").VString<string, "required">;
+        start_time: import("convex/values").VString<string, "required">;
+        timestamp_localization: import("convex/values").VFloat64<number | undefined, "optional">;
+        upload_type: import("convex/values").VFloat64<number, "required">;
+    }, "required", "start_time" | "end_time" | "timestamp_localization" | "upload_type">;
+    oxygen_data: import("convex/values").VObject<{
+        vo2max_ml_per_min_per_kg?: number | undefined;
+        avg_saturation_percentage?: number | undefined;
+        saturation_samples?: {
+            type?: number | undefined;
+            timestamp?: string | undefined;
+            percentage?: number | undefined;
+        }[] | undefined;
+        vo2_samples?: {
+            timestamp?: string | undefined;
+            vo2max_ml_per_min_per_kg?: number | undefined;
+        }[] | undefined;
+    } | undefined, {
+        avg_saturation_percentage: import("convex/values").VFloat64<number | undefined, "optional">;
+        saturation_samples: import("convex/values").VArray<{
+            type?: number | undefined;
+            timestamp?: string | undefined;
+            percentage?: number | undefined;
+        }[] | undefined, import("convex/values").VObject<{
+            type?: number | undefined;
+            timestamp?: string | undefined;
+            percentage?: number | undefined;
+        }, {
+            timestamp: import("convex/values").VString<string | undefined, "optional">;
+            percentage: import("convex/values").VFloat64<number | undefined, "optional">;
+            type: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "type" | "timestamp" | "percentage">, "optional">;
+        vo2_samples: import("convex/values").VArray<{
+            timestamp?: string | undefined;
+            vo2max_ml_per_min_per_kg?: number | undefined;
+        }[] | undefined, import("convex/values").VObject<{
+            timestamp?: string | undefined;
+            vo2max_ml_per_min_per_kg?: number | undefined;
+        }, {
+            timestamp: import("convex/values").VString<string | undefined, "optional">;
+            vo2max_ml_per_min_per_kg: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "timestamp" | "vo2max_ml_per_min_per_kg">, "optional">;
+        vo2max_ml_per_min_per_kg: import("convex/values").VFloat64<number | undefined, "optional">;
+    }, "optional", "vo2max_ml_per_min_per_kg" | "avg_saturation_percentage" | "saturation_samples" | "vo2_samples">;
+    scores: import("convex/values").VObject<{
+        activity?: number | undefined;
+        recovery?: number | undefined;
+        sleep?: number | undefined;
+        biological_age?: number | undefined;
+    } | undefined, {
+        activity: import("convex/values").VFloat64<number | undefined, "optional">;
+        recovery: import("convex/values").VFloat64<number | undefined, "optional">;
+        sleep: import("convex/values").VFloat64<number | undefined, "optional">;
+        biological_age: import("convex/values").VFloat64<number | undefined, "optional">;
+    }, "optional", "activity" | "recovery" | "sleep" | "biological_age">;
+    strain_data: import("convex/values").VObject<{
+        strain_level?: number | undefined;
+    } | undefined, {
+        strain_level: import("convex/values").VFloat64<number | undefined, "optional">;
+    }, "optional", "strain_level">;
+    stress_data: import("convex/values").VObject<{
+        activity_stress_duration_seconds?: number | undefined;
+        avg_stress_level?: number | undefined;
+        body_battery_samples?: {
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }[] | undefined;
+        high_stress_duration_seconds?: number | undefined;
+        low_stress_duration_seconds?: number | undefined;
+        max_stress_level?: number | undefined;
+        medium_stress_duration_seconds?: number | undefined;
+        rest_stress_duration_seconds?: number | undefined;
+        samples?: {
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }[] | undefined;
+        stress_duration_seconds?: number | undefined;
+        stress_rating?: number | undefined;
+    } | undefined, {
+        activity_stress_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        avg_stress_level: import("convex/values").VFloat64<number | undefined, "optional">;
+        body_battery_samples: import("convex/values").VArray<{
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }[] | undefined, import("convex/values").VObject<{
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }, {
+            timestamp: import("convex/values").VString<string | undefined, "optional">;
+            level: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "timestamp" | "level">, "optional">;
+        high_stress_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        low_stress_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        max_stress_level: import("convex/values").VFloat64<number | undefined, "optional">;
+        medium_stress_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        rest_stress_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        samples: import("convex/values").VArray<{
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }[] | undefined, import("convex/values").VObject<{
+            timestamp?: string | undefined;
+            level?: number | undefined;
+        }, {
+            timestamp: import("convex/values").VString<string | undefined, "optional">;
+            level: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "timestamp" | "level">, "optional">;
+        stress_duration_seconds: import("convex/values").VFloat64<number | undefined, "optional">;
+        stress_rating: import("convex/values").VFloat64<number | undefined, "optional">;
+    }, "optional", "activity_stress_duration_seconds" | "avg_stress_level" | "body_battery_samples" | "high_stress_duration_seconds" | "low_stress_duration_seconds" | "max_stress_level" | "medium_stress_duration_seconds" | "rest_stress_duration_seconds" | "samples" | "stress_duration_seconds" | "stress_rating">;
+    tag_data: import("convex/values").VObject<{
+        tags?: {
+            timestamp: string;
+            tag_name: string;
+            notes: string;
+        }[] | undefined;
+    } | undefined, {
+        tags: import("convex/values").VArray<{
+            timestamp: string;
+            tag_name: string;
+            notes: string;
+        }[] | undefined, import("convex/values").VObject<{
+            timestamp: string;
+            tag_name: string;
+            notes: string;
+        }, {
+            timestamp: import("convex/values").VString<string, "required">;
+            tag_name: import("convex/values").VString<string, "required">;
+            notes: import("convex/values").VString<string, "required">;
+        }, "required", "timestamp" | "tag_name" | "notes">, "optional">;
+    }, "optional", "tags">;
+};
+//# sourceMappingURL=daily.d.ts.map

package/dist/component/validators/daily.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daily.d.ts","sourceRoot":"","sources":["../../../src/component/validators/daily.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiJ1B,CAAC"}