@openlifelog/sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1101 @@
+type MeasurementSystem = 'metric' | 'imperial';
+type DateTime = string;
+type DateString = string;
+type UUID = string;
+interface PageInfo {
+    nextCursor?: string;
+    hasMore: boolean;
+}
+interface ListResponse<T> {
+    data: T[];
+    pageInfo: PageInfo;
+}
+interface ListParams {
+    limit?: number;
+    cursor?: string;
+}
+interface DateRangeParams {
+    startDate?: DateString;
+    endDate?: DateString;
+}
+interface SearchParams extends ListParams {
+    search?: string;
+    q?: string;
+}
+interface CountResponse {
+    count: number;
+}
+interface SuccessResponse<T = any> {
+    success: boolean;
+    data?: T;
+    message?: string;
+}
+interface ErrorResponse {
+    error: string;
+    message?: string;
+    code?: number;
+}
+type MealType = 'breakfast' | 'lunch' | 'dinner' | 'snack';
+type SessionStatus = 'planned' | 'in_progress' | 'completed' | 'abandoned' | 'paused';
+type GoalTargetType = 'exact' | 'min' | 'max';
+type NutritionGoalType = 'exact' | 'range' | 'min' | 'max';
+type ExerciseCategory = 'strength' | 'cardio' | 'flexibility' | 'sport' | 'other';
+type MovementPattern = 'compound' | 'isolation' | 'unilateral' | 'bilateral';
+type ForceDirection = 'push' | 'pull' | 'static' | 'dynamic';
+type WorkoutFormat = 'straight_sets' | 'superset' | 'circuit' | 'pyramid' | 'drop_set' | 'rest_pause' | 'emom';
+type MuscleGroup = 'chest' | 'back' | 'shoulders' | 'biceps' | 'triceps' | 'forearms' | 'abs' | 'obliques' | 'quadriceps' | 'hamstrings' | 'glutes' | 'calves' | 'traps' | 'lats' | 'front_delts' | 'side_delts' | 'rear_delts';
+type Equipment = 'barbell' | 'dumbbell' | 'kettlebell' | 'machine' | 'cable' | 'bodyweight' | 'resistance_band' | 'bench' | 'rack' | 'pull_up_bar';
+type RecordType = 'weight' | 'reps' | 'volume' | 'distance' | 'duration';
+
+interface User {
+    id: UUID;
+    name: string;
+    email: string;
+    emailVerified: boolean;
+    isActive: boolean;
+    isOnboarded: boolean;
+    timezone: string;
+    locale: string;
+    dateFormat: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+}
+interface UserPreferences {
+    userId: UUID;
+    measurementSystem: MeasurementSystem;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+}
+interface SignupRequest {
+    name: string;
+    email: string;
+    password: string;
+}
+interface LoginRequest {
+    email: string;
+    password: string;
+}
+interface AuthResponse {
+    token: string;
+    user: User;
+}
+interface PasswordResetRequest {
+    email: string;
+}
+interface PasswordResetConfirm {
+    token: string;
+    newPassword: string;
+}
+interface UpdateUserRequest {
+    name?: string;
+    isOnboarded?: boolean;
+    timezone?: string;
+    locale?: string;
+    dateFormat?: string;
+}
+interface UpdatePreferencesRequest {
+    measurementSystem?: MeasurementSystem;
+}
+
+interface NutritionalInformation {
+    calories: number;
+    protein: number;
+    carbohydrates: number;
+    fat: number;
+    fiber?: number;
+    sugar?: number;
+    saturatedFat?: number;
+    transFat?: number;
+    cholesterol?: number;
+    sodium?: number;
+    potassium?: number;
+    calcium?: number;
+    iron?: number;
+    vitaminA?: number;
+    vitaminC?: number;
+    vitaminD?: number;
+    vitaminE?: number;
+    vitaminK?: number;
+    vitaminB6?: number;
+    vitaminB12?: number;
+    thiamin?: number;
+    riboflavin?: number;
+    niacin?: number;
+    folate?: number;
+    magnesium?: number;
+    phosphorus?: number;
+    zinc?: number;
+    copper?: number;
+    manganese?: number;
+    selenium?: number;
+    alanine?: number;
+    arginine?: number;
+    asparticAcid?: number;
+    cysteine?: number;
+    glutamicAcid?: number;
+    glycine?: number;
+    histidine?: number;
+    isoleucine?: number;
+    leucine?: number;
+    lysine?: number;
+    methionine?: number;
+    phenylalanine?: number;
+    proline?: number;
+    serine?: number;
+    threonine?: number;
+    tryptophan?: number;
+    tyrosine?: number;
+    valine?: number;
+}
+interface ServingSize {
+    name: string;
+    grams: number;
+    isDefault: boolean;
+}
+interface Food {
+    id: UUID;
+    name: string;
+    description?: string;
+    brand?: string;
+    barcodeUpc?: string;
+    barcodeEan?: string;
+    barcodeGtin?: string;
+    barcodeOther?: string;
+    type: 'food' | 'beverage' | 'meal';
+    nutrients: NutritionalInformation;
+    servingSizes: ServingSize[];
+    calories: number;
+    protein: number;
+    carbs: number;
+    fat: number;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+}
+interface CreateFoodRequest {
+    name: string;
+    description?: string;
+    brand?: string;
+    barcodeUpc?: string;
+    barcodeEan?: string;
+    barcodeGtin?: string;
+    barcodeOther?: string;
+    type?: 'food' | 'beverage' | 'meal';
+    nutrients: NutritionalInformation;
+    servingSizes: Omit<ServingSize, 'id'>[];
+}
+type UpdateFoodRequest = Partial<CreateFoodRequest>;
+interface ListFoodsParams extends SearchParams {
+    search?: string;
+}
+interface FoodLog {
+    id: UUID;
+    userId: UUID;
+    foodId: UUID;
+    name: string;
+    servingSizeName?: string;
+    quantity: number;
+    unitGrams: number;
+    totalGrams: number;
+    nutrients: Record<string, number>;
+    mealType?: MealType;
+    loggedAt: DateTime;
+    notes?: string;
+    createdAt: DateTime;
+    foodName?: string;
+    foodBrand?: string;
+}
+interface CreateFoodLogRequest {
+    foodId: UUID;
+    name: string;
+    servingSizeName?: string;
+    quantity: number;
+    unitGrams: number;
+    mealType?: MealType;
+    loggedAt?: DateTime;
+    notes?: string;
+}
+type UpdateFoodLogRequest = Partial<CreateFoodLogRequest>;
+interface ListFoodLogsParams extends ListParams, DateRangeParams {
+    date?: DateString;
+    mealType?: MealType;
+}
+interface DailyNutritionSummary {
+    date: DateString;
+    mealType?: MealType;
+    totalCalories: number;
+    totalProtein: number;
+    totalCarbs: number;
+    totalFat: number;
+    itemCount: number;
+    nutrients?: Record<string, number>;
+}
+interface GetDailySummaryParams {
+    date?: DateString;
+    mealType?: MealType;
+}
+interface QuickEntryFoodLogRequest {
+    name: string;
+    calories?: number;
+    protein?: number;
+    carbohydrates?: number;
+    fat?: number;
+    mealType?: MealType;
+    loggedAt?: DateTime;
+}
+
+interface ExerciseCapabilities {
+    supportsWeight: boolean;
+    supportsBodyweightOnly: boolean;
+    supportsAssistance: boolean;
+    supportsDistance: boolean;
+    supportsDuration: boolean;
+    supportsTempo: boolean;
+}
+interface Exercise {
+    id: UUID;
+    name: string;
+    description?: string;
+    category: ExerciseCategory | string;
+    exerciseType?: string;
+    movementPattern?: MovementPattern | string;
+    forceDirection?: ForceDirection | string;
+    primaryMuscles: (MuscleGroup | string)[];
+    secondaryMuscles: (MuscleGroup | string)[];
+    equipment: (Equipment | string)[];
+    capabilities: ExerciseCapabilities;
+    createdBy?: UUID;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+}
+interface CreateExerciseRequest {
+    name: string;
+    description?: string;
+    category: ExerciseCategory | string;
+    exerciseType?: string;
+    movementPattern?: MovementPattern | string;
+    forceDirection?: ForceDirection | string;
+    primaryMuscles: (MuscleGroup | string)[];
+    secondaryMuscles?: (MuscleGroup | string)[];
+    equipment: (Equipment | string)[];
+    capabilities: ExerciseCapabilities;
+}
+type UpdateExerciseRequest = Partial<CreateExerciseRequest>;
+interface ListExercisesParams extends SearchParams {
+    category?: ExerciseCategory | string;
+    muscleGroup?: MuscleGroup | string;
+}
+
+interface SetData {
+    order: number;
+    reps?: number;
+    weight?: number;
+    restSeconds?: number;
+    distance?: number;
+    duration?: number;
+    tempo?: string;
+    rpe?: number;
+    notes?: string;
+    [key: string]: any;
+}
+interface WorkoutExercise {
+    id: UUID;
+    workoutId: UUID;
+    exerciseId: UUID;
+    orderIndex: number;
+    workoutFormat: WorkoutFormat | string;
+    setsData: SetData[];
+    isSuperset: boolean;
+    notes?: string;
+    exerciseName?: string;
+    exerciseDescription?: string;
+}
+interface Workout {
+    id: UUID;
+    name: string;
+    description?: string;
+    type: string;
+    createdBy: UUID;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    exercises?: WorkoutExercise[];
+}
+interface CreateWorkoutRequest {
+    name: string;
+    description?: string;
+    type: string;
+}
+type UpdateWorkoutRequest = Partial<CreateWorkoutRequest>;
+interface AddExercisesToWorkoutRequest {
+    exercises: Array<{
+        exerciseId: UUID;
+        orderIndex: number;
+        workoutFormat: WorkoutFormat | string;
+        setsData: SetData[];
+        isSuperset?: boolean;
+        notes?: string;
+    }>;
+}
+interface UpdateWorkoutExerciseRequest {
+    orderIndex?: number;
+    workoutFormat?: WorkoutFormat | string;
+    setsData?: SetData[];
+    isSuperset?: boolean;
+    notes?: string;
+}
+interface ListWorkoutsParams extends ListParams {
+    search?: string;
+}
+
+interface SessionExerciseDetail {
+    id: UUID;
+    sessionId: UUID;
+    exerciseId: UUID;
+    workoutExerciseId?: UUID;
+    orderPerformed: number;
+    startedAt?: DateTime;
+    completedAt?: DateTime;
+    workoutFormat: string;
+    setsData: SetData[];
+    totalSets: number;
+    completedSets: number;
+    totalVolume?: number;
+    totalDistance?: number;
+    totalDuration?: number;
+    skipped: boolean;
+    notes?: string;
+    formRating?: number;
+    rpe?: number;
+    exerciseName: string;
+    exerciseDescription?: string;
+}
+interface WorkoutSession {
+    id: UUID;
+    userId: UUID;
+    workoutId?: UUID;
+    name?: string;
+    programEnrollmentId?: UUID;
+    scheduledFor?: DateTime;
+    startedAt?: DateTime;
+    completedAt?: DateTime;
+    pausedDuration?: string;
+    status: SessionStatus;
+    userBodyweight?: number;
+    totalVolume?: number;
+    totalDistance?: number;
+    totalDuration?: number;
+    totalSetsCompleted: number;
+    totalExercisesCompleted: number;
+    notes?: string;
+    mood?: string;
+    location?: string;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+    exercises?: SessionExerciseDetail[];
+}
+interface CreateWorkoutSessionRequest {
+    workoutId?: UUID;
+    name?: string;
+    status?: SessionStatus;
+    userBodyweight?: number;
+    scheduledFor?: DateTime;
+    notes?: string;
+    mood?: string;
+    location?: string;
+}
+interface AddExerciseItem {
+    exerciseId: UUID;
+    targetSets: number;
+    notes?: string;
+}
+interface UpdateExerciseItem {
+    id: UUID;
+    targetSets?: number;
+    notes?: string;
+    startedAt?: DateTime;
+    completedAt?: DateTime;
+    skipped?: boolean;
+    skipReason?: string;
+}
+interface UpdateWorkoutSessionRequest {
+    name?: string;
+    status?: SessionStatus;
+    startedAt?: DateTime;
+    completedAt?: DateTime;
+    notes?: string;
+    mood?: string;
+    location?: string;
+    completionPercentage?: number;
+    pausedDuration?: string;
+    userBodyweight?: number;
+    addExercises?: AddExerciseItem[];
+    updateExercises?: UpdateExerciseItem[];
+    removeExercises?: UUID[];
+    reorderExercises?: Record<UUID, number>;
+    updateSets?: Record<UUID, any[]>;
+}
+interface ListWorkoutSessionsParams extends ListParams, DateRangeParams {
+    status?: SessionStatus;
+    workoutId?: UUID;
+    includeExercises?: boolean;
+}
+interface ExerciseHistoryEntry {
+    date: DateString;
+    sessionId: UUID;
+    totalVolume?: number;
+    totalSets: number;
+    completedSets: number;
+    rpe?: number;
+    formRating?: number;
+    notes?: string;
+}
+interface ExerciseHistory {
+    exerciseId: UUID;
+    exerciseName: string;
+    history: ExerciseHistoryEntry[];
+}
+interface PersonalRecord {
+    exerciseId: UUID;
+    exerciseName: string;
+    recordType: RecordType;
+    value: number;
+    unit: string;
+    achievedDate: DateString;
+    sessionId: UUID;
+}
+interface PersonalRecordHistoryEntry {
+    value: number;
+    date: DateString;
+    sessionId: UUID;
+}
+interface PersonalRecordHistory {
+    exerciseId: UUID;
+    exerciseName: string;
+    recordType: RecordType;
+    unit: string;
+    history: PersonalRecordHistoryEntry[];
+}
+
+interface ProgramScheduleExercise {
+    exerciseId: UUID;
+    orderIndex: number;
+    sets: SetData[];
+}
+interface ProgramScheduleDay {
+    week: number;
+    day: number;
+    name: string;
+    exercises: ProgramScheduleExercise[];
+}
+interface ProgramMetadata {
+    difficulty?: string;
+    type?: string;
+    equipment?: string[];
+    duration?: string;
+    [key: string]: any;
+}
+interface Program {
+    id: UUID;
+    name: string;
+    description?: string;
+    createdBy: UUID;
+    isTemplate: boolean;
+    schedule: ProgramScheduleDay[];
+    metadata?: ProgramMetadata;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+}
+interface CreateProgramRequest {
+    name: string;
+    description?: string;
+    schedule: ProgramScheduleDay[];
+    metadata?: ProgramMetadata;
+}
+type UpdateProgramRequest = Partial<CreateProgramRequest>;
+interface EnrollInProgramRequest {
+    startDate: DateString;
+}
+interface ProgramEnrollment {
+    id: UUID;
+    userId: UUID;
+    programId: UUID;
+    startDate: DateString;
+    currentWeek: number;
+    currentDay: number;
+    status: 'active' | 'paused' | 'completed';
+    completedAt?: DateTime;
+    createdAt: DateTime;
+    updatedAt: DateTime;
+}
+interface UpdateEnrollmentRequest {
+    status?: 'active' | 'paused' | 'completed';
+    currentWeek?: number;
+    currentDay?: number;
+}
+interface EnrollmentProgress {
+    enrollmentId: UUID;
+    totalWeeks: number;
+    totalDays: number;
+    completedDays: number;
+    currentWeek: number;
+    currentDay: number;
+    completionPercentage: number;
+}
+interface CurrentWeekSchedule {
+    enrollmentId: UUID;
+    week: number;
+    days: ProgramScheduleDay[];
+}
+
+type MetricAggregationType = 'sum' | 'average' | 'min' | 'max' | 'latest';
+type MetricCategory = 'body_composition' | 'cardiovascular' | 'strength' | 'flexibility' | 'sleep' | 'stress' | 'nutrition' | 'hydration' | 'custom';
+interface Metric {
+    id: UUID;
+    key: string;
+    name: string;
+    description?: string;
+    category: MetricCategory | string;
+    unit: string;
+    aggregationType: MetricAggregationType;
+    createdAt: DateTime;
+}
+interface MetricEvent {
+    id: UUID;
+    userId: UUID;
+    metricId: UUID;
+    metricKey: string;
+    value: number;
+    metadata?: Record<string, any>;
+    loggedAt: DateTime;
+    source?: string;
+    referenceId?: UUID;
+    createdAt: DateTime;
+}
+interface CreateMetricEventRequest {
+    metricKey: string;
+    value: number;
+    metadata?: Record<string, any>;
+    loggedAt?: DateTime;
+    source?: string;
+}
+interface UpdateMetricEventRequest {
+    value?: number;
+    metadata?: Record<string, any>;
+    loggedAt?: DateTime;
+}
+interface BulkCreateMetricEventsRequest {
+    metrics: CreateMetricEventRequest[];
+}
+interface ListMetricEventsParams extends ListParams, DateRangeParams {
+    metricId?: UUID;
+    metricKey?: string;
+}
+interface DailyMetricAggregate {
+    date: DateString;
+    metricKey: string;
+    value: number;
+    count: number;
+    min?: number;
+    max?: number;
+}
+interface GetDailyMetricParams {
+    date?: DateString;
+}
+
+interface UserGoal {
+    id: UUID;
+    userId: UUID;
+    metricId: UUID;
+    targetValue: number;
+    targetType: GoalTargetType;
+    effectiveFrom: DateString;
+    effectiveUntil?: DateString;
+    createdAt: DateTime;
+    metricKey?: string;
+    metricName?: string;
+    unit?: string;
+}
+interface CreateUserGoalRequest {
+    metricKey: string;
+    targetValue: number;
+    targetType: GoalTargetType;
+    effectiveFrom?: DateString;
+    effectiveUntil?: DateString;
+}
+interface UpdateUserGoalRequest {
+    targetValue?: number;
+    targetType?: GoalTargetType;
+    effectiveFrom?: DateString;
+    effectiveUntil?: DateString;
+}
+type GoalProgressStatus = 'on_track' | 'below' | 'above' | 'no_data';
+interface GoalProgress {
+    id: UUID;
+    metricName: string;
+    targetValue: number;
+    targetType: GoalTargetType;
+    currentValue?: number;
+    status: GoalProgressStatus;
+    percentage?: number;
+}
+interface DailyGoalProgress {
+    date: DateString;
+    goals: GoalProgress[];
+}
+interface NutritionGoal {
+    type: NutritionGoalType;
+    value?: number;
+    min?: number;
+    max?: number;
+}
+interface UserNutritionGoals {
+    id: UUID;
+    userId: UUID;
+    effectiveDate: DateString;
+    goals: Record<string, NutritionGoal>;
+    caloriesTarget?: number;
+    proteinTarget?: number;
+    carbohydratesTarget?: number;
+    fatTarget?: number;
+    notes?: string;
+    createdAt: DateTime;
+}
+interface CreateNutritionGoalsRequest {
+    effectiveDate: DateString;
+    goals: Record<string, NutritionGoal>;
+    notes?: string;
+}
+type UpdateNutritionGoalsRequest = Partial<CreateNutritionGoalsRequest>;
+interface BulkCreateNutritionGoalsRequest {
+    goals: Array<{
+        effectiveDate: DateString;
+        goals: Record<string, NutritionGoal>;
+        notes?: string;
+    }>;
+}
+interface CopyNutritionGoalsRequest {
+    fromDate: DateString;
+    toDate: DateString;
+}
+interface NutritionProgress {
+    nutrientKey: string;
+    goal: NutritionGoal;
+    current: number;
+    target?: number;
+    percentage: number;
+    status: GoalProgressStatus;
+    remaining?: number;
+}
+interface DailyNutritionProgress {
+    date: DateString;
+    effectiveGoalDate: DateString;
+    progress: NutritionProgress[];
+    summary: {
+        onTrack: number;
+        below: number;
+        over: number;
+        noData: number;
+    };
+}
+interface ListNutritionGoalsHistoryParams extends ListParams, DateRangeParams {
+}
+
+type InsightType = 'nutrition_pattern' | 'workout_pattern' | 'performance_trend' | 'goal_progress' | 'recommendation';
+type InsightSeverity = 'info' | 'warning' | 'success' | 'error';
+interface Insight {
+    type: InsightType;
+    message: string;
+    severity: InsightSeverity;
+    metric?: string;
+    period?: string;
+    data?: Record<string, any>;
+}
+interface Recommendation {
+    category: string;
+    suggestion: string;
+    rationale?: string;
+    priority?: 'low' | 'medium' | 'high';
+}
+interface FoodInsightsResponse {
+    insights: Insight[];
+    recommendations: Recommendation[];
+}
+interface GetFoodInsightsParams extends DateRangeParams {
+}
+
+interface OpenLifeLogConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    measurementSystem?: MeasurementSystem;
+    autoConvertUnits?: boolean;
+    timeout?: number;
+    maxRetries?: number;
+    enableRetries?: boolean;
+    headers?: Record<string, string>;
+    debug?: boolean;
+    fetch?: typeof fetch;
+}
+type ResolvedConfig = Required<Omit<OpenLifeLogConfig, 'apiKey'>> & {
+    apiKey?: string;
+};
+
+declare class WeightConverter {
+    static kgToLbs(kg: number): number;
+    static lbsToKg(lbs: number): number;
+    static fromMetric(kg: number, targetSystem: MeasurementSystem): number;
+    static toMetric(value: number, sourceSystem: MeasurementSystem): number;
+}
+declare class DistanceConverter {
+    static metersToMiles(meters: number): number;
+    static milesToMeters(miles: number): number;
+    static metersToFeet(meters: number): number;
+    static feetToMeters(feet: number): number;
+    static fromMetric(meters: number, targetSystem: MeasurementSystem, preferMiles?: boolean): number;
+    static toMetric(value: number, sourceSystem: MeasurementSystem, isMiles?: boolean): number;
+}
+declare class HeightConverter {
+    static cmToInches(cm: number): number;
+    static inchesToCm(inches: number): number;
+    static cmToFeetInches(cm: number): {
+        feet: number;
+        inches: number;
+    };
+    static feetInchesToCm(feet: number, inches: number): number;
+    static fromMetric(cm: number, targetSystem: MeasurementSystem): number;
+    static toMetric(value: number, sourceSystem: MeasurementSystem): number;
+}
+declare class UnitConverter {
+    private measurementSystem;
+    constructor(measurementSystem?: MeasurementSystem);
+    setMeasurementSystem(system: MeasurementSystem): void;
+    getMeasurementSystem(): MeasurementSystem;
+    weightFromMetric(kg: number | null | undefined): number | null;
+    weightToMetric(value: number | null | undefined): number | null;
+    distanceFromMetric(meters: number | null | undefined, preferMiles?: boolean): number | null;
+    distanceToMetric(value: number | null | undefined, isMiles?: boolean): number | null;
+    heightFromMetric(cm: number | null | undefined): number | null;
+    heightToMetric(value: number | null | undefined): number | null;
+    static round(value: number, decimals?: number): number;
+    getWeightUnit(): string;
+    getDistanceUnit(preferMiles?: boolean): string;
+    getHeightUnit(): string;
+}
+declare function createUnitConverter(measurementSystem?: MeasurementSystem): UnitConverter;
+
+interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    headers?: Record<string, string>;
+    body?: any;
+    params?: Record<string, any>;
+    timeout?: number;
+    skipRetry?: boolean;
+}
+interface HttpResponse<T = any> {
+    data: T;
+    status: number;
+    headers: Headers;
+}
+declare class HttpClient {
+    private config;
+    private baseUrl;
+    constructor(config: ResolvedConfig);
+    setApiKey(apiKey: string): void;
+    getApiKey(): string | undefined;
+    private toSnakeCase;
+    private buildUrl;
+    private buildHeaders;
+    private executeWithTimeout;
+    private sleep;
+    private isRetryableError;
+    private getRetryDelay;
+    request<T = any>(path: string, options?: RequestOptions): Promise<HttpResponse<T>>;
+    get<T = any>(path: string, params?: Record<string, any>, options?: Omit<RequestOptions, 'method' | 'body' | 'params'>): Promise<HttpResponse<T>>;
+    post<T = any>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): Promise<HttpResponse<T>>;
+    put<T = any>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): Promise<HttpResponse<T>>;
+    patch<T = any>(path: string, body?: any, options?: Omit<RequestOptions, 'method' | 'body'>): Promise<HttpResponse<T>>;
+    delete<T = any>(path: string, options?: Omit<RequestOptions, 'method' | 'body'>): Promise<HttpResponse<T>>;
+}
+
+declare class AuthResource {
+    private http;
+    constructor(http: HttpClient);
+    signup(request: SignupRequest): Promise<AuthResponse>;
+    login(request: LoginRequest): Promise<AuthResponse>;
+    requestPasswordReset(request: PasswordResetRequest): Promise<void>;
+    confirmPasswordReset(request: PasswordResetConfirm): Promise<void>;
+    logout(): void;
+}
+
+declare class PaginatedIterator<T> {
+    private fetchPage;
+    private currentPage;
+    private currentIndex;
+    private nextCursor?;
+    private hasMore;
+    private isFirstFetch;
+    constructor(fetchPage: (cursor?: string) => Promise<ListResponse<T>>);
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    toArray(): Promise<T[]>;
+}
+declare function createPaginatedIterator<T>(fetchPage: (cursor?: string) => Promise<ListResponse<T>>): PaginatedIterator<T>;
+declare function fetchAllPages<T>(fetchPage: (cursor?: string) => Promise<ListResponse<T>>, maxPages?: number): Promise<T[]>;
+declare function hasMorePages(pageInfo: PageInfo): boolean;
+
+declare class UsersResource {
+    private http;
+    constructor(http: HttpClient);
+    me(): Promise<User>;
+    update(request: UpdateUserRequest): Promise<User>;
+    getPreferences(): Promise<UserPreferences>;
+    updatePreferences(request: UpdatePreferencesRequest): Promise<UserPreferences>;
+    list(params?: ListParams): Promise<ListResponse<User>>;
+    search(params: {
+        q: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<ListResponse<User>>;
+    listAutoPaginate(params?: ListParams): PaginatedIterator<User>;
+    get(userId: string): Promise<User>;
+}
+
+declare class FoodsResource {
+    private http;
+    constructor(http: HttpClient);
+    list(params?: ListFoodsParams): Promise<ListResponse<Food>>;
+    listAutoPaginate(params?: ListFoodsParams): PaginatedIterator<Food>;
+    count(): Promise<CountResponse>;
+    search(params: {
+        q: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<ListResponse<Food>>;
+    get(foodId: string): Promise<Food>;
+    create(request: CreateFoodRequest): Promise<Food>;
+    update(foodId: string, request: UpdateFoodRequest): Promise<Food>;
+    delete(foodId: string): Promise<void>;
+    getFavorites(params?: ListFoodsParams): Promise<ListResponse<Food>>;
+    addToFavorites(foodId: string): Promise<void>;
+    removeFromFavorites(foodId: string): Promise<void>;
+}
+
+declare class FoodLogsResource {
+    private http;
+    constructor(http: HttpClient);
+    list(params?: ListFoodLogsParams): Promise<FoodLog[]>;
+    getDailySummary(params?: GetDailySummaryParams): Promise<DailyNutritionSummary>;
+    get(logId: string): Promise<FoodLog>;
+    create(request: CreateFoodLogRequest): Promise<FoodLog>;
+    quickEntry(request: QuickEntryFoodLogRequest): Promise<FoodLog>;
+    update(logId: string, request: UpdateFoodLogRequest): Promise<FoodLog>;
+    delete(logId: string): Promise<void>;
+}
+
+declare class ExercisesResource {
+    private http;
+    constructor(http: HttpClient);
+    list(params?: ListExercisesParams): Promise<ListResponse<Exercise>>;
+    listAutoPaginate(params?: ListExercisesParams): PaginatedIterator<Exercise>;
+    count(): Promise<CountResponse>;
+    search(params: {
+        q: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<ListResponse<Exercise>>;
+    get(exerciseId: string): Promise<Exercise>;
+    create(request: CreateExerciseRequest): Promise<Exercise>;
+    update(exerciseId: string, request: UpdateExerciseRequest): Promise<Exercise>;
+    delete(exerciseId: string): Promise<void>;
+    getFavorites(params?: ListExercisesParams): Promise<ListResponse<Exercise>>;
+    addToFavorites(exerciseId: string): Promise<void>;
+    removeFromFavorites(exerciseId: string): Promise<void>;
+}
+
+declare class WorkoutsResource {
+    private http;
+    constructor(http: HttpClient);
+    list(params?: ListWorkoutsParams): Promise<ListResponse<Workout>>;
+    listAutoPaginate(params?: ListWorkoutsParams): PaginatedIterator<Workout>;
+    count(): Promise<CountResponse>;
+    search(params: {
+        q: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<ListResponse<Workout>>;
+    get(workoutId: string): Promise<Workout>;
+    create(request: CreateWorkoutRequest): Promise<Workout>;
+    update(workoutId: string, request: UpdateWorkoutRequest): Promise<Workout>;
+    clone(workoutId: string): Promise<Workout>;
+    delete(workoutId: string): Promise<void>;
+    addExercises(workoutId: string, request: AddExercisesToWorkoutRequest): Promise<void>;
+    updateExercise(workoutId: string, exerciseId: string, request: UpdateWorkoutExerciseRequest): Promise<void>;
+    removeExercise(workoutId: string, exerciseId: string): Promise<void>;
+    getWorkoutsByExercise(exerciseId: string): Promise<ListResponse<Workout>>;
+    getFavorites(params?: ListWorkoutsParams): Promise<ListResponse<Workout>>;
+    addToFavorites(workoutId: string): Promise<void>;
+    removeFromFavorites(workoutId: string): Promise<void>;
+}
+
+declare class SessionsResource {
+    private http;
+    constructor(http: HttpClient);
+    list(params?: ListWorkoutSessionsParams): Promise<ListResponse<WorkoutSession>>;
+    listAutoPaginate(params?: ListWorkoutSessionsParams): PaginatedIterator<WorkoutSession>;
+    create(request: CreateWorkoutSessionRequest): Promise<WorkoutSession>;
+    start(request: Omit<CreateWorkoutSessionRequest, 'status'>): Promise<WorkoutSession>;
+    get(sessionId: string): Promise<WorkoutSession>;
+    update(sessionId: string, request: UpdateWorkoutSessionRequest): Promise<WorkoutSession>;
+    complete(sessionId: string, notes?: string): Promise<WorkoutSession>;
+    addExercises(sessionId: string, exercises: AddExerciseItem[]): Promise<WorkoutSession>;
+    delete(sessionId: string): Promise<void>;
+    getSessionsByWorkout(workoutId: string, params?: ListWorkoutSessionsParams): Promise<ListResponse<WorkoutSession>>;
+    getExerciseHistory(exerciseId: string): Promise<ExerciseHistory>;
+    getPersonalRecords(): Promise<ListResponse<PersonalRecord>>;
+    getExercisePersonalRecords(exerciseId: string): Promise<ListResponse<PersonalRecord>>;
+    getPersonalRecordHistory(exerciseId: string): Promise<ListResponse<PersonalRecordHistory>>;
+}
+
+declare class ProgramsResource {
+    private http;
+    constructor(http: HttpClient);
+    list(params?: ListParams): Promise<ListResponse<Program>>;
+    listTemplates(params?: ListParams): Promise<ListResponse<Program>>;
+    create(request: CreateProgramRequest): Promise<Program>;
+    get(programId: string): Promise<Program>;
+    update(programId: string, request: UpdateProgramRequest): Promise<Program>;
+    delete(programId: string): Promise<void>;
+    enroll(programId: string, request: EnrollInProgramRequest): Promise<ProgramEnrollment>;
+    listEnrollments(params?: ListParams): Promise<ListResponse<ProgramEnrollment>>;
+    getEnrollment(enrollmentId: string): Promise<ProgramEnrollment>;
+    updateEnrollment(enrollmentId: string, request: UpdateEnrollmentRequest): Promise<ProgramEnrollment>;
+    unenroll(enrollmentId: string): Promise<void>;
+    getEnrollmentProgress(enrollmentId: string): Promise<EnrollmentProgress>;
+    getCurrentWeek(enrollmentId: string): Promise<CurrentWeekSchedule>;
+}
+
+declare class MetricsResource {
+    private http;
+    constructor(http: HttpClient);
+    list(): Promise<ListResponse<Metric>>;
+    get(metricId: string): Promise<Metric>;
+    getByCategory(category: string): Promise<ListResponse<Metric>>;
+    getDailyMetric(metricKey: string, params?: GetDailyMetricParams): Promise<DailyMetricAggregate>;
+    listEvents(params?: ListMetricEventsParams): Promise<ListResponse<MetricEvent>>;
+    listEventsAutoPaginate(params?: ListMetricEventsParams): PaginatedIterator<MetricEvent>;
+    getEvent(eventId: string): Promise<MetricEvent>;
+    log(request: CreateMetricEventRequest): Promise<MetricEvent>;
+    createEvent(request: CreateMetricEventRequest): Promise<MetricEvent>;
+    bulkCreateEvents(request: BulkCreateMetricEventsRequest): Promise<void>;
+    updateEvent(eventId: string, request: UpdateMetricEventRequest): Promise<MetricEvent>;
+    deleteEvent(eventId: string): Promise<void>;
+}
+
+declare class GoalsResource {
+    private http;
+    constructor(http: HttpClient);
+    list(): Promise<ListResponse<UserGoal>>;
+    getByDate(date: string): Promise<ListResponse<UserGoal>>;
+    create(request: CreateUserGoalRequest): Promise<UserGoal>;
+    update(goalId: string, request: UpdateUserGoalRequest): Promise<UserGoal>;
+    delete(goalId: string): Promise<void>;
+    getProgress(): Promise<DailyGoalProgress>;
+    getProgressByDate(date: string): Promise<DailyGoalProgress>;
+    getNutritionGoals(): Promise<UserNutritionGoals>;
+    getNutritionGoalsByDate(date: string): Promise<UserNutritionGoals>;
+    createNutritionGoals(request: CreateNutritionGoalsRequest): Promise<UserNutritionGoals>;
+    updateNutritionGoals(date: string, request: UpdateNutritionGoalsRequest): Promise<UserNutritionGoals>;
+    deleteNutritionGoals(date: string): Promise<void>;
+    bulkCreateNutritionGoals(request: BulkCreateNutritionGoalsRequest): Promise<void>;
+    copyNutritionGoals(request: CopyNutritionGoalsRequest): Promise<void>;
+    getNutritionGoalsHistory(params?: ListNutritionGoalsHistoryParams): Promise<ListResponse<UserNutritionGoals>>;
+    getNutritionProgress(): Promise<DailyNutritionProgress>;
+    getNutritionProgressByDate(date: string): Promise<DailyNutritionProgress>;
+}
+
+declare class AIResource {
+    private http;
+    constructor(http: HttpClient);
+    getFoodInsights(params?: GetFoodInsightsParams): Promise<FoodInsightsResponse>;
+}
+
+declare class OpenLifeLog {
+    private config;
+    private httpClient;
+    private unitConverter;
+    readonly auth: AuthResource;
+    readonly users: UsersResource;
+    readonly foods: FoodsResource;
+    readonly foodLogs: FoodLogsResource;
+    readonly exercises: ExercisesResource;
+    readonly workouts: WorkoutsResource;
+    readonly sessions: SessionsResource;
+    readonly programs: ProgramsResource;
+    readonly metrics: MetricsResource;
+    readonly goals: GoalsResource;
+    readonly ai: AIResource;
+    constructor(config?: OpenLifeLogConfig);
+    setApiKey(apiKey: string): void;
+    getApiKey(): string | undefined;
+    getUnitConverter(): UnitConverter;
+    setMeasurementSystem(system: 'metric' | 'imperial'): void;
+    getMeasurementSystem(): 'metric' | 'imperial';
+    logFood(request: CreateFoodLogRequest): Promise<FoodLog>;
+    getTodayNutrition(): Promise<DailyNutritionSummary>;
+    getTodayProgress(): Promise<DailyGoalProgress>;
+    getTodayNutritionProgress(): Promise<DailyNutritionProgress>;
+    isAuthenticated(): boolean;
+}
+
+interface MetricDefinition {
+    key: string;
+    displayName: string;
+    category: 'body' | 'activity' | 'sleep' | 'vital' | 'wellness';
+    unit: string;
+    aggregation: 'last' | 'sum' | 'avg' | 'min' | 'max';
+    imperialUnit?: string;
+    imperialConversion?: number;
+}
+declare const BODY_METRICS: MetricDefinition[];
+declare const ACTIVITY_METRICS: MetricDefinition[];
+declare const SLEEP_METRICS: MetricDefinition[];
+declare const VITAL_METRICS: MetricDefinition[];
+declare const WELLNESS_METRICS: MetricDefinition[];
+declare const ALL_METRICS: MetricDefinition[];
+declare function getMetricDefinition(key: string): MetricDefinition | undefined;
+declare function getMetricsByCategory(category: MetricDefinition['category']): MetricDefinition[];
+
+declare class OpenLifeLogError extends Error {
+    readonly statusCode?: number;
+    readonly code?: string;
+    readonly rawError?: any;
+    constructor(message: string, statusCode?: number, code?: string, rawError?: any);
+}
+declare class AuthenticationError extends OpenLifeLogError {
+    constructor(message?: string, rawError?: any);
+}
+declare class AuthorizationError extends OpenLifeLogError {
+    constructor(message?: string, rawError?: any);
+}
+declare class NotFoundError extends OpenLifeLogError {
+    constructor(message?: string, rawError?: any);
+}
+declare class ValidationError extends OpenLifeLogError {
+    readonly validationErrors?: Record<string, string[]>;
+    constructor(message?: string, validationErrors?: Record<string, string[]>, rawError?: any);
+}
+declare class RateLimitError extends OpenLifeLogError {
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: number, rawError?: any);
+}
+declare class ServerError extends OpenLifeLogError {
+    constructor(message?: string, rawError?: any);
+}
+declare class NetworkError extends OpenLifeLogError {
+    constructor(message?: string, rawError?: any);
+}
+declare class TimeoutError extends OpenLifeLogError {
+    constructor(message?: string, rawError?: any);
+}
+declare class UnitConversionError extends OpenLifeLogError {
+    constructor(message?: string, rawError?: any);
+}
+
+export { ACTIVITY_METRICS, ALL_METRICS, type AddExerciseItem, type AddExercisesToWorkoutRequest, type AuthResponse, AuthenticationError, AuthorizationError, BODY_METRICS, type BulkCreateMetricEventsRequest, type BulkCreateNutritionGoalsRequest, type CopyNutritionGoalsRequest, type CountResponse, type CreateExerciseRequest, type CreateFoodLogRequest, type CreateFoodRequest, type CreateMetricEventRequest, type CreateNutritionGoalsRequest, type CreateProgramRequest, type CreateUserGoalRequest, type CreateWorkoutRequest, type CreateWorkoutSessionRequest, type CurrentWeekSchedule, type DailyGoalProgress, type DailyMetricAggregate, type DailyNutritionProgress, type DailyNutritionSummary, type DateRangeParams, type DateString, type DateTime, DistanceConverter, type EnrollInProgramRequest, type EnrollmentProgress, type Equipment, type ErrorResponse, type Exercise, type ExerciseCapabilities, type ExerciseCategory, type ExerciseHistory, type ExerciseHistoryEntry, type Food, type FoodInsightsResponse, type FoodLog, type ForceDirection, type GetDailyMetricParams, type GetDailySummaryParams, type GetFoodInsightsParams, type GoalProgress, type GoalProgressStatus, type GoalTargetType, HeightConverter, type Insight, type InsightSeverity, type InsightType, type ListExercisesParams, type ListFoodLogsParams, type ListFoodsParams, type ListMetricEventsParams, type ListNutritionGoalsHistoryParams, type ListParams, type ListResponse, type ListWorkoutSessionsParams, type ListWorkoutsParams, type LoginRequest, type MealType, type MeasurementSystem, type Metric, type MetricAggregationType, type MetricCategory, type MetricDefinition, type MetricEvent, type MovementPattern, type MuscleGroup, NetworkError, NotFoundError, type NutritionGoal, type NutritionGoalType, type NutritionProgress, type NutritionalInformation, OpenLifeLog, type OpenLifeLogConfig, OpenLifeLogError, type PageInfo, PaginatedIterator, type PasswordResetConfirm, type PasswordResetRequest, type PersonalRecord, type PersonalRecordHistory, type PersonalRecordHistoryEntry, type Program, type ProgramEnrollment, type ProgramMetadata, type ProgramScheduleDay, type ProgramScheduleExercise, type QuickEntryFoodLogRequest, RateLimitError, type Recommendation, type RecordType, SLEEP_METRICS, type SearchParams, ServerError, type ServingSize, type SessionExerciseDetail, type SessionStatus, type SetData, type SignupRequest, type SuccessResponse, TimeoutError, type UUID, UnitConversionError, UnitConverter, type UpdateEnrollmentRequest, type UpdateExerciseItem, type UpdateExerciseRequest, type UpdateFoodLogRequest, type UpdateFoodRequest, type UpdateMetricEventRequest, type UpdateNutritionGoalsRequest, type UpdatePreferencesRequest, type UpdateProgramRequest, type UpdateUserGoalRequest, type UpdateUserRequest, type UpdateWorkoutExerciseRequest, type UpdateWorkoutRequest, type UpdateWorkoutSessionRequest, type User, type UserGoal, type UserNutritionGoals, type UserPreferences, VITAL_METRICS, ValidationError, WELLNESS_METRICS, WeightConverter, type Workout, type WorkoutExercise, type WorkoutFormat, type WorkoutSession, createPaginatedIterator, createUnitConverter, OpenLifeLog as default, fetchAllPages, getMetricDefinition, getMetricsByCategory, hasMorePages };