@clipin/convex-wearables 0.0.2 → 0.1.0

package/dist/test.d.ts

@@ -0,0 +1,581 @@
+import type { GenericSchema, SchemaDefinition } from "convex/server";
+import type { TestConvex } from "convex-test";
+/**
+ * Register the component with a test Convex instance.
+ * @param t - The test Convex instance, for example from `convexTest`.
+ * @param name - The component name, as registered in the host app.
+ */
+export declare function register(t: TestConvex<SchemaDefinition<GenericSchema, boolean>>, name?: string): void;
+declare const _default: {
+    register: typeof register;
+    schema: SchemaDefinition<{
+        connections: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            providerUserId?: string | undefined;
+            providerUsername?: string | undefined;
+            accessToken?: string | undefined;
+            refreshToken?: string | undefined;
+            tokenExpiresAt?: number | undefined;
+            scope?: string | undefined;
+            lastSyncedAt?: number | undefined;
+            provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
+            status: "error" | "active" | "inactive" | "revoked" | "expired";
+            userId: string;
+        }, {
+            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>;
+            providerUserId: import("convex/values").VString<string | undefined, "optional">;
+            providerUsername: import("convex/values").VString<string | undefined, "optional">;
+            accessToken: import("convex/values").VString<string | undefined, "optional">;
+            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<"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"];
+            by_user_provider: ["userId", "provider", "_creationTime"];
+            by_provider_user: ["provider", "providerUserId", "_creationTime"];
+            by_status: ["status", "_creationTime"];
+        }, {}, {}>;
+        dataSources: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            connectionId?: import("convex/values").GenericId<"connections"> | undefined;
+            deviceModel?: string | undefined;
+            softwareVersion?: string | undefined;
+            source?: string | undefined;
+            deviceType?: string | undefined;
+            originalSourceName?: string | undefined;
+            provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
+            userId: string;
+        }, {
+            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>;
+            connectionId: import("convex/values").VId<import("convex/values").GenericId<"connections"> | undefined, "optional">;
+            deviceModel: import("convex/values").VString<string | undefined, "optional">;
+            softwareVersion: import("convex/values").VString<string | undefined, "optional">;
+            source: import("convex/values").VString<string | undefined, "optional">;
+            deviceType: import("convex/values").VString<string | undefined, "optional">;
+            originalSourceName: import("convex/values").VString<string | undefined, "optional">;
+        }, "required", "provider" | "userId" | "connectionId" | "deviceModel" | "softwareVersion" | "source" | "deviceType" | "originalSourceName">, {
+            by_user_provider: ["userId", "provider", "_creationTime"];
+            by_user_provider_device: ["userId", "provider", "deviceModel", "source", "_creationTime"];
+            by_connection: ["connectionId", "_creationTime"];
+        }, {}, {}>;
+        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").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", "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;
+            heartRateMin?: number | undefined;
+            heartRateMax?: number | undefined;
+            heartRateAvg?: number | undefined;
+            energyBurned?: number | undefined;
+            distance?: number | undefined;
+            stepsCount?: number | undefined;
+            maxSpeed?: number | undefined;
+            maxWatts?: number | undefined;
+            movingTimeSeconds?: number | undefined;
+            totalElevationGain?: number | undefined;
+            averageSpeed?: number | undefined;
+            averageWatts?: number | undefined;
+            elevHigh?: number | undefined;
+            elevLow?: number | undefined;
+            sleepTotalDurationMinutes?: number | undefined;
+            sleepTimeInBedMinutes?: number | undefined;
+            sleepEfficiencyScore?: number | undefined;
+            sleepDeepMinutes?: number | undefined;
+            sleepRemMinutes?: number | undefined;
+            sleepLightMinutes?: number | undefined;
+            sleepAwakeMinutes?: number | undefined;
+            isNap?: boolean | undefined;
+            sleepStages?: {
+                stage: string;
+                startTime: number;
+                endTime: number;
+            }[] | undefined;
+            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">;
+            category: import("convex/values").VUnion<"workout" | "sleep", [import("convex/values").VLiteral<"workout", "required">, import("convex/values").VLiteral<"sleep", "required">], "required", never>;
+            type: import("convex/values").VString<string | undefined, "optional">;
+            sourceName: import("convex/values").VString<string | undefined, "optional">;
+            durationSeconds: import("convex/values").VFloat64<number | undefined, "optional">;
+            startDatetime: import("convex/values").VFloat64<number, "required">;
+            endDatetime: import("convex/values").VFloat64<number | undefined, "optional">;
+            externalId: import("convex/values").VString<string | undefined, "optional">;
+            heartRateMin: import("convex/values").VFloat64<number | undefined, "optional">;
+            heartRateMax: import("convex/values").VFloat64<number | undefined, "optional">;
+            heartRateAvg: import("convex/values").VFloat64<number | undefined, "optional">;
+            energyBurned: import("convex/values").VFloat64<number | undefined, "optional">;
+            distance: import("convex/values").VFloat64<number | undefined, "optional">;
+            stepsCount: import("convex/values").VFloat64<number | undefined, "optional">;
+            maxSpeed: import("convex/values").VFloat64<number | undefined, "optional">;
+            maxWatts: import("convex/values").VFloat64<number | undefined, "optional">;
+            movingTimeSeconds: import("convex/values").VFloat64<number | undefined, "optional">;
+            totalElevationGain: import("convex/values").VFloat64<number | undefined, "optional">;
+            averageSpeed: import("convex/values").VFloat64<number | undefined, "optional">;
+            averageWatts: import("convex/values").VFloat64<number | undefined, "optional">;
+            elevHigh: import("convex/values").VFloat64<number | undefined, "optional">;
+            elevLow: import("convex/values").VFloat64<number | undefined, "optional">;
+            sleepTotalDurationMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            sleepTimeInBedMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            sleepEfficiencyScore: import("convex/values").VFloat64<number | undefined, "optional">;
+            sleepDeepMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            sleepRemMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            sleepLightMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            sleepAwakeMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            isNap: import("convex/values").VBoolean<boolean | undefined, "optional">;
+            sleepStages: import("convex/values").VArray<{
+                stage: string;
+                startTime: number;
+                endTime: number;
+            }[] | undefined, import("convex/values").VObject<{
+                stage: string;
+                startTime: number;
+                endTime: number;
+            }, {
+                stage: import("convex/values").VString<string, "required">;
+                startTime: import("convex/values").VFloat64<number, "required">;
+                endTime: import("convex/values").VFloat64<number, "required">;
+            }, "required", "stage" | "startTime" | "endTime">, "optional">;
+        }, "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"];
+            by_external_id: ["externalId", "_creationTime"];
+        }, {}, {}>;
+        dailySummaries: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            totalSteps?: number | undefined;
+            totalCalories?: number | undefined;
+            activeCalories?: number | undefined;
+            activeMinutes?: number | undefined;
+            totalDistance?: number | undefined;
+            floorsClimbed?: number | undefined;
+            avgHeartRate?: number | undefined;
+            maxHeartRate?: number | undefined;
+            minHeartRate?: number | undefined;
+            sleepDurationMinutes?: number | undefined;
+            sleepEfficiency?: number | undefined;
+            deepSleepMinutes?: number | undefined;
+            remSleepMinutes?: number | undefined;
+            lightSleepMinutes?: number | undefined;
+            awakeDuringMinutes?: number | undefined;
+            timeInBedMinutes?: number | undefined;
+            hrvAvg?: number | undefined;
+            hrvRmssd?: number | undefined;
+            restingHeartRate?: number | undefined;
+            recoveryScore?: number | undefined;
+            weight?: number | undefined;
+            bodyFatPercentage?: number | undefined;
+            bodyMassIndex?: number | undefined;
+            leanBodyMass?: number | undefined;
+            bodyTemperature?: number | undefined;
+            avgStressLevel?: number | undefined;
+            bodyBattery?: number | undefined;
+            spo2Avg?: number | undefined;
+            userId: string;
+            category: string;
+            date: string;
+        }, {
+            userId: import("convex/values").VString<string, "required">;
+            date: import("convex/values").VString<string, "required">;
+            category: import("convex/values").VString<string, "required">;
+            totalSteps: import("convex/values").VFloat64<number | undefined, "optional">;
+            totalCalories: import("convex/values").VFloat64<number | undefined, "optional">;
+            activeCalories: import("convex/values").VFloat64<number | undefined, "optional">;
+            activeMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            totalDistance: import("convex/values").VFloat64<number | undefined, "optional">;
+            floorsClimbed: import("convex/values").VFloat64<number | undefined, "optional">;
+            avgHeartRate: import("convex/values").VFloat64<number | undefined, "optional">;
+            maxHeartRate: import("convex/values").VFloat64<number | undefined, "optional">;
+            minHeartRate: import("convex/values").VFloat64<number | undefined, "optional">;
+            sleepDurationMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            sleepEfficiency: import("convex/values").VFloat64<number | undefined, "optional">;
+            deepSleepMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            remSleepMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            lightSleepMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            awakeDuringMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            timeInBedMinutes: import("convex/values").VFloat64<number | undefined, "optional">;
+            hrvAvg: import("convex/values").VFloat64<number | undefined, "optional">;
+            hrvRmssd: import("convex/values").VFloat64<number | undefined, "optional">;
+            restingHeartRate: import("convex/values").VFloat64<number | undefined, "optional">;
+            recoveryScore: import("convex/values").VFloat64<number | undefined, "optional">;
+            weight: import("convex/values").VFloat64<number | undefined, "optional">;
+            bodyFatPercentage: import("convex/values").VFloat64<number | undefined, "optional">;
+            bodyMassIndex: import("convex/values").VFloat64<number | undefined, "optional">;
+            leanBodyMass: import("convex/values").VFloat64<number | undefined, "optional">;
+            bodyTemperature: import("convex/values").VFloat64<number | undefined, "optional">;
+            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", "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;
+            recordsProcessed?: number | 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: "failed" | "canceled" | "running" | "completed" | "queued";
+            userId: string;
+            connectionId: import("convex/values").GenericId<"connections">;
+            idempotencyKey: 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>;
+            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<"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">;
+            recordsProcessed: import("convex/values").VFloat64<number | undefined, "optional">;
+            workflowId: import("convex/values").VString<string | undefined, "optional">;
+            windowStart: import("convex/values").VFloat64<number | undefined, "optional">;
+            windowEnd: import("convex/values").VFloat64<number | undefined, "optional">;
+            attempt: import("convex/values").VFloat64<number | undefined, "optional">;
+            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" | "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"];
+            by_user_status: ["userId", "status", "_creationTime"];
+            by_status: ["status", "_creationTime"];
+            by_idempotency_key: ["idempotencyKey", "_creationTime"];
+            by_workflow: ["workflowId", "_creationTime"];
+        }, {}, {}>;
+        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;
+            createdAt: number;
+        }, {
+            state: import("convex/values").VString<string, "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>;
+            codeVerifier: import("convex/values").VString<string | undefined, "optional">;
+            redirectUri: import("convex/values").VString<string | undefined, "optional">;
+            createdAt: import("convex/values").VFloat64<number, "required">;
+        }, "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;
+            provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
+            isEnabled: boolean;
+        }, {
+            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>;
+            isEnabled: import("convex/values").VBoolean<boolean, "required">;
+            clientId: import("convex/values").VString<string | undefined, "optional">;
+            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" | "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;
+        }, {
+            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>;
+            priority: import("convex/values").VFloat64<number, "required">;
+        }, "required", "provider" | "priority">, {
+            by_provider: ["provider", "_creationTime"];
+            by_priority: ["priority", "_creationTime"];
+        }, {}, {}>;
+        menstrualCycles: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            externalId?: string | undefined;
+            currentPhase?: number | undefined;
+            dayInCycle?: number | undefined;
+            cycleLength?: number | undefined;
+            predictedCycleLength?: number | undefined;
+            periodLength?: number | undefined;
+            currentPhaseType?: string | undefined;
+            lengthOfCurrentPhase?: number | undefined;
+            daysUntilNextPhase?: number | undefined;
+            isPredictedCycle?: boolean | undefined;
+            fertileWindowStart?: number | undefined;
+            lengthOfFertileWindow?: number | undefined;
+            lastUpdatedAt?: number | undefined;
+            isPregnant?: boolean | undefined;
+            pregnancyDueDate?: string | undefined;
+            pregnancyOriginalDueDate?: string | undefined;
+            pregnancyCycleStartDate?: string | undefined;
+            pregnancyTitle?: string | undefined;
+            numberOfBabies?: string | undefined;
+            provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
+            userId: string;
+            periodStartDate: string;
+        }, {
+            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>;
+            externalId: import("convex/values").VString<string | undefined, "optional">;
+            periodStartDate: import("convex/values").VString<string, "required">;
+            dayInCycle: import("convex/values").VFloat64<number | undefined, "optional">;
+            cycleLength: import("convex/values").VFloat64<number | undefined, "optional">;
+            predictedCycleLength: import("convex/values").VFloat64<number | undefined, "optional">;
+            periodLength: import("convex/values").VFloat64<number | undefined, "optional">;
+            currentPhase: import("convex/values").VFloat64<number | undefined, "optional">;
+            currentPhaseType: import("convex/values").VString<string | undefined, "optional">;
+            lengthOfCurrentPhase: import("convex/values").VFloat64<number | undefined, "optional">;
+            daysUntilNextPhase: import("convex/values").VFloat64<number | undefined, "optional">;
+            isPredictedCycle: import("convex/values").VBoolean<boolean | undefined, "optional">;
+            fertileWindowStart: import("convex/values").VFloat64<number | undefined, "optional">;
+            lengthOfFertileWindow: import("convex/values").VFloat64<number | undefined, "optional">;
+            lastUpdatedAt: import("convex/values").VFloat64<number | undefined, "optional">;
+            isPregnant: import("convex/values").VBoolean<boolean | undefined, "optional">;
+            pregnancyDueDate: import("convex/values").VString<string | undefined, "optional">;
+            pregnancyOriginalDueDate: import("convex/values").VString<string | undefined, "optional">;
+            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", "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"];
+        }, {}, {}>;
+        backfillJobs: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            error?: string | undefined;
+            completedAt?: number | undefined;
+            workflowId?: string | undefined;
+            windowStart?: number | undefined;
+            windowEnd?: number | undefined;
+            lastHeartbeatAt?: number | undefined;
+            currentDataType?: string | undefined;
+            currentAttempt?: number | undefined;
+            currentEventId?: string | undefined;
+            completedDataTypes?: string[] | undefined;
+            startedAt: number;
+            provider: "garmin" | "suunto" | "polar" | "whoop" | "strava" | "apple" | "samsung" | "google";
+            status: "failed" | "canceled" | "running" | "completed" | "queued";
+            userId: string;
+            connectionId: import("convex/values").GenericId<"connections">;
+            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<"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">;
+            workflowId: import("convex/values").VString<string | undefined, "optional">;
+            windowStart: import("convex/values").VFloat64<number | undefined, "optional">;
+            windowEnd: import("convex/values").VFloat64<number | undefined, "optional">;
+            currentDataType: import("convex/values").VString<string | undefined, "optional">;
+            currentAttempt: import("convex/values").VFloat64<number | undefined, "optional">;
+            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" | "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"];
+            by_workflow: ["workflowId", "_creationTime"];
+        }, {}, {}>;
+    }, true>;
+    modules: Record<string, () => Promise<unknown>>;
+};
+export default _default;
+//# sourceMappingURL=test.d.ts.map

package/dist/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK9C;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,UAAU,CAAC,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,EACvD,IAAI,GAAE,MAAoB,QAK3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,wBAA6C"}