@torqlab/strava-api 1.0.0

package/dist/index.mjs

@@ -0,0 +1,431 @@
+// constants.ts
+var STRAVA_API_INITIAL_BACKOFF_MS = 1000;
+var STRAVA_API_MAX_BACKOFF_MS = 16000;
+var STRAVA_API_MAX_RETRIES = 3;
+var STRAVA_AUTH_DEFAULT_SCOPE = "activity:read";
+var STRAVA_OAUTH_BASE_URL = "https://www.strava.com/oauth";
+var STRAVA_API_BASE_URL = "https://www.strava.com/api/v3";
+var STRAVA_API_ENDPOINTS = {
+  TOKEN: `${STRAVA_OAUTH_BASE_URL}/token`,
+  AUTH: `${STRAVA_OAUTH_BASE_URL}/authorize`,
+  ACTIVITIES: `${STRAVA_API_BASE_URL}/athlete/activities`,
+  ACTIVITY: `${STRAVA_API_BASE_URL}/activities`
+};
+var STRAVA_API_ERROR_CODES = {
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  RATE_LIMITED: "RATE_LIMITED",
+  SERVER_ERROR: "SERVER_ERROR",
+  MALFORMED_RESPONSE: "MALFORMED_RESPONSE",
+  INVALID_ID: "INVALID_ID",
+  NOT_FOUND: "NOT_FOUND",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  VALIDATION_FAILED: "VALIDATION_FAILED",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  INVALID_CODE: "INVALID_CODE"
+};
+var STRAVA_API_STATUS_CODES = {
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  RATE_LIMITED: 429,
+  SERVER_ERROR: 500
+};
+
+// validators/validate-activity-id/validate-activity-id.ts
+var validateActivityId = (activityId) => {
+  const trimmedActivityId = String(activityId).trim();
+  const numericActivityId = Number(trimmedActivityId);
+  const isValidNumericActivityId = !Number.isNaN(numericActivityId) && Number.isFinite(numericActivityId) && numericActivityId > 0;
+  if (!trimmedActivityId) {
+    const error = {
+      code: "INVALID_ID",
+      message: "Activity ID is required and cannot be empty",
+      retryable: false
+    };
+    throw new Error(JSON.stringify(error));
+  } else if (!isValidNumericActivityId) {
+    const error = {
+      code: "INVALID_ID",
+      message: "Activity ID must be a valid positive number",
+      retryable: false
+    };
+    throw new Error(JSON.stringify(error));
+  }
+};
+var validate_activity_id_default = validateActivityId;
+// client/get-auth-headers/get-auth-headers.ts
+var getAuthHeaders = (config) => {
+  const headers = {
+    Authorization: `Bearer ${config.accessToken}`
+  };
+  return headers;
+};
+var get_auth_headers_default = getAuthHeaders;
+// client/create-error/create-error.ts
+var createError = (code, message, retryable = false, response) => {
+  if (response) {
+    const error = {
+      code,
+      message,
+      retryable
+    };
+    return new Error(JSON.stringify({ ...error, response }));
+  } else {
+    const error = {
+      code,
+      message,
+      retryable
+    };
+    return new Error(JSON.stringify(error));
+  }
+};
+var create_error_default = createError;
+// client/handle-rate-limit/constants.ts
+var DEFAULT_WAIT_MS = 60 * 1000;
+var WINDOW_MS = 15 * 60 * 1000;
+
+// client/handle-rate-limit/handle-rate-limit.ts
+var handleRateLimit = async (response) => {
+  const retryAfterHeader = response.headers.get("Retry-After");
+  const retryAfterSeconds = retryAfterHeader ? Number.parseFloat(retryAfterHeader) : NaN;
+  const shouldWaitAndRetry = !Number.isNaN(retryAfterSeconds) && Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0;
+  if (shouldWaitAndRetry) {
+    const waitMs = Math.ceil(retryAfterSeconds * 1000);
+    await new Promise((resolve) => {
+      setTimeout(resolve, waitMs);
+    });
+  } else {
+    const rateLimitLimit = response.headers.get("X-RateLimit-Limit");
+    const rateLimitUsage = response.headers.get("X-RateLimit-Usage");
+    const limit = rateLimitLimit ? Number.parseInt(rateLimitLimit, 10) : NaN;
+    const usage = rateLimitUsage ? Number.parseInt(rateLimitUsage, 10) : NaN;
+    const shouldWaitInWindow = !Number.isNaN(limit) && !Number.isNaN(usage) && Number.isFinite(limit) && Number.isFinite(usage) && usage >= limit;
+    if (shouldWaitInWindow) {
+      await new Promise((resolve) => {
+        setTimeout(resolve, WINDOW_MS);
+      });
+    } else {
+      await new Promise((resolve) => {
+        setTimeout(resolve, DEFAULT_WAIT_MS);
+      });
+    }
+  }
+};
+var handle_rate_limit_default = handleRateLimit;
+// client/parse-error/parse-error.ts
+var parseError = (error) => {
+  try {
+    return JSON.parse(error.message);
+  } catch {
+    return null;
+  }
+};
+var parse_error_default = parseError;
+
+// client/parse-error-code/parse-error-code.ts
+var parseErrorCode = (error) => {
+  try {
+    const errorParsed = parse_error_default(error);
+    return errorParsed?.code || null;
+  } catch {
+    return null;
+  }
+};
+var parse_error_code_default = parseErrorCode;
+// refresh-token/refresh-token.ts
+var createError2 = (code, message) => {
+  const error = {
+    retryable: false,
+    code,
+    message
+  };
+  return new Error(JSON.stringify(error));
+};
+var doRefreshToken = async (body) => {
+  try {
+    return await fetch(STRAVA_API_ENDPOINTS.TOKEN, {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+  } catch {
+    throw createError2("NETWORK_ERROR", "Failed to connect to Strava OAuth endpoint");
+  }
+};
+var parseApiResponse = async (response) => {
+  try {
+    return await response.json();
+  } catch {
+    throw createError2("MALFORMED_RESPONSE", "Invalid response format from token refresh endpoint");
+  }
+};
+var refreshToken = async (config) => {
+  if (!config.refreshToken) {
+    throw createError2("UNAUTHORIZED", "Refresh token is not available");
+  } else if (!config.clientId || !config.clientSecret) {
+    throw createError2("UNAUTHORIZED", "Client ID and client secret are required for token refresh");
+  } else {
+    const body = new URLSearchParams({
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+      grant_type: "refresh_token",
+      refresh_token: config.refreshToken
+    });
+    const response = await doRefreshToken(body);
+    if (!response.ok) {
+      throw createError2("UNAUTHORIZED", "Token refresh failed");
+    } else {
+      const jsonData = await parseApiResponse(response.clone());
+      if (jsonData.access_token && jsonData.refresh_token) {
+        return {
+          access_token: jsonData.access_token,
+          refresh_token: jsonData.refresh_token
+        };
+      } else {
+        throw createError2("MALFORMED_RESPONSE", "Access token not found in refresh response");
+      }
+    }
+  }
+};
+var refresh_token_default = refreshToken;
+// client/handle-fetch-error/handle-fetch-error.ts
+var handleFetchError = async (fn, config, error) => {
+  const errorCode = parse_error_code_default(error);
+  const isRateLimitedError = errorCode === STRAVA_API_ERROR_CODES.RATE_LIMITED;
+  const isUnauthorizedError = errorCode === STRAVA_API_ERROR_CODES.UNAUTHORIZED;
+  if (isRateLimitedError) {
+    const errorWithResponse = error;
+    const rateLimitedResponse = errorWithResponse.response ?? new Response("Rate Limited", {
+      status: STRAVA_API_STATUS_CODES.RATE_LIMITED,
+      headers: { "Retry-After": "60" }
+    });
+    await handle_rate_limit_default(rateLimitedResponse);
+    throw error;
+  } else if (isUnauthorizedError) {
+    const canRefreshToken = Boolean(config.refreshToken) && Boolean(config.clientId) && Boolean(config.clientSecret);
+    if (canRefreshToken) {
+      try {
+        const { access_token } = await refresh_token_default(config);
+        const refreshedConfig = {
+          ...config,
+          accessToken: access_token
+        };
+        return await fn(refreshedConfig);
+      } catch {
+        throw error;
+      }
+    } else {
+      throw error;
+    }
+  } else {
+    throw error;
+  }
+};
+var handle_fetch_error_default = handleFetchError;
+// client/parse-response/parse-response.ts
+var parseApiResponse2 = async (response) => {
+  try {
+    const data = await response.json();
+    if (!data) {
+      throw create_error_default("MALFORMED_RESPONSE", "Expected non-empty response from Strava API", false);
+    } else {
+      return data;
+    }
+  } catch (error) {
+    const parsedError = parse_error_default(error);
+    if (parsedError) {
+      throw create_error_default("MALFORMED_RESPONSE", "Invalid response format from Strava API", false);
+    } else {
+      throw error;
+    }
+  }
+};
+var parseResponse = async (response) => {
+  const isUnauthorized = response.status === STRAVA_API_STATUS_CODES.UNAUTHORIZED;
+  const isForbidden = response.status === STRAVA_API_STATUS_CODES.FORBIDDEN;
+  const isRateLimited = response.status === STRAVA_API_STATUS_CODES.RATE_LIMITED;
+  const isServerError = response.status >= STRAVA_API_STATUS_CODES.SERVER_ERROR;
+  if (isUnauthorized) {
+    throw create_error_default("UNAUTHORIZED", "Authentication failed. Token may be expired or invalid.", false);
+  } else if (isForbidden) {
+    throw create_error_default("FORBIDDEN", "Insufficient permissions to access Strava API", false);
+  } else if (isRateLimited) {
+    throw create_error_default("RATE_LIMITED", "Rate limit exceeded. Please try again later.", true, response);
+  } else if (isServerError) {
+    throw create_error_default("SERVER_ERROR", "Strava API server error", true);
+  } else if (!response.ok) {
+    throw create_error_default("SERVER_ERROR", `Unexpected API error: ${response.status}`, false);
+  } else {
+    return parseApiResponse2(response);
+  }
+};
+var parse_response_default = parseResponse;
+// client/client.ts
+var doFetch = async (url, config) => {
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: get_auth_headers_default(config)
+    });
+    return parse_response_default(response);
+  } catch {
+    throw create_error_default("NETWORK_ERROR", "Failed to connect to Strava API", true);
+  }
+};
+var client = async (url, config) => {
+  try {
+    return await doFetch(url, config);
+  } catch (error) {
+    return await handle_fetch_error_default((newConfig) => doFetch(url, newConfig), config, error);
+  }
+};
+var client_default = client;
+// client/handle-retry/handle-retry.ts
+var parseError2 = (error) => {
+  try {
+    return JSON.parse(error.message);
+  } catch {
+    return null;
+  }
+};
+var attemptWithBackoff = async (fn, attemptIndex, maxRetries, currentBackoffMs, _previousError) => {
+  try {
+    return await fn();
+  } catch (error) {
+    const currentError = error;
+    const activityError = parseError2(currentError);
+    if (activityError !== null && activityError.retryable === false) {
+      throw currentError;
+    } else {
+      const isLastAttempt = attemptIndex >= maxRetries;
+      if (isLastAttempt) {
+        throw currentError;
+      } else {
+        const delayMs = Math.min(currentBackoffMs, STRAVA_API_MAX_BACKOFF_MS);
+        await new Promise((resolve) => {
+          setTimeout(resolve, delayMs);
+        });
+        const nextBackoffMs = currentBackoffMs * 2;
+        const nextAttemptIndex = attemptIndex + 1;
+        return attemptWithBackoff(fn, nextAttemptIndex, maxRetries, nextBackoffMs, currentError);
+      }
+    }
+  }
+};
+var handleRetry = async ({
+  fn,
+  maxRetries,
+  initialBackoffMs = STRAVA_API_INITIAL_BACKOFF_MS
+}) => attemptWithBackoff(fn, 0, maxRetries, initialBackoffMs, null);
+var handle_retry_default = handleRetry;
+// fetch-activity/fetch-activity.ts
+var fetchActivityWithValidation = async (config, activityId) => {
+  const activity = await client_default(`/activities/${activityId}`, config);
+  if (config.guardrails) {
+    const validationResult = activity ? config.guardrails.validate(activity) : { valid: false, errors: ["Activity is empty"] };
+    if (!validationResult.valid) {
+      const error = create_error_default("VALIDATION_FAILED", validationResult.errors?.join(", ") ?? "Activity validation failed", false);
+      throw new Error(JSON.stringify(error));
+    }
+  }
+  return activity;
+};
+var fetchActivity = async (activityId, config) => {
+  validate_activity_id_default(activityId);
+  return handle_retry_default({
+    maxRetries: STRAVA_API_MAX_RETRIES,
+    initialBackoffMs: STRAVA_API_INITIAL_BACKOFF_MS,
+    fn: async () => fetchActivityWithValidation(config, activityId)
+  });
+};
+var fetch_activity_default = fetchActivity;
+// fetch-activities/fetch-activities.ts
+var fetchActivities = async (config) => handle_retry_default({
+  maxRetries: STRAVA_API_MAX_RETRIES,
+  initialBackoffMs: STRAVA_API_INITIAL_BACKOFF_MS,
+  fn: () => client_default(STRAVA_API_ENDPOINTS.ACTIVITIES, config)
+});
+var fetch_activities_default = fetchActivities;
+// get-auth-url/get-auth-url.ts
+var getAuthUrl = (config) => {
+  if (!config.clientId) {
+    throw create_error_default("INVALID_CONFIG", "Client ID is required");
+  } else if (!config.redirectUri) {
+    throw create_error_default("INVALID_CONFIG", "Redirect URI is required");
+  } else {
+    const scope = config.scope ?? STRAVA_AUTH_DEFAULT_SCOPE;
+    const params = new URLSearchParams({
+      client_id: config.clientId,
+      response_type: "code",
+      redirect_uri: config.redirectUri,
+      scope,
+      approval_prompt: "force"
+    });
+    return `${STRAVA_API_ENDPOINTS.AUTH}?${params.toString()}`;
+  }
+};
+var get_auth_url_default = getAuthUrl;
+// exchange-token/exchange-token.ts
+var fetchTokenResponse = async (body) => {
+  try {
+    return await fetch(STRAVA_API_ENDPOINTS.TOKEN, {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+  } catch {
+    throw create_error_default("NETWORK_ERROR", "Failed to connect to Strava OAuth endpoint");
+  }
+};
+var parseTokenResponse = async (response) => {
+  try {
+    return await response.json();
+  } catch {
+    throw create_error_default("MALFORMED_RESPONSE", "Invalid response format from token endpoint");
+  }
+};
+var exchangeToken = async (authorizationCode, config) => {
+  if (!config.clientId || !config.clientSecret) {
+    throw create_error_default("INVALID_CONFIG", "Client ID and client secret are required");
+  } else if (!config.redirectUri) {
+    throw create_error_default("INVALID_CONFIG", "Redirect URI is required");
+  } else if (!authorizationCode) {
+    throw create_error_default("INVALID_CODE", "Authorization code is required");
+  } else {
+    const body = new URLSearchParams({
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+      code: authorizationCode,
+      grant_type: "authorization_code"
+    });
+    const response = await fetchTokenResponse(body);
+    if (response.ok) {
+      const tokenData = await parseTokenResponse(response.clone());
+      if (!tokenData.access_token) {
+        throw create_error_default("MALFORMED_RESPONSE", "Access token not found in response");
+      } else if (!tokenData.refresh_token) {
+        throw create_error_default("MALFORMED_RESPONSE", "Refresh token not found in response");
+      } else {
+        return tokenData;
+      }
+    } else {
+      if (response.status === 401 || response.status === 403) {
+        throw create_error_default("UNAUTHORIZED", "Invalid client credentials or authorization code");
+      } else {
+        throw create_error_default("UNAUTHORIZED", `Token exchange failed with status ${response.status}`);
+      }
+    }
+  }
+};
+var exchange_token_default = exchangeToken;
+export {
+  refresh_token_default as refreshStravaAuthToken,
+  get_auth_url_default as getStravaAuthUrl,
+  fetch_activity_default as fetchStravaActivity,
+  fetch_activities_default as fetchStravaActivities,
+  exchange_token_default as exchangeStravaAuthToken
+};

package/dist/refresh-token/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './refresh-token';
+//# sourceMappingURL=index.d.ts.map

package/dist/refresh-token/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../refresh-token/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/refresh-token/refresh-token.d.ts

@@ -0,0 +1,34 @@
+import type { StravaApiConfig } from '../types';
+import type { Output } from './types';
+/**
+ * Refreshes an expired OAuth2 access token using refresh token.
+ *
+ * Calls the Strava OAuth token refresh endpoint to obtain a new access token
+ * when the current one has expired. Requires refresh token, client ID, and
+ * client secret to be present in the configuration.
+ *
+ * @param {StravaApiConfig} config - API configuration.
+ * @returns {Promise<string>} Promise resolving to the new access token.
+ * @throws {Error} Throws an error for various failure scenarios:
+ *   - 'UNAUTHORIZED' (not retryable): Refresh token missing or invalid credentials
+ *   - 'NETWORK_ERROR' (not retryable): Network connection failure
+ *   - 'UNAUTHORIZED' (not retryable): Token refresh request failed
+ *   - 'MALFORMED_RESPONSE' (not retryable): Invalid JSON response or missing access_token
+ *   - And others...
+ *
+ * @see {@link https://developers.strava.com/docs/authentication/#refreshingexpiredaccesstokens | Strava Token Refresh}
+ * @see {@link https://www.oauth.com/oauth2-servers/access-tokens/refreshing-access-tokens/ | OAuth2 Token Refresh}
+ *
+ * @example
+ * ```typescript
+ * const newToken = await refreshToken({
+ *   accessToken: 'expired-token',
+ *   refreshToken: 'refresh-token-123',
+ *   clientId: 'client-id',
+ *   clientSecret: 'client-secret'
+ * });
+ * ```
+ */
+declare const refreshToken: (config: StravaApiConfig) => Promise<Output>;
+export default refreshToken;
+//# sourceMappingURL=refresh-token.d.ts.map

package/dist/refresh-token/refresh-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refresh-token.d.ts","sourceRoot":"","sources":["../../refresh-token/refresh-token.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EAIhB,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAuDtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,QAAA,MAAM,YAAY,GAAU,QAAQ,eAAe,KAAG,OAAO,CAAC,MAAM,CA8BnE,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/refresh-token/types.d.ts

@@ -0,0 +1,5 @@
+export interface Output {
+    access_token: string;
+    refresh_token: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/refresh-token/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../refresh-token/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,MAAM;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB"}

package/dist/types.d.ts

@@ -0,0 +1,192 @@
+import { STRAVA_API_ERROR_CODES } from './constants';
+export type StravaApiErrorCode = keyof typeof STRAVA_API_ERROR_CODES;
+export interface StravaApiError {
+    code: StravaApiErrorCode;
+    message: string;
+    retryable?: boolean;
+}
+export interface StravaApiErrorWithResponse extends Error {
+    response?: Response;
+}
+/**
+ * Entity validation result from Guardrails.
+ */
+export interface StravaApiConfigGuardrailsValidationResult {
+    /** Whether the entity is valid. */
+    valid: boolean;
+    /** Validation errors if any. */
+    errors?: string[];
+}
+export interface StravaApiConfig {
+    /** OAuth2 access token for Strava API. */
+    accessToken: string;
+    /** OAuth2 refresh token for token refresh. */
+    refreshToken?: string;
+    /** OAuth2 client ID for token refresh. */
+    clientId?: string;
+    /** OAuth2 client secret for token refresh. */
+    clientSecret?: string;
+    /** Guardrails instance for validation (dependency injection). */
+    guardrails?: {
+        /**
+         * Validates an entity and returns validation result.
+         * @param {object} input - The entity to validate
+         * @returns {StravaApiConfigGuardrailsValidationResult} Validation result
+         */
+        validate: (input: StravaActivity) => StravaApiConfigGuardrailsValidationResult;
+    };
+}
+export interface StravaApiTokenRefreshResponse {
+    access_token?: string;
+    refresh_token?: string;
+}
+/**
+ * Strava Activity type.
+ * The type is dictated by the Strava API and used internally by the system.
+ * @see {@link https://developers.strava.com/docs/reference/#api-Activities-getActivityById | Strava Activity Response Format}
+ */
+export interface StravaActivity {
+    id: number;
+    resource_state?: number;
+    external_id?: string;
+    upload_id?: number;
+    athlete?: {
+        id: number;
+        resource_state?: number;
+    };
+    name?: string;
+    distance?: number;
+    moving_time?: number;
+    elapsed_time?: number;
+    total_elevation_gain?: number;
+    type: string;
+    sport_type: string;
+    start_date?: string;
+    start_date_local?: string;
+    timezone?: string;
+    utc_offset?: number;
+    start_latlng?: [number, number];
+    end_latlng?: [number, number];
+    achievement_count?: number;
+    kudos_count?: number;
+    comment_count?: number;
+    athlete_count?: number;
+    photo_count?: number;
+    map?: {
+        id?: string;
+        polyline?: string;
+        resource_state?: number;
+        summary_polyline?: string;
+    };
+    trainer?: boolean;
+    commute?: boolean;
+    manual?: boolean;
+    private?: boolean;
+    flagged?: boolean;
+    gear_id?: string;
+    from_accepted_tag?: boolean;
+    average_speed?: number;
+    max_speed?: number;
+    average_cadence?: number;
+    average_temp?: number;
+    average_watts?: number;
+    weighted_average_watts?: number;
+    kilojoules?: number;
+    device_watts?: boolean;
+    has_heartrate?: boolean;
+    max_watts?: number;
+    elev_high?: number;
+    elev_low?: number;
+    pr_count?: number;
+    total_photo_count?: number;
+    has_kudoed?: boolean;
+    workout_type?: number;
+    suffer_score?: number | null;
+    description?: string;
+    calories?: number;
+    segment_efforts?: Record<string, unknown>[];
+    splits_metric?: Record<string, unknown>[];
+    laps?: Record<string, unknown>[];
+    gear?: {
+        id?: string;
+        primary?: boolean;
+        name?: string;
+        resource_state?: number;
+        distance?: number;
+    };
+    partner_brand_tag?: string | null;
+    photos?: Record<string, unknown>;
+    highlighted_kudosers?: Record<string, unknown>[];
+    hide_from_home?: boolean;
+    device_name?: string;
+    embed_token?: string;
+    segment_leaderboard_opt_out?: boolean;
+    leaderboard_opt_out?: boolean;
+}
+/**
+ * OAuth2 authorization configuration for Strava API.
+ */
+export interface StravaAuthConfig {
+    /** OAuth2 client ID from Strava application. */
+    clientId: string;
+    /** OAuth2 client secret from Strava application. */
+    clientSecret: string;
+    /** OAuth2 redirect URI (must match application settings). */
+    redirectUri: string;
+    /** OAuth2 scopes (e.g., 'activity:read' or 'activity:read_all'). */
+    scope?: string;
+}
+/**
+ * Token exchange response from Strava OAuth endpoint.
+ */
+export interface StravaAuthTokenResponse {
+    /** OAuth2 access token. */
+    access_token: string;
+    /** OAuth2 refresh token. */
+    refresh_token: string;
+    /** Token expiration timestamp (Unix time). */
+    expires_at: number;
+    /** Token expiration time in seconds. */
+    expires_in: number;
+    /** Token type (typically 'Bearer'). */
+    token_type: string;
+    /** Athlete information. */
+    athlete?: {
+        id: number;
+        username?: string;
+        resource_state?: number;
+        firstname?: string;
+        lastname?: string;
+        bio?: string;
+        city?: string;
+        state?: string;
+        country?: string;
+        sex?: string;
+        premium?: boolean;
+        summit?: boolean;
+        created_at?: string;
+        updated_at?: string;
+        badge_type_id?: number;
+        weight?: number;
+        profile_medium?: string;
+        profile?: string;
+        friend?: unknown;
+        follower?: unknown;
+    };
+}
+/**
+ * Token refresh response from Strava OAuth endpoint.
+ */
+export interface StravaAuthTokenRefreshResponse {
+    /** New OAuth2 access token. */
+    access_token: string;
+    /** New OAuth2 refresh token (optional, may not be provided). */
+    refresh_token?: string;
+    /** Token expiration timestamp (Unix time). */
+    expires_at: number;
+    /** Token expiration time in seconds. */
+    expires_in: number;
+    /** Token type (typically 'Bearer'). */
+    token_type: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAErD,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,sBAAsB,CAAC;AAErE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,0BAA2B,SAAQ,KAAK;IACvD,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,yCAAyC;IACxD,mCAAmC;IACnC,KAAK,EAAE,OAAO,CAAC;IACf,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,0CAA0C;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,UAAU,CAAC,EAAE;QACX;;;;WAIG;QACH,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,yCAAyC,CAAC;KAChF,CAAC;CACH;AAED,MAAM,WAAW,6BAA6B;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE;QACR,EAAE,EAAE,MAAM,CAAC;QACX,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE;QACJ,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACjC,IAAI,CAAC,EAAE;QACL,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACjD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,2BAA2B;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,4BAA4B;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,OAAO,CAAC,EAAE;QACR,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C,+BAA+B;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/validators/index.d.ts

@@ -0,0 +1,2 @@
+export { default as validateActivityId } from './validate-activity-id';
+//# sourceMappingURL=index.d.ts.map