@openlifelog/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,2023 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  ACTIVITY_METRICS: () => ACTIVITY_METRICS,
+  ALL_METRICS: () => ALL_METRICS,
+  AuthenticationError: () => AuthenticationError,
+  AuthorizationError: () => AuthorizationError,
+  BODY_METRICS: () => BODY_METRICS,
+  DistanceConverter: () => DistanceConverter,
+  HeightConverter: () => HeightConverter,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  OpenLifeLog: () => OpenLifeLog,
+  OpenLifeLogError: () => OpenLifeLogError,
+  PaginatedIterator: () => PaginatedIterator,
+  RateLimitError: () => RateLimitError,
+  SLEEP_METRICS: () => SLEEP_METRICS,
+  ServerError: () => ServerError,
+  TimeoutError: () => TimeoutError,
+  UnitConversionError: () => UnitConversionError,
+  UnitConverter: () => UnitConverter,
+  VITAL_METRICS: () => VITAL_METRICS,
+  ValidationError: () => ValidationError,
+  WELLNESS_METRICS: () => WELLNESS_METRICS,
+  WeightConverter: () => WeightConverter,
+  createPaginatedIterator: () => createPaginatedIterator,
+  createUnitConverter: () => createUnitConverter,
+  default: () => OpenLifeLog,
+  fetchAllPages: () => fetchAllPages,
+  getMetricDefinition: () => getMetricDefinition,
+  getMetricsByCategory: () => getMetricsByCategory,
+  hasMorePages: () => hasMorePages
+});
+module.exports = __toCommonJS(index_exports);
+
+// config.ts
+var DEFAULT_CONFIG = {
+  baseUrl: "https://api.openlifelog.com",
+  measurementSystem: "metric",
+  autoConvertUnits: true,
+  timeout: 3e4,
+  maxRetries: 3,
+  enableRetries: true,
+  debug: false
+};
+function mergeConfig(userConfig) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...userConfig,
+    apiKey: userConfig.apiKey,
+    headers: userConfig.headers || {},
+    // Bind fetch to globalThis to preserve context
+    fetch: userConfig.fetch || globalThis.fetch.bind(globalThis)
+  };
+}
+
+// utils/errors.ts
+var OpenLifeLogError = class extends Error {
+  constructor(message, statusCode, code, rawError) {
+    super(message);
+    this.name = "OpenLifeLogError";
+    this.statusCode = statusCode;
+    this.code = code;
+    this.rawError = rawError;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var AuthenticationError = class extends OpenLifeLogError {
+  constructor(message = "Authentication failed. Please check your credentials.", rawError) {
+    super(message, 401, "AUTHENTICATION_ERROR", rawError);
+    this.name = "AuthenticationError";
+  }
+};
+var AuthorizationError = class extends OpenLifeLogError {
+  constructor(message = "You do not have permission to access this resource.", rawError) {
+    super(message, 403, "AUTHORIZATION_ERROR", rawError);
+    this.name = "AuthorizationError";
+  }
+};
+var NotFoundError = class extends OpenLifeLogError {
+  constructor(message = "The requested resource was not found.", rawError) {
+    super(message, 404, "NOT_FOUND", rawError);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends OpenLifeLogError {
+  constructor(message = "Validation failed.", validationErrors, rawError) {
+    super(message, 400, "VALIDATION_ERROR", rawError);
+    this.name = "ValidationError";
+    this.validationErrors = validationErrors;
+  }
+};
+var RateLimitError = class extends OpenLifeLogError {
+  constructor(message = "Rate limit exceeded. Please try again later.", retryAfter, rawError) {
+    super(message, 429, "RATE_LIMIT_ERROR", rawError);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ServerError = class extends OpenLifeLogError {
+  constructor(message = "An internal server error occurred.", rawError) {
+    super(message, 500, "SERVER_ERROR", rawError);
+    this.name = "ServerError";
+  }
+};
+var NetworkError = class extends OpenLifeLogError {
+  constructor(message = "A network error occurred. Please check your connection.", rawError) {
+    super(message, void 0, "NETWORK_ERROR", rawError);
+    this.name = "NetworkError";
+  }
+};
+var TimeoutError = class extends OpenLifeLogError {
+  constructor(message = "The request timed out.", rawError) {
+    super(message, 408, "TIMEOUT_ERROR", rawError);
+    this.name = "TimeoutError";
+  }
+};
+var UnitConversionError = class extends OpenLifeLogError {
+  constructor(message = "Failed to convert units.", rawError) {
+    super(message, void 0, "UNIT_CONVERSION_ERROR", rawError);
+    this.name = "UnitConversionError";
+  }
+};
+function parseErrorResponse(error, statusCode) {
+  const message = error?.message || error?.error || "An unknown error occurred";
+  const rawError = error;
+  if (statusCode === 401) {
+    return new AuthenticationError(message, rawError);
+  }
+  if (statusCode === 403) {
+    return new AuthorizationError(message, rawError);
+  }
+  if (statusCode === 404) {
+    return new NotFoundError(message, rawError);
+  }
+  if (statusCode === 400) {
+    return new ValidationError(message, error?.validationErrors, rawError);
+  }
+  if (statusCode === 429) {
+    return new RateLimitError(message, error?.retryAfter, rawError);
+  }
+  if (statusCode && statusCode >= 500) {
+    return new ServerError(message, rawError);
+  }
+  return new OpenLifeLogError(message, statusCode, error?.code, rawError);
+}
+
+// utils/http.ts
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+  }
+  /**
+   * Update the API key (token)
+   */
+  setApiKey(apiKey) {
+    this.config.apiKey = apiKey;
+  }
+  /**
+   * Get the current API key
+   */
+  getApiKey() {
+    return this.config.apiKey;
+  }
+  /**
+   * Convert camelCase to snake_case
+   */
+  toSnakeCase(str) {
+    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+  }
+  /**
+   * Build full URL with query parameters
+   */
+  buildUrl(path, params) {
+    const url = new URL(path.startsWith("/") ? `${this.baseUrl}${path}` : `${this.baseUrl}/${path}`);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          const snakeKey = this.toSnakeCase(key);
+          if (Array.isArray(value)) {
+            value.forEach((v) => url.searchParams.append(snakeKey, String(v)));
+          } else {
+            url.searchParams.append(snakeKey, String(value));
+          }
+        }
+      });
+    }
+    return url.toString();
+  }
+  /**
+   * Build request headers
+   */
+  buildHeaders(customHeaders) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.headers,
+      ...customHeaders
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    return headers;
+  }
+  /**
+   * Execute request with timeout support
+   */
+  async executeWithTimeout(url, init, timeout) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await this.config.fetch(url, {
+        ...init,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${timeout}ms`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Sleep for exponential backoff
+   */
+  async sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Determine if error is retryable
+   */
+  isRetryableError(error, statusCode) {
+    if (error instanceof NetworkError || error instanceof TimeoutError) {
+      return true;
+    }
+    if (statusCode && statusCode >= 500 && statusCode < 600) {
+      return true;
+    }
+    if (statusCode === 429) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Calculate exponential backoff delay
+   */
+  getRetryDelay(attempt) {
+    const baseDelay = Math.pow(2, attempt) * 1e3;
+    const jitter = Math.random() * 1e3;
+    return baseDelay + jitter;
+  }
+  /**
+   * Make HTTP request with automatic retries
+   */
+  async request(path, options = {}) {
+    const {
+      method = "GET",
+      headers: customHeaders,
+      body,
+      params,
+      timeout = this.config.timeout,
+      skipRetry = false
+    } = options;
+    const url = this.buildUrl(path, params);
+    const headers = this.buildHeaders(customHeaders);
+    const requestInit = {
+      method,
+      headers
+    };
+    if (body && (method === "POST" || method === "PUT" || method === "PATCH")) {
+      requestInit.body = JSON.stringify(body);
+    }
+    const maxAttempts = skipRetry || !this.config.enableRetries ? 1 : this.config.maxRetries + 1;
+    let lastError;
+    if (this.config.debug) {
+      console.log(`[OpenLifeLog SDK] ${method} ${url}`, body ? { body } : "");
+    }
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        if (attempt > 0) {
+          const delay = this.getRetryDelay(attempt - 1);
+          if (this.config.debug) {
+            console.log(`[OpenLifeLog SDK] Retry attempt ${attempt}/${maxAttempts - 1}, waiting ${delay}ms`);
+          }
+          await this.sleep(delay);
+        }
+        const response = await this.executeWithTimeout(url, requestInit, timeout);
+        if (!response.ok) {
+          let errorData;
+          try {
+            errorData = await response.json();
+          } catch {
+            errorData = { error: response.statusText };
+          }
+          const error = parseErrorResponse(errorData, response.status);
+          if (this.isRetryableError(error, response.status) && attempt < maxAttempts - 1) {
+            lastError = error;
+            continue;
+          }
+          throw error;
+        }
+        let data;
+        const contentType = response.headers.get("content-type");
+        if (contentType?.includes("application/json")) {
+          data = await response.json();
+        } else {
+          data = await response.text();
+        }
+        if (this.config.debug) {
+          console.log(`[OpenLifeLog SDK] Response ${response.status}`, data);
+        }
+        return {
+          data,
+          status: response.status,
+          headers: response.headers
+        };
+      } catch (error) {
+        if (error.name === "TypeError" && error.message.includes("fetch")) {
+          lastError = new NetworkError(error.message, error);
+        } else if (error instanceof TimeoutError) {
+          lastError = error;
+        } else if (error.name === "AbortError") {
+          lastError = new TimeoutError("Request was aborted", error);
+        } else {
+          lastError = error;
+        }
+        if (this.isRetryableError(lastError) && attempt < maxAttempts - 1) {
+          continue;
+        }
+        throw lastError;
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * GET request
+   */
+  async get(path, params, options) {
+    return this.request(path, { ...options, method: "GET", params });
+  }
+  /**
+   * POST request
+   */
+  async post(path, body, options) {
+    return this.request(path, { ...options, method: "POST", body });
+  }
+  /**
+   * PUT request
+   */
+  async put(path, body, options) {
+    return this.request(path, { ...options, method: "PUT", body });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(path, body, options) {
+    return this.request(path, { ...options, method: "PATCH", body });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(path, options) {
+    return this.request(path, { ...options, method: "DELETE" });
+  }
+};
+
+// utils/units.ts
+var KG_TO_LBS = 2.20462;
+var LBS_TO_KG = 1 / KG_TO_LBS;
+var METERS_TO_MILES = 621371e-9;
+var MILES_TO_METERS = 1 / METERS_TO_MILES;
+var METERS_TO_FEET = 3.28084;
+var FEET_TO_METERS = 1 / METERS_TO_FEET;
+var CM_TO_INCHES = 0.393701;
+var INCHES_TO_CM = 1 / CM_TO_INCHES;
+var WeightConverter = class {
+  /**
+   * Convert kilograms to pounds
+   */
+  static kgToLbs(kg) {
+    return kg * KG_TO_LBS;
+  }
+  /**
+   * Convert pounds to kilograms
+   */
+  static lbsToKg(lbs) {
+    return lbs * LBS_TO_KG;
+  }
+  /**
+   * Convert weight from metric to the target measurement system
+   */
+  static fromMetric(kg, targetSystem) {
+    if (targetSystem === "imperial") {
+      return this.kgToLbs(kg);
+    }
+    return kg;
+  }
+  /**
+   * Convert weight to metric from the source measurement system
+   */
+  static toMetric(value, sourceSystem) {
+    if (sourceSystem === "imperial") {
+      return this.lbsToKg(value);
+    }
+    return value;
+  }
+};
+var DistanceConverter = class {
+  /**
+   * Convert meters to miles
+   */
+  static metersToMiles(meters) {
+    return meters * METERS_TO_MILES;
+  }
+  /**
+   * Convert miles to meters
+   */
+  static milesToMeters(miles) {
+    return miles * MILES_TO_METERS;
+  }
+  /**
+   * Convert meters to feet
+   */
+  static metersToFeet(meters) {
+    return meters * METERS_TO_FEET;
+  }
+  /**
+   * Convert feet to meters
+   */
+  static feetToMeters(feet) {
+    return feet * FEET_TO_METERS;
+  }
+  /**
+   * Convert distance from metric to the target measurement system
+   * For larger distances (> 1000m), converts to miles, otherwise to feet
+   */
+  static fromMetric(meters, targetSystem, preferMiles = false) {
+    if (targetSystem === "imperial") {
+      if (preferMiles || meters >= 1e3) {
+        return this.metersToMiles(meters);
+      }
+      return this.metersToFeet(meters);
+    }
+    return meters;
+  }
+  /**
+   * Convert distance to metric from the source measurement system
+   */
+  static toMetric(value, sourceSystem, isMiles = false) {
+    if (sourceSystem === "imperial") {
+      return isMiles ? this.milesToMeters(value) : this.feetToMeters(value);
+    }
+    return value;
+  }
+};
+var HeightConverter = class {
+  /**
+   * Convert centimeters to inches
+   */
+  static cmToInches(cm) {
+    return cm * CM_TO_INCHES;
+  }
+  /**
+   * Convert inches to centimeters
+   */
+  static inchesToCm(inches) {
+    return inches * INCHES_TO_CM;
+  }
+  /**
+   * Convert centimeters to feet and inches
+   */
+  static cmToFeetInches(cm) {
+    const totalInches = this.cmToInches(cm);
+    const feet = Math.floor(totalInches / 12);
+    const inches = Math.round(totalInches % 12);
+    return { feet, inches };
+  }
+  /**
+   * Convert feet and inches to centimeters
+   */
+  static feetInchesToCm(feet, inches) {
+    const totalInches = feet * 12 + inches;
+    return this.inchesToCm(totalInches);
+  }
+  /**
+   * Convert height from metric to the target measurement system
+   */
+  static fromMetric(cm, targetSystem) {
+    if (targetSystem === "imperial") {
+      return this.cmToInches(cm);
+    }
+    return cm;
+  }
+  /**
+   * Convert height to metric from the source measurement system
+   */
+  static toMetric(value, sourceSystem) {
+    if (sourceSystem === "imperial") {
+      return this.inchesToCm(value);
+    }
+    return value;
+  }
+};
+var UnitConverter = class {
+  constructor(measurementSystem = "metric") {
+    this.measurementSystem = measurementSystem;
+  }
+  /**
+   * Update the measurement system
+   */
+  setMeasurementSystem(system) {
+    this.measurementSystem = system;
+  }
+  /**
+   * Get the current measurement system
+   */
+  getMeasurementSystem() {
+    return this.measurementSystem;
+  }
+  /**
+   * Convert weight from metric (API storage format) to user preference
+   */
+  weightFromMetric(kg) {
+    if (kg === null || kg === void 0) return null;
+    return WeightConverter.fromMetric(kg, this.measurementSystem);
+  }
+  /**
+   * Convert weight to metric (API storage format) from user preference
+   */
+  weightToMetric(value) {
+    if (value === null || value === void 0) return null;
+    return WeightConverter.toMetric(value, this.measurementSystem);
+  }
+  /**
+   * Convert distance from metric to user preference
+   */
+  distanceFromMetric(meters, preferMiles = false) {
+    if (meters === null || meters === void 0) return null;
+    return DistanceConverter.fromMetric(meters, this.measurementSystem, preferMiles);
+  }
+  /**
+   * Convert distance to metric from user preference
+   */
+  distanceToMetric(value, isMiles = false) {
+    if (value === null || value === void 0) return null;
+    return DistanceConverter.toMetric(value, this.measurementSystem, isMiles);
+  }
+  /**
+   * Convert height from metric to user preference
+   */
+  heightFromMetric(cm) {
+    if (cm === null || cm === void 0) return null;
+    return HeightConverter.fromMetric(cm, this.measurementSystem);
+  }
+  /**
+   * Convert height to metric from user preference
+   */
+  heightToMetric(value) {
+    if (value === null || value === void 0) return null;
+    return HeightConverter.toMetric(value, this.measurementSystem);
+  }
+  /**
+   * Round number to specified decimal places
+   */
+  static round(value, decimals = 2) {
+    return Math.round(value * Math.pow(10, decimals)) / Math.pow(10, decimals);
+  }
+  /**
+   * Get the appropriate unit label for weight
+   */
+  getWeightUnit() {
+    return this.measurementSystem === "imperial" ? "lbs" : "kg";
+  }
+  /**
+   * Get the appropriate unit label for distance
+   */
+  getDistanceUnit(preferMiles = false) {
+    if (this.measurementSystem === "imperial") {
+      return preferMiles ? "mi" : "ft";
+    }
+    return "m";
+  }
+  /**
+   * Get the appropriate unit label for height
+   */
+  getHeightUnit() {
+    return this.measurementSystem === "imperial" ? "in" : "cm";
+  }
+};
+function createUnitConverter(measurementSystem = "metric") {
+  return new UnitConverter(measurementSystem);
+}
+
+// resources/auth.ts
+var AuthResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Sign up a new user
+   *
+   * @example
+   * ```typescript
+   * const { token, user } = await client.auth.signup({
+   *   name: 'John Doe',
+   *   email: 'john@example.com',
+   *   password: 'securePassword123'
+   * });
+   * ```
+   */
+  async signup(request) {
+    const response = await this.http.post("/v1/auth/signup", request);
+    this.http.setApiKey(response.data.token);
+    return response.data;
+  }
+  /**
+   * Log in an existing user
+   *
+   * @example
+   * ```typescript
+   * const { token, user } = await client.auth.login({
+   *   email: 'john@example.com',
+   *   password: 'securePassword123'
+   * });
+   * ```
+   */
+  async login(request) {
+    const response = await this.http.post("/v1/auth/login", request);
+    this.http.setApiKey(response.data.token);
+    return response.data;
+  }
+  /**
+   * Request a password reset
+   *
+   * @example
+   * ```typescript
+   * await client.auth.requestPasswordReset({
+   *   email: 'john@example.com'
+   * });
+   * ```
+   */
+  async requestPasswordReset(request) {
+    await this.http.post("/v1/auth/password-reset/request", request);
+  }
+  /**
+   * Confirm password reset with token
+   *
+   * @example
+   * ```typescript
+   * await client.auth.confirmPasswordReset({
+   *   token: 'reset-token-from-email',
+   *   newPassword: 'newSecurePassword123'
+   * });
+   * ```
+   */
+  async confirmPasswordReset(request) {
+    await this.http.post("/v1/auth/password-reset/confirm", request);
+  }
+  /**
+   * Log out the current user (clears the API key)
+   *
+   * @example
+   * ```typescript
+   * client.auth.logout();
+   * ```
+   */
+  logout() {
+    this.http.setApiKey("");
+  }
+};
+
+// utils/pagination.ts
+var PaginatedIterator = class {
+  constructor(fetchPage) {
+    this.currentPage = [];
+    this.currentIndex = 0;
+    this.hasMore = true;
+    this.isFirstFetch = true;
+    this.fetchPage = fetchPage;
+  }
+  /**
+   * Async iterator implementation
+   */
+  async *[Symbol.asyncIterator]() {
+    while (this.hasMore || this.currentIndex < this.currentPage.length) {
+      if (this.currentIndex >= this.currentPage.length) {
+        if (!this.hasMore) {
+          break;
+        }
+        const response = await this.fetchPage(this.isFirstFetch ? void 0 : this.nextCursor);
+        this.isFirstFetch = false;
+        this.currentPage = response.data;
+        this.currentIndex = 0;
+        this.nextCursor = response.pageInfo.nextCursor;
+        this.hasMore = response.pageInfo.hasMore;
+        if (this.currentPage.length === 0) {
+          break;
+        }
+      }
+      yield this.currentPage[this.currentIndex++];
+    }
+  }
+  /**
+   * Get all items from all pages (be careful with large datasets!)
+   */
+  async toArray() {
+    const items = [];
+    for await (const item of this) {
+      items.push(item);
+    }
+    return items;
+  }
+};
+function createPaginatedIterator(fetchPage) {
+  return new PaginatedIterator(fetchPage);
+}
+async function fetchAllPages(fetchPage, maxPages) {
+  const allItems = [];
+  let cursor;
+  let hasMore = true;
+  let pageCount = 0;
+  while (hasMore && (!maxPages || pageCount < maxPages)) {
+    const response = await fetchPage(cursor);
+    allItems.push(...response.data);
+    cursor = response.pageInfo.nextCursor;
+    hasMore = response.pageInfo.hasMore;
+    pageCount++;
+    if (!hasMore || !cursor) {
+      break;
+    }
+  }
+  return allItems;
+}
+function hasMorePages(pageInfo) {
+  return pageInfo.hasMore && !!pageInfo.nextCursor;
+}
+
+// resources/users.ts
+var UsersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get current authenticated user
+   *
+   * @example
+   * ```typescript
+   * const user = await client.users.me();
+   * console.log(user.name, user.email);
+   * ```
+   */
+  async me() {
+    const response = await this.http.get("/v1/users/me");
+    return response.data;
+  }
+  /**
+   * Update current user profile
+   *
+   * @example
+   * ```typescript
+   * const user = await client.users.update({
+   *   name: 'Updated Name',
+   *   isOnboarded: true
+   * });
+   * ```
+   */
+  async update(request) {
+    const response = await this.http.patch("/v1/users/me", request);
+    return response.data;
+  }
+  /**
+   * Get user preferences
+   *
+   * @example
+   * ```typescript
+   * const prefs = await client.users.getPreferences();
+   * console.log(prefs.measurementSystem); // 'metric' or 'imperial'
+   * ```
+   */
+  async getPreferences() {
+    const response = await this.http.get("/v1/users/me/preferences");
+    return response.data;
+  }
+  /**
+   * Update user preferences
+   *
+   * @example
+   * ```typescript
+   * const prefs = await client.users.updatePreferences({
+   *   measurementSystem: 'imperial'
+   * });
+   * ```
+   */
+  async updatePreferences(request) {
+    const response = await this.http.patch("/v1/users/me/preferences", request);
+    return response.data;
+  }
+  /**
+   * List all users (for admin/public lists)
+   *
+   * @example
+   * ```typescript
+   * const { data, pageInfo } = await client.users.list({ limit: 20 });
+   * ```
+   */
+  async list(params) {
+    const response = await this.http.get("/v1/users", params);
+    return response.data;
+  }
+  /**
+   * Search for users by name or email
+   *
+   * @example
+   * ```typescript
+   * const { data, pageInfo } = await client.users.search({ q: 'john' });
+   * ```
+   */
+  async search(params) {
+    const response = await this.http.get("/v1/users/search", params);
+    return response.data;
+  }
+  /**
+   * List all users with automatic pagination
+   *
+   * @example
+   * ```typescript
+   * for await (const user of client.users.listAutoPaginate({ limit: 100 })) {
+   *   console.log(user.name);
+   * }
+   * ```
+   */
+  listAutoPaginate(params) {
+    return createPaginatedIterator(
+      (cursor) => this.list({ ...params, cursor })
+    );
+  }
+  /**
+   * Get specific user by ID
+   *
+   * @example
+   * ```typescript
+   * const user = await client.users.get('user-id');
+   * ```
+   */
+  async get(userId) {
+    const response = await this.http.get(`/v1/users/${userId}`);
+    return response.data;
+  }
+};
+
+// resources/foods.ts
+var FoodsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List foods with pagination and search
+   *
+   * @example
+   * ```typescript
+   * const { data, pageInfo } = await client.foods.list({
+   *   limit: 20,
+   *   search: 'chicken'
+   * });
+   * ```
+   */
+  async list(params) {
+    const response = await this.http.get("/v1/foods", params);
+    return response.data;
+  }
+  /**
+   * List foods with automatic pagination
+   *
+   * @example
+   * ```typescript
+   * for await (const food of client.foods.listAutoPaginate({ limit: 100 })) {
+   *   console.log(food.name);
+   * }
+   * ```
+   */
+  listAutoPaginate(params) {
+    return createPaginatedIterator(
+      (cursor) => this.list({ ...params, cursor })
+    );
+  }
+  /**
+   * Get total count of foods
+   *
+   * @example
+   * ```typescript
+   * const { count } = await client.foods.count();
+   * console.log(`Database has ${count} foods`);
+   * ```
+   */
+  async count() {
+    const response = await this.http.get("/v1/foods/count");
+    return response.data;
+  }
+  /**
+   * Search foods by name or brand
+   *
+   * @example
+   * ```typescript
+   * const { data } = await client.foods.search({
+   *   q: 'chicken breast',
+   *   limit: 10
+   * });
+   * ```
+   */
+  async search(params) {
+    const response = await this.http.get("/v1/foods/search", params);
+    return response.data;
+  }
+  /**
+   * Get specific food by ID
+   *
+   * @example
+   * ```typescript
+   * const food = await client.foods.get('food-id');
+   * console.log(food.nutrients);
+   * ```
+   */
+  async get(foodId) {
+    const response = await this.http.get(`/v1/foods/${foodId}`);
+    return response.data;
+  }
+  /**
+   * Create a new food item
+   *
+   * @example
+   * ```typescript
+   * const food = await client.foods.create({
+   *   name: 'Custom Protein Shake',
+   *   type: 'beverage',
+   *   nutrients: {
+   *     calories: 300,
+   *     protein: 40,
+   *     carbohydrates: 20,
+   *     fat: 5
+   *   },
+   *   servingSizes: [{
+   *     name: '1 serving',
+   *     grams: 300,
+   *     isDefault: true
+   *   }]
+   * });
+   * ```
+   */
+  async create(request) {
+    const response = await this.http.post("/v1/foods", request);
+    return response.data;
+  }
+  /**
+   * Update an existing food item
+   *
+   * @example
+   * ```typescript
+   * const food = await client.foods.update('food-id', {
+   *   description: 'Updated description'
+   * });
+   * ```
+   */
+  async update(foodId, request) {
+    const response = await this.http.put(`/v1/foods/${foodId}`, request);
+    return response.data;
+  }
+  /**
+   * Delete a food item
+   *
+   * @example
+   * ```typescript
+   * await client.foods.delete('food-id');
+   * ```
+   */
+  async delete(foodId) {
+    await this.http.delete(`/v1/foods/${foodId}`);
+  }
+  /**
+   * Get favorite foods
+   *
+   * @example
+   * ```typescript
+   * const { data } = await client.foods.getFavorites();
+   * ```
+   */
+  async getFavorites(params) {
+    const response = await this.http.get("/v1/foods/favorites", params);
+    return response.data;
+  }
+  /**
+   * Add food to favorites
+   *
+   * @example
+   * ```typescript
+   * await client.foods.addToFavorites('food-id');
+   * ```
+   */
+  async addToFavorites(foodId) {
+    await this.http.post(`/v1/foods/${foodId}/favorite`);
+  }
+  /**
+   * Remove food from favorites
+   *
+   * @example
+   * ```typescript
+   * await client.foods.removeFromFavorites('food-id');
+   * ```
+   */
+  async removeFromFavorites(foodId) {
+    await this.http.delete(`/v1/foods/${foodId}/favorite`);
+  }
+};
+
+// resources/food-logs.ts
+var FoodLogsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List food log entries with filtering
+   *
+   * @example
+   * ```typescript
+   * const logs = await client.foodLogs.list({
+   *   date: '2024-01-15',
+   *   mealType: 'lunch'
+   * });
+   * ```
+   */
+  async list(params) {
+    const response = await this.http.get("/v1/food-logs", params);
+    return response.data;
+  }
+  /**
+   * Get daily nutrition summary
+   *
+   * @example
+   * ```typescript
+   * const summary = await client.foodLogs.getDailySummary({
+   *   date: '2024-01-15'
+   * });
+   * console.log(`Total calories: ${summary.totalCalories}`);
+   * ```
+   */
+  async getDailySummary(params) {
+    const response = await this.http.get("/v1/food-logs/summary", params);
+    return response.data;
+  }
+  /**
+   * Get specific food log entry
+   *
+   * @example
+   * ```typescript
+   * const log = await client.foodLogs.get('log-id');
+   * ```
+   */
+  async get(logId) {
+    const response = await this.http.get(`/v1/food-logs/${logId}`);
+    return response.data;
+  }
+  /**
+   * Create a food log entry
+   *
+   * @example
+   * ```typescript
+   * const log = await client.foodLogs.create({
+   *   foodId: 'food-uuid',
+   *   name: 'Chicken Breast',
+   *   servingSizeName: 'breast (200g)',
+   *   quantity: 1.5,
+   *   unitGrams: 200,
+   *   mealType: 'lunch',
+   *   notes: 'Grilled with olive oil'
+   * });
+   * ```
+   */
+  async create(request) {
+    const response = await this.http.post("/v1/food-logs", request);
+    return response.data;
+  }
+  /**
+   * Quick entry food log with just name and nutrients
+   * Creates a food log entry without creating a food (one-off entry)
+   *
+   * @example
+   * ```typescript
+   * const log = await client.foodLogs.quickEntry({
+   *   name: 'Homemade Salad',
+   *   protein: 15,
+   *   carbohydrates: 20,
+   *   fat: 10,
+   *   mealType: 'lunch'
+   * });
+   * ```
+   */
+  async quickEntry(request) {
+    const response = await this.http.post("/v1/food-logs-quick-entry", request);
+    return response.data;
+  }
+  /**
+   * Update a food log entry
+   *
+   * @example
+   * ```typescript
+   * const log = await client.foodLogs.update('log-id', {
+   *   quantity: 2,
+   *   notes: 'Updated portion size'
+   * });
+   * ```
+   */
+  async update(logId, request) {
+    const response = await this.http.put(`/v1/food-logs/${logId}`, request);
+    return response.data;
+  }
+  /**
+   * Delete a food log entry
+   *
+   * @example
+   * ```typescript
+   * await client.foodLogs.delete('log-id');
+   * ```
+   */
+  async delete(logId) {
+    await this.http.delete(`/v1/food-logs/${logId}`);
+  }
+};
+
+// resources/exercises.ts
+var ExercisesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List exercises with filtering
+   *
+   * @example
+   * ```typescript
+   * const { data } = await client.exercises.list({
+   *   category: 'strength',
+   *   muscleGroup: 'chest'
+   * });
+   * ```
+   */
+  async list(params) {
+    const response = await this.http.get("/v1/exercises", params);
+    return response.data;
+  }
+  /**
+   * List exercises with automatic pagination
+   */
+  listAutoPaginate(params) {
+    return createPaginatedIterator(
+      (cursor) => this.list({ ...params, cursor })
+    );
+  }
+  /**
+   * Get total count of exercises
+   */
+  async count() {
+    const response = await this.http.get("/v1/exercises/count");
+    return response.data;
+  }
+  /**
+   * Search exercises by name
+   */
+  async search(params) {
+    const response = await this.http.get("/v1/exercises/search", params);
+    return response.data;
+  }
+  /**
+   * Get specific exercise by ID
+   */
+  async get(exerciseId) {
+    const response = await this.http.get(`/v1/exercises/${exerciseId}`);
+    return response.data;
+  }
+  /**
+   * Create a new exercise
+   */
+  async create(request) {
+    const response = await this.http.post("/v1/exercises", request);
+    return response.data;
+  }
+  /**
+   * Update an existing exercise
+   */
+  async update(exerciseId, request) {
+    const response = await this.http.put(`/v1/exercises/${exerciseId}`, request);
+    return response.data;
+  }
+  /**
+   * Delete an exercise
+   */
+  async delete(exerciseId) {
+    await this.http.delete(`/v1/exercises/${exerciseId}`);
+  }
+  /**
+   * Get favorite exercises
+   */
+  async getFavorites(params) {
+    const response = await this.http.get("/v1/exercises/favorites", params);
+    return response.data;
+  }
+  /**
+   * Add exercise to favorites
+   */
+  async addToFavorites(exerciseId) {
+    await this.http.post(`/v1/exercises/${exerciseId}/favorite`);
+  }
+  /**
+   * Remove exercise from favorites
+   */
+  async removeFromFavorites(exerciseId) {
+    await this.http.delete(`/v1/exercises/${exerciseId}/favorite`);
+  }
+};
+
+// resources/workouts.ts
+var WorkoutsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List workout templates
+   */
+  async list(params) {
+    const response = await this.http.get("/v1/workouts", params);
+    return response.data;
+  }
+  /**
+   * List workouts with automatic pagination
+   */
+  listAutoPaginate(params) {
+    return createPaginatedIterator(
+      (cursor) => this.list({ ...params, cursor })
+    );
+  }
+  /**
+   * Get total count of workouts
+   */
+  async count() {
+    const response = await this.http.get("/v1/workouts/count");
+    return response.data;
+  }
+  /**
+   * Search workouts by name
+   */
+  async search(params) {
+    const response = await this.http.get("/v1/workouts/search", params);
+    return response.data;
+  }
+  /**
+   * Get specific workout with all exercises
+   */
+  async get(workoutId) {
+    const response = await this.http.get(`/v1/workouts/${workoutId}`);
+    return response.data;
+  }
+  /**
+   * Create a new workout template
+   */
+  async create(request) {
+    const response = await this.http.post("/v1/workouts", request);
+    return response.data;
+  }
+  /**
+   * Update a workout template
+   */
+  async update(workoutId, request) {
+    const response = await this.http.put(`/v1/workouts/${workoutId}`, request);
+    return response.data;
+  }
+  /**
+   * Clone an existing workout
+   */
+  async clone(workoutId) {
+    const response = await this.http.post(`/v1/workouts/${workoutId}/clone`);
+    return response.data;
+  }
+  /**
+   * Delete a workout template
+   */
+  async delete(workoutId) {
+    await this.http.delete(`/v1/workouts/${workoutId}`);
+  }
+  /**
+   * Add exercises to workout
+   */
+  async addExercises(workoutId, request) {
+    await this.http.post(`/v1/workouts/${workoutId}/exercises`, request);
+  }
+  /**
+   * Update exercise in workout
+   */
+  async updateExercise(workoutId, exerciseId, request) {
+    await this.http.put(`/v1/workouts/${workoutId}/exercises/${exerciseId}`, request);
+  }
+  /**
+   * Remove exercise from workout
+   */
+  async removeExercise(workoutId, exerciseId) {
+    await this.http.delete(`/v1/workouts/${workoutId}/exercises/${exerciseId}`);
+  }
+  /**
+   * Get all workouts containing a specific exercise
+   */
+  async getWorkoutsByExercise(exerciseId) {
+    const response = await this.http.get(`/v1/exercises/${exerciseId}/workouts`);
+    return response.data;
+  }
+  /**
+   * Get favorite workouts
+   */
+  async getFavorites(params) {
+    const response = await this.http.get("/v1/workouts/favorites", params);
+    return response.data;
+  }
+  /**
+   * Add workout to favorites
+   */
+  async addToFavorites(workoutId) {
+    await this.http.post(`/v1/workouts/${workoutId}/favorite`);
+  }
+  /**
+   * Remove workout from favorites
+   */
+  async removeFromFavorites(workoutId) {
+    await this.http.delete(`/v1/workouts/${workoutId}/favorite`);
+  }
+};
+
+// resources/sessions.ts
+var SessionsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List workout sessions with filtering
+   */
+  async list(params) {
+    const response = await this.http.get("/v1/workout-sessions", params);
+    return response.data;
+  }
+  /**
+   * List sessions with automatic pagination
+   */
+  listAutoPaginate(params) {
+    return createPaginatedIterator(
+      (cursor) => this.list({ ...params, cursor })
+    );
+  }
+  /**
+   * Create a new workout session
+   */
+  async create(request) {
+    const response = await this.http.post("/v1/workout-sessions", request);
+    return response.data;
+  }
+  /**
+   * Start a workout session (convenience method)
+   */
+  async start(request) {
+    return this.create({ ...request, status: "in_progress" });
+  }
+  /**
+   * Get specific session with all exercise data
+   */
+  async get(sessionId) {
+    const response = await this.http.get(`/v1/workout-sessions/${sessionId}`);
+    return response.data;
+  }
+  /**
+   * Update a workout session
+   */
+  async update(sessionId, request) {
+    const response = await this.http.patch(`/v1/workout-sessions/${sessionId}`, request);
+    return response.data;
+  }
+  /**
+   * Complete a workout session (convenience method)
+   */
+  async complete(sessionId, notes) {
+    return this.update(sessionId, {
+      status: "completed",
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...notes && { notes }
+    });
+  }
+  /**
+   * Add exercises to a session (convenience method)
+   *
+   * @example
+   * ```typescript
+   * await client.sessions.addExercises('session-123', [
+   *   { exerciseId: 'ex-1', targetSets: 3 },
+   *   { exerciseId: 'ex-2', targetSets: 4, notes: 'Focus on form' }
+   * ]);
+   * ```
+   */
+  async addExercises(sessionId, exercises) {
+    return this.update(sessionId, { addExercises: exercises });
+  }
+  /**
+   * Delete a workout session
+   */
+  async delete(sessionId) {
+    await this.http.delete(`/v1/workout-sessions/${sessionId}`);
+  }
+  /**
+   * Get all sessions for a specific workout
+   */
+  async getSessionsByWorkout(workoutId, params) {
+    const response = await this.http.get(`/v1/workouts/${workoutId}/sessions`, params);
+    return response.data;
+  }
+  /**
+   * Get exercise performance history across sessions
+   */
+  async getExerciseHistory(exerciseId) {
+    const response = await this.http.get(`/v1/exercises/${exerciseId}/history`);
+    return response.data;
+  }
+  /**
+   * Get user's personal records
+   */
+  async getPersonalRecords() {
+    const response = await this.http.get("/v1/personal-records");
+    return response.data;
+  }
+  /**
+   * Get personal records for a specific exercise
+   */
+  async getExercisePersonalRecords(exerciseId) {
+    const response = await this.http.get(`/v1/exercises/${exerciseId}/personal-records`);
+    return response.data;
+  }
+  /**
+   * Get personal record progression history for an exercise
+   */
+  async getPersonalRecordHistory(exerciseId) {
+    const response = await this.http.get(`/v1/exercises/${exerciseId}/personal-records/history`);
+    return response.data;
+  }
+};
+
+// resources/programs.ts
+var ProgramsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List user's programs and enrollments
+   */
+  async list(params) {
+    const response = await this.http.get("/v1/programs", params);
+    return response.data;
+  }
+  /**
+   * List available program templates
+   */
+  async listTemplates(params) {
+    const response = await this.http.get("/v1/programs/templates", params);
+    return response.data;
+  }
+  /**
+   * Create a new program
+   */
+  async create(request) {
+    const response = await this.http.post("/v1/programs", request);
+    return response.data;
+  }
+  /**
+   * Get specific program details
+   */
+  async get(programId) {
+    const response = await this.http.get(`/v1/programs/${programId}`);
+    return response.data;
+  }
+  /**
+   * Update a program
+   */
+  async update(programId, request) {
+    const response = await this.http.put(`/v1/programs/${programId}`, request);
+    return response.data;
+  }
+  /**
+   * Delete a program
+   */
+  async delete(programId) {
+    await this.http.delete(`/v1/programs/${programId}`);
+  }
+  /**
+   * Enroll in a program
+   */
+  async enroll(programId, request) {
+    const response = await this.http.post(`/v1/programs/${programId}/enroll`, request);
+    return response.data;
+  }
+  /**
+   * List program enrollments
+   */
+  async listEnrollments(params) {
+    const response = await this.http.get("/v1/enrollments", params);
+    return response.data;
+  }
+  /**
+   * Get enrollment details
+   */
+  async getEnrollment(enrollmentId) {
+    const response = await this.http.get(`/v1/enrollments/${enrollmentId}`);
+    return response.data;
+  }
+  /**
+   * Update enrollment (pause, resume, etc.)
+   */
+  async updateEnrollment(enrollmentId, request) {
+    const response = await this.http.put(`/v1/enrollments/${enrollmentId}`, request);
+    return response.data;
+  }
+  /**
+   * Unenroll from a program
+   */
+  async unenroll(enrollmentId) {
+    await this.http.delete(`/v1/enrollments/${enrollmentId}`);
+  }
+  /**
+   * Get enrollment progress
+   */
+  async getEnrollmentProgress(enrollmentId) {
+    const response = await this.http.get(`/v1/enrollments/${enrollmentId}/progress`);
+    return response.data;
+  }
+  /**
+   * Get current week schedule for enrollment
+   */
+  async getCurrentWeek(enrollmentId) {
+    const response = await this.http.get(`/v1/enrollments/${enrollmentId}/current-week`);
+    return response.data;
+  }
+};
+
+// resources/metrics.ts
+var MetricsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List available metrics
+   */
+  async list() {
+    const response = await this.http.get("/v1/metrics");
+    return response.data;
+  }
+  /**
+   * Get specific metric details
+   */
+  async get(metricId) {
+    const response = await this.http.get(`/v1/metrics/${metricId}`);
+    return response.data;
+  }
+  /**
+   * Get metrics by category
+   */
+  async getByCategory(category) {
+    const response = await this.http.get(`/v1/metrics/category/${category}`);
+    return response.data;
+  }
+  /**
+   * Get daily aggregated metric value
+   */
+  async getDailyMetric(metricKey, params) {
+    const response = await this.http.get(`/v1/metrics/daily/${metricKey}`, params);
+    return response.data;
+  }
+  /**
+   * List metric events (data points)
+   */
+  async listEvents(params) {
+    const response = await this.http.get("/v1/metric-events", params);
+    return response.data;
+  }
+  /**
+   * List metric events with automatic pagination
+   */
+  listEventsAutoPaginate(params) {
+    return createPaginatedIterator(
+      (cursor) => this.listEvents({ ...params, cursor })
+    );
+  }
+  /**
+   * Get specific metric event
+   */
+  async getEvent(eventId) {
+    const response = await this.http.get(`/v1/metric-events/${eventId}`);
+    return response.data;
+  }
+  /**
+   * Log a metric value (convenience method)
+   */
+  async log(request) {
+    const response = await this.http.post("/v1/metric-events", request);
+    return response.data;
+  }
+  /**
+   * Create a metric event
+   */
+  async createEvent(request) {
+    return this.log(request);
+  }
+  /**
+   * Bulk create metric events
+   */
+  async bulkCreateEvents(request) {
+    await this.http.post("/v1/metric-events/bulk", request);
+  }
+  /**
+   * Update a metric event
+   */
+  async updateEvent(eventId, request) {
+    const response = await this.http.put(`/v1/metric-events/${eventId}`, request);
+    return response.data;
+  }
+  /**
+   * Delete a metric event
+   */
+  async deleteEvent(eventId) {
+    await this.http.delete(`/v1/metric-events/${eventId}`);
+  }
+};
+
+// resources/goals.ts
+var GoalsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get active user goals
+   */
+  async list() {
+    const response = await this.http.get("/v1/goals");
+    return response.data;
+  }
+  /**
+   * Get goals effective on a specific date
+   */
+  async getByDate(date) {
+    const response = await this.http.get(`/v1/goals/date/${date}`);
+    return response.data;
+  }
+  /**
+   * Create a new goal
+   */
+  async create(request) {
+    const response = await this.http.post("/v1/goals", request);
+    return response.data;
+  }
+  /**
+   * Update a goal
+   */
+  async update(goalId, request) {
+    const response = await this.http.put(`/v1/goals/${goalId}`, request);
+    return response.data;
+  }
+  /**
+   * Delete a goal
+   */
+  async delete(goalId) {
+    await this.http.delete(`/v1/goals/${goalId}`);
+  }
+  /**
+   * Get today's goal progress
+   */
+  async getProgress() {
+    const response = await this.http.get("/v1/goals/progress");
+    return response.data;
+  }
+  /**
+   * Get goal progress for a specific date
+   */
+  async getProgressByDate(date) {
+    const response = await this.http.get(`/v1/goals/progress/${date}`);
+    return response.data;
+  }
+  /**
+   * Get current nutrition goals
+   */
+  async getNutritionGoals() {
+    const response = await this.http.get("/v1/nutrition/goals");
+    return response.data;
+  }
+  /**
+   * Get nutrition goals for a specific date
+   */
+  async getNutritionGoalsByDate(date) {
+    const response = await this.http.get(`/v1/nutrition/goals/date/${date}`);
+    return response.data;
+  }
+  /**
+   * Create nutrition goals
+   */
+  async createNutritionGoals(request) {
+    const response = await this.http.post("/v1/nutrition/goals", request);
+    return response.data;
+  }
+  /**
+   * Update nutrition goals for a specific date
+   */
+  async updateNutritionGoals(date, request) {
+    const response = await this.http.put(`/v1/nutrition/goals/date/${date}`, request);
+    return response.data;
+  }
+  /**
+   * Delete nutrition goals for a specific date
+   */
+  async deleteNutritionGoals(date) {
+    await this.http.delete(`/v1/nutrition/goals/date/${date}`);
+  }
+  /**
+   * Bulk create nutrition goals for multiple dates
+   */
+  async bulkCreateNutritionGoals(request) {
+    await this.http.post("/v1/nutrition/goals/bulk", request);
+  }
+  /**
+   * Copy nutrition goals from one date to another
+   */
+  async copyNutritionGoals(request) {
+    await this.http.post("/v1/nutrition/goals/copy", request);
+  }
+  /**
+   * Get nutrition goals history
+   */
+  async getNutritionGoalsHistory(params) {
+    const response = await this.http.get("/v1/nutrition/goals/history", params);
+    return response.data;
+  }
+  /**
+   * Get today's nutrition progress toward goals
+   */
+  async getNutritionProgress() {
+    const response = await this.http.get("/v1/nutrition/progress/today");
+    return response.data;
+  }
+  /**
+   * Get nutrition progress for a specific date
+   */
+  async getNutritionProgressByDate(date) {
+    const response = await this.http.get(`/v1/nutrition/progress/date/${date}`);
+    return response.data;
+  }
+};
+
+// resources/ai.ts
+var AIResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get AI-generated nutrition insights
+   *
+   * @example
+   * ```typescript
+   * const insights = await client.ai.getFoodInsights({
+   *   startDate: '2024-01-01',
+   *   endDate: '2024-01-15'
+   * });
+   * ```
+   */
+  async getFoodInsights(params) {
+    const response = await this.http.get("/v1/ai/food-insights", params);
+    return response.data;
+  }
+};
+
+// client.ts
+var OpenLifeLog = class {
+  constructor(config = {}) {
+    this.config = mergeConfig(config);
+    this.httpClient = new HttpClient(this.config);
+    this.unitConverter = createUnitConverter(this.config.measurementSystem);
+    this.auth = new AuthResource(this.httpClient);
+    this.users = new UsersResource(this.httpClient);
+    this.foods = new FoodsResource(this.httpClient);
+    this.foodLogs = new FoodLogsResource(this.httpClient);
+    this.exercises = new ExercisesResource(this.httpClient);
+    this.workouts = new WorkoutsResource(this.httpClient);
+    this.sessions = new SessionsResource(this.httpClient);
+    this.programs = new ProgramsResource(this.httpClient);
+    this.metrics = new MetricsResource(this.httpClient);
+    this.goals = new GoalsResource(this.httpClient);
+    this.ai = new AIResource(this.httpClient);
+  }
+  /**
+   * Update the API key (JWT token)
+   *
+   * @example
+   * ```typescript
+   * client.setApiKey('new-jwt-token');
+   * ```
+   */
+  setApiKey(apiKey) {
+    this.httpClient.setApiKey(apiKey);
+  }
+  /**
+   * Get the current API key
+   */
+  getApiKey() {
+    return this.httpClient.getApiKey();
+  }
+  /**
+   * Get the unit converter instance
+   */
+  getUnitConverter() {
+    return this.unitConverter;
+  }
+  /**
+   * Update the measurement system preference
+   *
+   * @example
+   * ```typescript
+   * client.setMeasurementSystem('imperial');
+   * ```
+   */
+  setMeasurementSystem(system) {
+    this.config.measurementSystem = system;
+    this.unitConverter.setMeasurementSystem(system);
+  }
+  /**
+   * Get the current measurement system
+   */
+  getMeasurementSystem() {
+    return this.config.measurementSystem;
+  }
+  /**
+   * Convenience method: Log food (combines food lookup and logging)
+   *
+   * This is a high-level method that developers love - simple and intuitive.
+   *
+   * @example
+   * ```typescript
+   * const log = await client.logFood({
+   *   foodId: 'food-uuid',
+   *   name: 'Chicken Breast',
+   *   servingSizeName: 'breast (200g)',
+   *   quantity: 1.5,
+   *   mealType: 'lunch',
+   *   notes: 'Grilled with olive oil'
+   * });
+   * ```
+   */
+  async logFood(request) {
+    return this.foodLogs.create(request);
+  }
+  /**
+   * Convenience method: Get today's nutrition summary
+   *
+   * @example
+   * ```typescript
+   * const summary = await client.getTodayNutrition();
+   * console.log(`Calories: ${summary.totalCalories}`);
+   * ```
+   */
+  async getTodayNutrition() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    return this.foodLogs.getDailySummary({ date: today });
+  }
+  /**
+   * Convenience method: Get today's goal progress
+   *
+   * @example
+   * ```typescript
+   * const progress = await client.getTodayProgress();
+   * ```
+   */
+  async getTodayProgress() {
+    return this.goals.getProgress();
+  }
+  /**
+   * Convenience method: Get today's nutrition progress
+   *
+   * @example
+   * ```typescript
+   * const progress = await client.getTodayNutritionProgress();
+   * ```
+   */
+  async getTodayNutritionProgress() {
+    return this.goals.getNutritionProgress();
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return !!this.httpClient.getApiKey();
+  }
+};
+
+// constants/metrics.ts
+var BODY_METRICS = [
+  { key: "height", displayName: "Height", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "weight", displayName: "Body Weight", category: "body", unit: "kg", aggregation: "last", imperialUnit: "lbs", imperialConversion: 2.20462 },
+  { key: "body_fat", displayName: "Body Fat %", category: "body", unit: "%", aggregation: "last" },
+  { key: "muscle_mass", displayName: "Muscle Mass", category: "body", unit: "kg", aggregation: "last", imperialUnit: "lbs", imperialConversion: 2.20462 },
+  { key: "bone_mass", displayName: "Bone Mass", category: "body", unit: "kg", aggregation: "last", imperialUnit: "lbs", imperialConversion: 2.20462 },
+  { key: "body_water", displayName: "Body Water %", category: "body", unit: "%", aggregation: "last" },
+  { key: "bmi", displayName: "BMI", category: "body", unit: "kg/m\xB2", aggregation: "last" },
+  { key: "waist", displayName: "Waist Circumference", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "hip", displayName: "Hip Circumference", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "chest", displayName: "Chest Circumference", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "neck", displayName: "Neck Circumference", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "left_bicep", displayName: "Left Bicep", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "right_bicep", displayName: "Right Bicep", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "left_forearm", displayName: "Left Forearm", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "right_forearm", displayName: "Right Forearm", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "left_thigh", displayName: "Left Thigh", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "right_thigh", displayName: "Right Thigh", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "left_calf", displayName: "Left Calf", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 },
+  { key: "right_calf", displayName: "Right Calf", category: "body", unit: "cm", aggregation: "last", imperialUnit: "in", imperialConversion: 0.393701 }
+];
+var ACTIVITY_METRICS = [
+  { key: "steps", displayName: "Steps", category: "activity", unit: "steps", aggregation: "sum" },
+  { key: "distance", displayName: "Distance", category: "activity", unit: "km", aggregation: "sum", imperialUnit: "mi", imperialConversion: 0.621371 },
+  { key: "active_minutes", displayName: "Active Minutes", category: "activity", unit: "min", aggregation: "sum" },
+  { key: "exercise_minutes", displayName: "Exercise Minutes", category: "activity", unit: "min", aggregation: "sum" },
+  { key: "exercise_calories", displayName: "Exercise Calories", category: "activity", unit: "kcal", aggregation: "sum" },
+  { key: "floors_climbed", displayName: "Floors Climbed", category: "activity", unit: "floors", aggregation: "sum" },
+  { key: "standing_hours", displayName: "Standing Hours", category: "activity", unit: "hours", aggregation: "sum" },
+  { key: "vo2_max", displayName: "VO2 Max", category: "activity", unit: "ml/kg/min", aggregation: "last" }
+];
+var SLEEP_METRICS = [
+  { key: "sleep_duration", displayName: "Sleep Duration", category: "sleep", unit: "hours", aggregation: "last" },
+  { key: "deep_sleep", displayName: "Deep Sleep", category: "sleep", unit: "hours", aggregation: "last" },
+  { key: "rem_sleep", displayName: "REM Sleep", category: "sleep", unit: "hours", aggregation: "last" },
+  { key: "light_sleep", displayName: "Light Sleep", category: "sleep", unit: "hours", aggregation: "last" },
+  { key: "sleep_quality", displayName: "Sleep Quality", category: "sleep", unit: "score", aggregation: "avg" },
+  { key: "sleep_efficiency", displayName: "Sleep Efficiency", category: "sleep", unit: "%", aggregation: "avg" },
+  { key: "time_to_fall_asleep", displayName: "Time to Fall Asleep", category: "sleep", unit: "min", aggregation: "avg" },
+  { key: "times_awakened", displayName: "Times Awakened", category: "sleep", unit: "count", aggregation: "sum" }
+];
+var VITAL_METRICS = [
+  { key: "heart_rate", displayName: "Heart Rate", category: "vital", unit: "bpm", aggregation: "avg" },
+  { key: "resting_heart_rate", displayName: "Resting Heart Rate", category: "vital", unit: "bpm", aggregation: "min" },
+  { key: "heart_rate_variability", displayName: "Heart Rate Variability", category: "vital", unit: "ms", aggregation: "avg" },
+  { key: "blood_pressure_systolic", displayName: "Blood Pressure (Systolic)", category: "vital", unit: "mmHg", aggregation: "last" },
+  { key: "blood_pressure_diastolic", displayName: "Blood Pressure (Diastolic)", category: "vital", unit: "mmHg", aggregation: "last" },
+  { key: "blood_glucose", displayName: "Blood Glucose", category: "vital", unit: "mg/dL", aggregation: "avg" },
+  { key: "blood_oxygen", displayName: "Blood Oxygen", category: "vital", unit: "%", aggregation: "avg" },
+  { key: "respiratory_rate", displayName: "Respiratory Rate", category: "vital", unit: "breaths/min", aggregation: "avg" },
+  { key: "body_temperature", displayName: "Body Temperature", category: "vital", unit: "\xB0C", aggregation: "avg", imperialUnit: "\xB0F", imperialConversion: 1.8 }
+  // Note: Fahrenheit conversion requires adding 32, handle separately
+];
+var WELLNESS_METRICS = [
+  { key: "mood", displayName: "Mood", category: "wellness", unit: "score", aggregation: "avg" },
+  { key: "energy_level", displayName: "Energy Level", category: "wellness", unit: "score", aggregation: "avg" },
+  { key: "stress_level", displayName: "Stress Level", category: "wellness", unit: "score", aggregation: "avg" }
+];
+var ALL_METRICS = [
+  ...BODY_METRICS,
+  ...ACTIVITY_METRICS,
+  ...SLEEP_METRICS,
+  ...VITAL_METRICS,
+  ...WELLNESS_METRICS
+];
+function getMetricDefinition(key) {
+  return ALL_METRICS.find((m) => m.key === key);
+}
+function getMetricsByCategory(category) {
+  return ALL_METRICS.filter((m) => m.category === category);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACTIVITY_METRICS,
+  ALL_METRICS,
+  AuthenticationError,
+  AuthorizationError,
+  BODY_METRICS,
+  DistanceConverter,
+  HeightConverter,
+  NetworkError,
+  NotFoundError,
+  OpenLifeLog,
+  OpenLifeLogError,
+  PaginatedIterator,
+  RateLimitError,
+  SLEEP_METRICS,
+  ServerError,
+  TimeoutError,
+  UnitConversionError,
+  UnitConverter,
+  VITAL_METRICS,
+  ValidationError,
+  WELLNESS_METRICS,
+  WeightConverter,
+  createPaginatedIterator,
+  createUnitConverter,
+  fetchAllPages,
+  getMetricDefinition,
+  getMetricsByCategory,
+  hasMorePages
+});