@clipin/convex-wearables 0.0.2 → 0.1.0

package/dist/component/schema.d.ts

@@ -5,7 +5,7 @@ export declare const providerName: import("convex/values").VUnion<"garmin" | "su
 /**
  * Connection status enum.
  */
-export declare const connectionStatus: import("convex/values").VUnion<"active" | "inactive" | "revoked" | "expired" | "error", [import("convex/values").VLiteral<"active", "required">, import("convex/values").VLiteral<"inactive", "required">, import("convex/values").VLiteral<"revoked", "required">, import("convex/values").VLiteral<"expired", "required">, import("convex/values").VLiteral<"error", "required">], "required", never>;
+export declare const connectionStatus: import("convex/values").VUnion<"error" | "active" | "inactive" | "revoked" | "expired", [import("convex/values").VLiteral<"active", "required">, import("convex/values").VLiteral<"inactive", "required">, import("convex/values").VLiteral<"revoked", "required">, import("convex/values").VLiteral<"expired", "required">, import("convex/values").VLiteral<"error", "required">], "required", never>;
 /**
  * Event category — top-level classification.
  */
@@ -13,11 +13,15 @@ export declare const eventCategory: import("convex/values").VUnion<"workout" | "
 /**
  * Sync job status.
  */
-export declare const syncJobStatus: import("convex/values").VUnion<"queued" | "running" | "completed" | "failed" | "canceled", [import("convex/values").VLiteral<"queued", "required">, import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"completed", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"canceled", "required">], "required", never>;
+export declare const syncJobStatus: import("convex/values").VUnion<"failed" | "canceled" | "running" | "completed" | "queued", [import("convex/values").VLiteral<"queued", "required">, import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"completed", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"canceled", "required">], "required", never>;
 /**
  * Backfill job status.
  */
-export declare const backfillStatus: import("convex/values").VUnion<"queued" | "running" | "completed" | "failed" | "canceled", [import("convex/values").VLiteral<"queued", "required">, import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"completed", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"canceled", "required">], "required", never>;
+export declare const backfillStatus: import("convex/values").VUnion<"failed" | "canceled" | "running" | "completed" | "queued", [import("convex/values").VLiteral<"queued", "required">, import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"completed", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"canceled", "required">], "required", never>;
+/**
+ * Supported rollup aggregations.
+ */
+export declare const timeSeriesAggregation: import("convex/values").VUnion<"avg" | "min" | "max" | "last" | "count", [import("convex/values").VLiteral<"avg", "required">, import("convex/values").VLiteral<"min", "required">, import("convex/values").VLiteral<"max", "required">, import("convex/values").VLiteral<"last", "required">, import("convex/values").VLiteral<"count", "required">], "required", never>;
 declare const _default: import("convex/server").SchemaDefinition<{
     connections: import("convex/server").TableDefinition<import("convex/values").VObject<{
         providerUserId?: string | undefined;
@@ -28,7 +32,7 @@ declare const _default: import("convex/server").SchemaDefinition<{
         scope?: string | undefined;
         lastSyncedAt?: number | undefined;
         provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
-        status: "active" | "inactive" | "revoked" | "expired" | "error";
+        status: "error" | "active" | "inactive" | "revoked" | "expired";
         userId: string;
     }, {
         userId: import("convex/values").VString<string, "required">;
@@ -39,7 +43,7 @@ declare const _default: import("convex/server").SchemaDefinition<{
         refreshToken: import("convex/values").VString<string | undefined, "optional">;
         tokenExpiresAt: import("convex/values").VFloat64<number | undefined, "optional">;
         scope: import("convex/values").VString<string | undefined, "optional">;
-        status: import("convex/values").VUnion<"active" | "inactive" | "revoked" | "expired" | "error", [import("convex/values").VLiteral<"active", "required">, import("convex/values").VLiteral<"inactive", "required">, import("convex/values").VLiteral<"revoked", "required">, import("convex/values").VLiteral<"expired", "required">, import("convex/values").VLiteral<"error", "required">], "required", never>;
+        status: import("convex/values").VUnion<"error" | "active" | "inactive" | "revoked" | "expired", [import("convex/values").VLiteral<"active", "required">, import("convex/values").VLiteral<"inactive", "required">, import("convex/values").VLiteral<"revoked", "required">, import("convex/values").VLiteral<"expired", "required">, import("convex/values").VLiteral<"error", "required">], "required", never>;
         lastSyncedAt: import("convex/values").VFloat64<number | undefined, "optional">;
     }, "required", "provider" | "status" | "userId" | "providerUserId" | "providerUsername" | "accessToken" | "refreshToken" | "tokenExpiresAt" | "scope" | "lastSyncedAt">, {
         by_user: ["userId", "_creationTime"];
@@ -72,26 +76,58 @@ declare const _default: import("convex/server").SchemaDefinition<{
     }, {}, {}>;
     dataPoints: import("convex/server").TableDefinition<import("convex/values").VObject<{
         externalId?: string | undefined;
+        dataSourceId: import("convex/values").GenericId<"dataSources">;
         seriesType: string;
         recordedAt: number;
         value: number;
-        dataSourceId: import("convex/values").GenericId<"dataSources">;
     }, {
         dataSourceId: import("convex/values").VId<import("convex/values").GenericId<"dataSources">, "required">;
         seriesType: import("convex/values").VString<string, "required">;
         recordedAt: import("convex/values").VFloat64<number, "required">;
         value: import("convex/values").VFloat64<number, "required">;
         externalId: import("convex/values").VString<string | undefined, "optional">;
-    }, "required", "externalId" | "seriesType" | "recordedAt" | "value" | "dataSourceId">, {
+    }, "required", "dataSourceId" | "seriesType" | "recordedAt" | "value" | "externalId">, {
         by_source_type_time: ["dataSourceId", "seriesType", "recordedAt", "_creationTime"];
         by_type_time: ["seriesType", "recordedAt", "_creationTime"];
     }, {}, {}>;
+    timeSeriesRollups: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        avg: number;
+        min: number;
+        max: number;
+        last: number;
+        count: number;
+        dataSourceId: import("convex/values").GenericId<"dataSources">;
+        seriesType: string;
+        bucketMs: number;
+        bucketStart: number;
+        bucketEnd: number;
+        lastRecordedAt: number;
+        updatedAt: number;
+    }, {
+        dataSourceId: import("convex/values").VId<import("convex/values").GenericId<"dataSources">, "required">;
+        seriesType: import("convex/values").VString<string, "required">;
+        bucketMs: import("convex/values").VFloat64<number, "required">;
+        bucketStart: import("convex/values").VFloat64<number, "required">;
+        bucketEnd: import("convex/values").VFloat64<number, "required">;
+        avg: import("convex/values").VFloat64<number, "required">;
+        min: import("convex/values").VFloat64<number, "required">;
+        max: import("convex/values").VFloat64<number, "required">;
+        last: import("convex/values").VFloat64<number, "required">;
+        lastRecordedAt: import("convex/values").VFloat64<number, "required">;
+        count: import("convex/values").VFloat64<number, "required">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+    }, "required", "avg" | "min" | "max" | "last" | "count" | "dataSourceId" | "seriesType" | "bucketMs" | "bucketStart" | "bucketEnd" | "lastRecordedAt" | "updatedAt">, {
+        by_source_type_bucket: ["dataSourceId", "seriesType", "bucketStart", "_creationTime"];
+        by_source_type_bucket_size: ["dataSourceId", "seriesType", "bucketMs", "bucketStart", "_creationTime"];
+        by_source_bucket: ["dataSourceId", "bucketStart", "_creationTime"];
+        by_type_bucket: ["seriesType", "bucketStart", "_creationTime"];
+    }, {}, {}>;
     events: import("convex/server").TableDefinition<import("convex/values").VObject<{
         type?: string | undefined;
+        externalId?: string | undefined;
         sourceName?: string | undefined;
         durationSeconds?: number | undefined;
         endDatetime?: number | undefined;
-        externalId?: string | undefined;
         heartRateMin?: number | undefined;
         heartRateMax?: number | undefined;
         heartRateAvg?: number | undefined;
@@ -119,10 +155,10 @@ declare const _default: import("convex/server").SchemaDefinition<{
             startTime: number;
             endTime: number;
         }[] | undefined;
-        category: "workout" | "sleep";
-        startDatetime: number;
         userId: string;
         dataSourceId: import("convex/values").GenericId<"dataSources">;
+        category: "workout" | "sleep";
+        startDatetime: number;
     }, {
         dataSourceId: import("convex/values").VId<import("convex/values").GenericId<"dataSources">, "required">;
         userId: import("convex/values").VString<string, "required">;
@@ -168,7 +204,7 @@ declare const _default: import("convex/server").SchemaDefinition<{
             startTime: import("convex/values").VFloat64<number, "required">;
             endTime: import("convex/values").VFloat64<number, "required">;
         }, "required", "stage" | "startTime" | "endTime">, "optional">;
-    }, "required", "category" | "type" | "sourceName" | "durationSeconds" | "startDatetime" | "endDatetime" | "externalId" | "heartRateMin" | "heartRateMax" | "heartRateAvg" | "energyBurned" | "distance" | "stepsCount" | "maxSpeed" | "maxWatts" | "movingTimeSeconds" | "totalElevationGain" | "averageSpeed" | "averageWatts" | "elevHigh" | "elevLow" | "sleepTotalDurationMinutes" | "sleepTimeInBedMinutes" | "sleepEfficiencyScore" | "sleepDeepMinutes" | "sleepRemMinutes" | "sleepLightMinutes" | "sleepAwakeMinutes" | "isNap" | "sleepStages" | "userId" | "dataSourceId">, {
+    }, "required", "type" | "userId" | "dataSourceId" | "externalId" | "category" | "sourceName" | "durationSeconds" | "startDatetime" | "endDatetime" | "heartRateMin" | "heartRateMax" | "heartRateAvg" | "energyBurned" | "distance" | "stepsCount" | "maxSpeed" | "maxWatts" | "movingTimeSeconds" | "totalElevationGain" | "averageSpeed" | "averageWatts" | "elevHigh" | "elevLow" | "sleepTotalDurationMinutes" | "sleepTimeInBedMinutes" | "sleepEfficiencyScore" | "sleepDeepMinutes" | "sleepRemMinutes" | "sleepLightMinutes" | "sleepAwakeMinutes" | "isNap" | "sleepStages">, {
         by_user_category_time: ["userId", "category", "startDatetime", "_creationTime"];
         by_source_category_time: ["dataSourceId", "category", "startDatetime", "_creationTime"];
         by_source_start_end: ["dataSourceId", "startDatetime", "endDatetime", "_creationTime"];
@@ -203,8 +239,8 @@ declare const _default: import("convex/server").SchemaDefinition<{
         avgStressLevel?: number | undefined;
         bodyBattery?: number | undefined;
         spo2Avg?: number | undefined;
-        category: string;
         userId: string;
+        category: string;
         date: string;
     }, {
         userId: import("convex/values").VString<string, "required">;
@@ -238,29 +274,29 @@ declare const _default: import("convex/server").SchemaDefinition<{
         avgStressLevel: import("convex/values").VFloat64<number | undefined, "optional">;
         bodyBattery: import("convex/values").VFloat64<number | undefined, "optional">;
         spo2Avg: import("convex/values").VFloat64<number | undefined, "optional">;
-    }, "required", "category" | "userId" | "date" | "totalSteps" | "totalCalories" | "activeCalories" | "activeMinutes" | "totalDistance" | "floorsClimbed" | "avgHeartRate" | "maxHeartRate" | "minHeartRate" | "sleepDurationMinutes" | "sleepEfficiency" | "deepSleepMinutes" | "remSleepMinutes" | "lightSleepMinutes" | "awakeDuringMinutes" | "timeInBedMinutes" | "hrvAvg" | "hrvRmssd" | "restingHeartRate" | "recoveryScore" | "weight" | "bodyFatPercentage" | "bodyMassIndex" | "leanBodyMass" | "bodyTemperature" | "avgStressLevel" | "bodyBattery" | "spo2Avg">, {
+    }, "required", "userId" | "category" | "date" | "totalSteps" | "totalCalories" | "activeCalories" | "activeMinutes" | "totalDistance" | "floorsClimbed" | "avgHeartRate" | "maxHeartRate" | "minHeartRate" | "sleepDurationMinutes" | "sleepEfficiency" | "deepSleepMinutes" | "remSleepMinutes" | "lightSleepMinutes" | "awakeDuringMinutes" | "timeInBedMinutes" | "hrvAvg" | "hrvRmssd" | "restingHeartRate" | "recoveryScore" | "weight" | "bodyFatPercentage" | "bodyMassIndex" | "leanBodyMass" | "bodyTemperature" | "avgStressLevel" | "bodyBattery" | "spo2Avg">, {
         by_user_category_date: ["userId", "category", "date", "_creationTime"];
         by_user_date: ["userId", "date", "_creationTime"];
     }, {}, {}>;
     syncJobs: import("convex/server").TableDefinition<import("convex/values").VObject<{
         error?: string | undefined;
+        completedAt?: number | undefined;
+        workflowId?: string | undefined;
         mode?: "manual" | "cron" | "webhook" | undefined;
         triggerSource?: string | undefined;
-        completedAt?: number | undefined;
         recordsProcessed?: number | undefined;
-        workflowId?: string | undefined;
         windowStart?: number | undefined;
         windowEnd?: number | undefined;
         attempt?: number | undefined;
         lastHeartbeatAt?: number | undefined;
         cursor?: string | undefined;
         currentPhase?: "events" | "dataPoints" | "summaries" | undefined;
+        startedAt: number;
         provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
-        status: "queued" | "running" | "completed" | "failed" | "canceled";
+        status: "failed" | "canceled" | "running" | "completed" | "queued";
         userId: string;
         connectionId: import("convex/values").GenericId<"connections">;
         idempotencyKey: string;
-        startedAt: number;
     }, {
         connectionId: import("convex/values").VId<import("convex/values").GenericId<"connections">, "required">;
         userId: import("convex/values").VString<string, "required">;
@@ -268,7 +304,7 @@ declare const _default: import("convex/server").SchemaDefinition<{
         mode: import("convex/values").VUnion<"manual" | "cron" | "webhook" | undefined, [import("convex/values").VLiteral<"manual", "required">, import("convex/values").VLiteral<"cron", "required">, import("convex/values").VLiteral<"webhook", "required">], "optional", never>;
         triggerSource: import("convex/values").VString<string | undefined, "optional">;
         idempotencyKey: import("convex/values").VString<string, "required">;
-        status: import("convex/values").VUnion<"queued" | "running" | "completed" | "failed" | "canceled", [import("convex/values").VLiteral<"queued", "required">, import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"completed", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"canceled", "required">], "required", never>;
+        status: import("convex/values").VUnion<"failed" | "canceled" | "running" | "completed" | "queued", [import("convex/values").VLiteral<"queued", "required">, import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"completed", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"canceled", "required">], "required", never>;
         startedAt: import("convex/values").VFloat64<number, "required">;
         completedAt: import("convex/values").VFloat64<number | undefined, "optional">;
         error: import("convex/values").VString<string | undefined, "optional">;
@@ -280,7 +316,7 @@ declare const _default: import("convex/server").SchemaDefinition<{
         lastHeartbeatAt: import("convex/values").VFloat64<number | undefined, "optional">;
         cursor: import("convex/values").VString<string | undefined, "optional">;
         currentPhase: import("convex/values").VUnion<"events" | "dataPoints" | "summaries" | undefined, [import("convex/values").VLiteral<"events", "required">, import("convex/values").VLiteral<"dataPoints", "required">, import("convex/values").VLiteral<"summaries", "required">], "optional", never>;
-    }, "required", "error" | "provider" | "status" | "userId" | "connectionId" | "mode" | "triggerSource" | "idempotencyKey" | "startedAt" | "completedAt" | "recordsProcessed" | "workflowId" | "windowStart" | "windowEnd" | "attempt" | "lastHeartbeatAt" | "cursor" | "currentPhase">, {
+    }, "required", "error" | "startedAt" | "completedAt" | "workflowId" | "provider" | "status" | "userId" | "connectionId" | "mode" | "triggerSource" | "idempotencyKey" | "recordsProcessed" | "windowStart" | "windowEnd" | "attempt" | "lastHeartbeatAt" | "cursor" | "currentPhase">, {
         by_user: ["userId", "_creationTime"];
         by_connection: ["connectionId", "_creationTime"];
         by_user_provider: ["userId", "provider", "_creationTime"];
@@ -292,9 +328,9 @@ declare const _default: import("convex/server").SchemaDefinition<{
     oauthStates: import("convex/server").TableDefinition<import("convex/values").VObject<{
         codeVerifier?: string | undefined;
         redirectUri?: string | undefined;
+        state: string;
         provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
         userId: string;
-        state: string;
         createdAt: number;
     }, {
         state: import("convex/values").VString<string, "required">;
@@ -303,14 +339,14 @@ declare const _default: import("convex/server").SchemaDefinition<{
         codeVerifier: import("convex/values").VString<string | undefined, "optional">;
         redirectUri: import("convex/values").VString<string | undefined, "optional">;
         createdAt: import("convex/values").VFloat64<number, "required">;
-    }, "required", "provider" | "userId" | "state" | "codeVerifier" | "redirectUri" | "createdAt">, {
+    }, "required", "state" | "provider" | "userId" | "codeVerifier" | "redirectUri" | "createdAt">, {
         by_state: ["state", "_creationTime"];
     }, {}, {}>;
     providerSettings: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        updatedAt?: number | undefined;
         clientId?: string | undefined;
         clientSecret?: string | undefined;
         subscriptionKey?: string | undefined;
-        updatedAt?: number | undefined;
         provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
         isEnabled: boolean;
     }, {
@@ -320,9 +356,137 @@ declare const _default: import("convex/server").SchemaDefinition<{
         clientSecret: import("convex/values").VString<string | undefined, "optional">;
         subscriptionKey: import("convex/values").VString<string | undefined, "optional">;
         updatedAt: import("convex/values").VFloat64<number | undefined, "optional">;
-    }, "required", "provider" | "isEnabled" | "clientId" | "clientSecret" | "subscriptionKey" | "updatedAt">, {
+    }, "required", "provider" | "updatedAt" | "isEnabled" | "clientId" | "clientSecret" | "subscriptionKey">, {
         by_provider: ["provider", "_creationTime"];
     }, {}, {}>;
+    timeSeriesPolicyRules: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        provider?: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google" | undefined;
+        seriesType?: string | undefined;
+        updatedAt: number;
+        policySetKind: "default" | "preset";
+        policySetKey: string;
+        scopeKey: string;
+        tiers: ({
+            kind: "raw";
+            fromAgeMs: number;
+            toAgeMs: number | null;
+        } | {
+            kind: "rollup";
+            bucketMs: number;
+            fromAgeMs: number;
+            toAgeMs: number | null;
+            aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+        })[];
+    }, {
+        policySetKind: import("convex/values").VUnion<"default" | "preset", [import("convex/values").VLiteral<"default", "required">, import("convex/values").VLiteral<"preset", "required">], "required", never>;
+        policySetKey: import("convex/values").VString<string, "required">;
+        scopeKey: import("convex/values").VString<string, "required">;
+        provider: import("convex/values").VUnion<"garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google" | undefined, [import("convex/values").VLiteral<"garmin", "required">, import("convex/values").VLiteral<"suunto", "required">, import("convex/values").VLiteral<"polar", "required">, import("convex/values").VLiteral<"whoop", "required">, import("convex/values").VLiteral<"strava", "required">, import("convex/values").VLiteral<"apple", "required">, import("convex/values").VLiteral<"samsung", "required">, import("convex/values").VLiteral<"google", "required">], "optional", never>;
+        seriesType: import("convex/values").VString<string | undefined, "optional">;
+        tiers: import("convex/values").VArray<({
+            kind: "raw";
+            fromAgeMs: number;
+            toAgeMs: number | null;
+        } | {
+            kind: "rollup";
+            bucketMs: number;
+            fromAgeMs: number;
+            toAgeMs: number | null;
+            aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+        })[], import("convex/values").VUnion<{
+            kind: "raw";
+            fromAgeMs: number;
+            toAgeMs: number | null;
+        } | {
+            kind: "rollup";
+            bucketMs: number;
+            fromAgeMs: number;
+            toAgeMs: number | null;
+            aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+        }, [import("convex/values").VObject<{
+            kind: "raw";
+            fromAgeMs: number;
+            toAgeMs: number | null;
+        }, {
+            kind: import("convex/values").VLiteral<"raw", "required">;
+            fromAgeMs: import("convex/values").VFloat64<number, "required">;
+            toAgeMs: import("convex/values").VUnion<number | null, [import("convex/values").VFloat64<number, "required">, import("convex/values").VNull<null, "required">], "required", never>;
+        }, "required", "kind" | "fromAgeMs" | "toAgeMs">, import("convex/values").VObject<{
+            kind: "rollup";
+            bucketMs: number;
+            fromAgeMs: number;
+            toAgeMs: number | null;
+            aggregations: ("avg" | "min" | "max" | "last" | "count")[];
+        }, {
+            kind: import("convex/values").VLiteral<"rollup", "required">;
+            fromAgeMs: import("convex/values").VFloat64<number, "required">;
+            toAgeMs: import("convex/values").VUnion<number | null, [import("convex/values").VFloat64<number, "required">, import("convex/values").VNull<null, "required">], "required", never>;
+            bucketMs: import("convex/values").VFloat64<number, "required">;
+            aggregations: import("convex/values").VArray<("avg" | "min" | "max" | "last" | "count")[], import("convex/values").VUnion<"avg" | "min" | "max" | "last" | "count", [import("convex/values").VLiteral<"avg", "required">, import("convex/values").VLiteral<"min", "required">, import("convex/values").VLiteral<"max", "required">, import("convex/values").VLiteral<"last", "required">, import("convex/values").VLiteral<"count", "required">], "required", never>, "required">;
+        }, "required", "kind" | "bucketMs" | "fromAgeMs" | "toAgeMs" | "aggregations">], "required", "kind" | "bucketMs" | "fromAgeMs" | "toAgeMs" | "aggregations">, "required">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+    }, "required", "provider" | "seriesType" | "updatedAt" | "policySetKind" | "policySetKey" | "scopeKey" | "tiers">, {
+        by_set: ["policySetKind", "policySetKey", "_creationTime"];
+        by_set_scope: ["policySetKind", "policySetKey", "provider", "seriesType", "_creationTime"];
+    }, {}, {}>;
+    timeSeriesPolicyAssignments: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        userId: string;
+        updatedAt: number;
+        presetKey: string;
+    }, {
+        userId: import("convex/values").VString<string, "required">;
+        presetKey: import("convex/values").VString<string, "required">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+    }, "required", "userId" | "updatedAt" | "presetKey">, {
+        by_user: ["userId", "_creationTime"];
+        by_preset: ["presetKey", "_creationTime"];
+    }, {}, {}>;
+    timeSeriesPolicySettings: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        scheduledAt?: number | undefined;
+        lastRunAt?: number | undefined;
+        lastError?: string | undefined;
+        updatedAt: number;
+        key: string;
+        maintenanceEnabled: boolean;
+        maintenanceIntervalMs: number;
+    }, {
+        key: import("convex/values").VString<string, "required">;
+        maintenanceEnabled: import("convex/values").VBoolean<boolean, "required">;
+        maintenanceIntervalMs: import("convex/values").VFloat64<number, "required">;
+        scheduledAt: import("convex/values").VFloat64<number | undefined, "optional">;
+        lastRunAt: import("convex/values").VFloat64<number | undefined, "optional">;
+        lastError: import("convex/values").VString<string | undefined, "optional">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+    }, "required", "updatedAt" | "key" | "maintenanceEnabled" | "maintenanceIntervalMs" | "scheduledAt" | "lastRunAt" | "lastError">, {
+        by_key: ["key", "_creationTime"];
+    }, {}, {}>;
+    timeSeriesSeriesState: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        connectionId?: import("convex/values").GenericId<"connections"> | undefined;
+        lastMaintenanceAt?: number | undefined;
+        provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
+        userId: string;
+        dataSourceId: import("convex/values").GenericId<"dataSources">;
+        seriesType: string;
+        updatedAt: number;
+        latestRecordedAt: number;
+        lastIngestedAt: number;
+        nextMaintenanceAt: number;
+    }, {
+        dataSourceId: import("convex/values").VId<import("convex/values").GenericId<"dataSources">, "required">;
+        connectionId: import("convex/values").VId<import("convex/values").GenericId<"connections"> | undefined, "optional">;
+        userId: import("convex/values").VString<string, "required">;
+        provider: import("convex/values").VUnion<"garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google", [import("convex/values").VLiteral<"garmin", "required">, import("convex/values").VLiteral<"suunto", "required">, import("convex/values").VLiteral<"polar", "required">, import("convex/values").VLiteral<"whoop", "required">, import("convex/values").VLiteral<"strava", "required">, import("convex/values").VLiteral<"apple", "required">, import("convex/values").VLiteral<"samsung", "required">, import("convex/values").VLiteral<"google", "required">], "required", never>;
+        seriesType: import("convex/values").VString<string, "required">;
+        latestRecordedAt: import("convex/values").VFloat64<number, "required">;
+        lastIngestedAt: import("convex/values").VFloat64<number, "required">;
+        nextMaintenanceAt: import("convex/values").VFloat64<number, "required">;
+        lastMaintenanceAt: import("convex/values").VFloat64<number | undefined, "optional">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+    }, "required", "provider" | "userId" | "connectionId" | "dataSourceId" | "seriesType" | "updatedAt" | "latestRecordedAt" | "lastIngestedAt" | "nextMaintenanceAt" | "lastMaintenanceAt">, {
+        by_source_series: ["dataSourceId", "seriesType", "_creationTime"];
+        by_next_maintenance: ["nextMaintenanceAt", "_creationTime"];
+        by_user: ["userId", "_creationTime"];
+    }, {}, {}>;
     providerPriorities: import("convex/server").TableDefinition<import("convex/values").VObject<{
         provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
         priority: number;
@@ -379,7 +543,7 @@ declare const _default: import("convex/server").SchemaDefinition<{
         pregnancyCycleStartDate: import("convex/values").VString<string | undefined, "optional">;
         pregnancyTitle: import("convex/values").VString<string | undefined, "optional">;
         numberOfBabies: import("convex/values").VString<string | undefined, "optional">;
-    }, "required", "externalId" | "provider" | "userId" | "currentPhase" | "periodStartDate" | "dayInCycle" | "cycleLength" | "predictedCycleLength" | "periodLength" | "currentPhaseType" | "lengthOfCurrentPhase" | "daysUntilNextPhase" | "isPredictedCycle" | "fertileWindowStart" | "lengthOfFertileWindow" | "lastUpdatedAt" | "isPregnant" | "pregnancyDueDate" | "pregnancyOriginalDueDate" | "pregnancyCycleStartDate" | "pregnancyTitle" | "numberOfBabies">, {
+    }, "required", "provider" | "userId" | "externalId" | "currentPhase" | "periodStartDate" | "dayInCycle" | "cycleLength" | "predictedCycleLength" | "periodLength" | "currentPhaseType" | "lengthOfCurrentPhase" | "daysUntilNextPhase" | "isPredictedCycle" | "fertileWindowStart" | "lengthOfFertileWindow" | "lastUpdatedAt" | "isPregnant" | "pregnancyDueDate" | "pregnancyOriginalDueDate" | "pregnancyCycleStartDate" | "pregnancyTitle" | "numberOfBabies">, {
         by_user_date: ["userId", "periodStartDate", "_creationTime"];
         by_user_provider: ["userId", "provider", "_creationTime"];
         by_external_id: ["externalId", "_creationTime"];
@@ -395,18 +559,18 @@ declare const _default: import("convex/server").SchemaDefinition<{
         currentAttempt?: number | undefined;
         currentEventId?: string | undefined;
         completedDataTypes?: string[] | undefined;
+        startedAt: number;
         provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
-        status: "queued" | "running" | "completed" | "failed" | "canceled";
+        status: "failed" | "canceled" | "running" | "completed" | "queued";
         userId: string;
         connectionId: import("convex/values").GenericId<"connections">;
-        startedAt: number;
         dataType: string;
     }, {
         connectionId: import("convex/values").VId<import("convex/values").GenericId<"connections">, "required">;
         userId: import("convex/values").VString<string, "required">;
         provider: import("convex/values").VUnion<"garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google", [import("convex/values").VLiteral<"garmin", "required">, import("convex/values").VLiteral<"suunto", "required">, import("convex/values").VLiteral<"polar", "required">, import("convex/values").VLiteral<"whoop", "required">, import("convex/values").VLiteral<"strava", "required">, import("convex/values").VLiteral<"apple", "required">, import("convex/values").VLiteral<"samsung", "required">, import("convex/values").VLiteral<"google", "required">], "required", never>;
         dataType: import("convex/values").VString<string, "required">;
-        status: import("convex/values").VUnion<"queued" | "running" | "completed" | "failed" | "canceled", [import("convex/values").VLiteral<"queued", "required">, import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"completed", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"canceled", "required">], "required", never>;
+        status: import("convex/values").VUnion<"failed" | "canceled" | "running" | "completed" | "queued", [import("convex/values").VLiteral<"queued", "required">, import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"completed", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"canceled", "required">], "required", never>;
         startedAt: import("convex/values").VFloat64<number, "required">;
         completedAt: import("convex/values").VFloat64<number | undefined, "optional">;
         error: import("convex/values").VString<string | undefined, "optional">;
@@ -418,7 +582,7 @@ declare const _default: import("convex/server").SchemaDefinition<{
         currentEventId: import("convex/values").VString<string | undefined, "optional">;
         completedDataTypes: import("convex/values").VArray<string[] | undefined, import("convex/values").VString<string, "required">, "optional">;
         lastHeartbeatAt: import("convex/values").VFloat64<number | undefined, "optional">;
-    }, "required", "error" | "provider" | "status" | "userId" | "connectionId" | "startedAt" | "completedAt" | "workflowId" | "windowStart" | "windowEnd" | "lastHeartbeatAt" | "dataType" | "currentDataType" | "currentAttempt" | "currentEventId" | "completedDataTypes">, {
+    }, "required", "error" | "startedAt" | "completedAt" | "workflowId" | "provider" | "status" | "userId" | "connectionId" | "windowStart" | "windowEnd" | "lastHeartbeatAt" | "dataType" | "currentDataType" | "currentAttempt" | "currentEventId" | "completedDataTypes">, {
         by_connection: ["connectionId", "_creationTime"];
         by_connection_type: ["connectionId", "dataType", "_creationTime"];
         by_status: ["status", "_creationTime"];

package/dist/component/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,YAAY,wkBASxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,yYAM5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,0LAAoD,CAAC;AAE/E;;GAEG;AACH,eAAO,MAAM,aAAa,+YAMzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,+YAM1B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMF,wBAuRG"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,YAAY,wkBASxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,yYAM5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,0LAAoD,CAAC;AAE/E;;GAEG;AACH,eAAO,MAAM,aAAa,+YAMzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,+YAM1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,2WAMjC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMF,wBAsXG"}

package/dist/component/schema.js

@@ -20,6 +20,10 @@ export const syncJobStatus = v.union(v.literal("queued"), v.literal("running"),
  * Backfill job status.
  */
 export const backfillStatus = v.union(v.literal("queued"), v.literal("running"), v.literal("completed"), v.literal("failed"), v.literal("canceled"));
+/**
+ * Supported rollup aggregations.
+ */
+export const timeSeriesAggregation = v.union(v.literal("avg"), v.literal("min"), v.literal("max"), v.literal("last"), v.literal("count"));
 // ---------------------------------------------------------------------------
 // Schema
 // ---------------------------------------------------------------------------
@@ -72,6 +76,27 @@ export default defineSchema({
         .index("by_source_type_time", ["dataSourceId", "seriesType", "recordedAt"])
         .index("by_type_time", ["seriesType", "recordedAt"]),
     // -------------------------------------------------------------------------
+    // Time-Series Rollups — bucketed storage for dense historical series
+    // -------------------------------------------------------------------------
+    timeSeriesRollups: defineTable({
+        dataSourceId: v.id("dataSources"),
+        seriesType: v.string(),
+        bucketMs: v.number(),
+        bucketStart: v.number(),
+        bucketEnd: v.number(),
+        avg: v.number(),
+        min: v.number(),
+        max: v.number(),
+        last: v.number(),
+        lastRecordedAt: v.number(),
+        count: v.number(),
+        updatedAt: v.number(),
+    })
+        .index("by_source_type_bucket", ["dataSourceId", "seriesType", "bucketStart"])
+        .index("by_source_type_bucket_size", ["dataSourceId", "seriesType", "bucketMs", "bucketStart"])
+        .index("by_source_bucket", ["dataSourceId", "bucketStart"])
+        .index("by_type_bucket", ["seriesType", "bucketStart"]),
+    // -------------------------------------------------------------------------
     // Events — workouts and sleep sessions
     // -------------------------------------------------------------------------
     events: defineTable({
@@ -214,6 +239,70 @@ export default defineSchema({
         updatedAt: v.optional(v.number()),
     }).index("by_provider", ["provider"]),
     // -------------------------------------------------------------------------
+    // Time-Series Policy Rules — default and preset-based storage rules
+    // -------------------------------------------------------------------------
+    timeSeriesPolicyRules: defineTable({
+        policySetKind: v.union(v.literal("default"), v.literal("preset")),
+        policySetKey: v.string(), // "__default__" or host-defined preset key
+        scopeKey: v.string(),
+        provider: v.optional(providerName),
+        seriesType: v.optional(v.string()),
+        tiers: v.array(v.union(v.object({
+            kind: v.literal("raw"),
+            fromAgeMs: v.number(),
+            toAgeMs: v.union(v.number(), v.null()),
+        }), v.object({
+            kind: v.literal("rollup"),
+            fromAgeMs: v.number(),
+            toAgeMs: v.union(v.number(), v.null()),
+            bucketMs: v.number(),
+            aggregations: v.array(timeSeriesAggregation),
+        }))),
+        updatedAt: v.number(),
+    })
+        .index("by_set", ["policySetKind", "policySetKey"])
+        .index("by_set_scope", ["policySetKind", "policySetKey", "provider", "seriesType"]),
+    // -------------------------------------------------------------------------
+    // Time-Series Policy Assignments — per-user preset selection
+    // -------------------------------------------------------------------------
+    timeSeriesPolicyAssignments: defineTable({
+        userId: v.string(),
+        presetKey: v.string(),
+        updatedAt: v.number(),
+    })
+        .index("by_user", ["userId"])
+        .index("by_preset", ["presetKey"]),
+    // -------------------------------------------------------------------------
+    // Time-Series Policy Settings — singleton settings for maintenance
+    // -------------------------------------------------------------------------
+    timeSeriesPolicySettings: defineTable({
+        key: v.string(),
+        maintenanceEnabled: v.boolean(),
+        maintenanceIntervalMs: v.number(),
+        scheduledAt: v.optional(v.number()),
+        lastRunAt: v.optional(v.number()),
+        lastError: v.optional(v.string()),
+        updatedAt: v.number(),
+    }).index("by_key", ["key"]),
+    // -------------------------------------------------------------------------
+    // Time-Series Series State — per source/series maintenance cursor
+    // -------------------------------------------------------------------------
+    timeSeriesSeriesState: defineTable({
+        dataSourceId: v.id("dataSources"),
+        connectionId: v.optional(v.id("connections")),
+        userId: v.string(),
+        provider: providerName,
+        seriesType: v.string(),
+        latestRecordedAt: v.number(),
+        lastIngestedAt: v.number(),
+        nextMaintenanceAt: v.number(),
+        lastMaintenanceAt: v.optional(v.number()),
+        updatedAt: v.number(),
+    })
+        .index("by_source_series", ["dataSourceId", "seriesType"])
+        .index("by_next_maintenance", ["nextMaintenanceAt"])
+        .index("by_user", ["userId"]),
+    // -------------------------------------------------------------------------
     // Provider Priorities — sync order when multiple providers have same data
     // -------------------------------------------------------------------------
     providerPriorities: defineTable({